1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_component::natural::*;
8
9 #[doc = " Payload for CapabilityRequested events\n"]
10 #[derive(Debug, Default, PartialEq)]
11 pub struct CapabilityRequestedPayload {
12 pub name: ::core::option::Option<::std::string::String>,
13
14 pub capability: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
15 }
16
17 impl CapabilityRequestedPayload {
18 fn __max_ordinal(&self) -> usize {
19 if self.capability.is_some() {
20 return 2;
21 }
22
23 if self.name.is_some() {
24 return 1;
25 }
26
27 0
28 }
29 }
30
31 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityRequestedPayload<'static>, ___E>
32 for CapabilityRequestedPayload
33 where
34 ___E: ::fidl_next::Encoder + ?Sized,
35 ___E: ::fidl_next::fuchsia::HandleEncoder,
36 {
37 #[inline]
38 fn encode(
39 mut self,
40 encoder: &mut ___E,
41 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRequestedPayload<'static>>,
42 _: (),
43 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44 ::fidl_next::munge!(let crate::wire::CapabilityRequestedPayload { table } = out);
45
46 let max_ord = self.__max_ordinal();
47
48 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
49 ::fidl_next::Wire::zero_padding(&mut out);
50
51 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
52 ::fidl_next::wire::Envelope,
53 >(encoder, max_ord);
54
55 for i in 1..=max_ord {
56 match i {
57 2 => {
58 if let Some(value) = self.capability.take() {
59 ::fidl_next::wire::Envelope::encode_value::<
60 ::fidl_next::wire::fuchsia::Channel,
61 ___E,
62 >(
63 value, preallocated.encoder, &mut out, ()
64 )?;
65 } else {
66 ::fidl_next::wire::Envelope::encode_zero(&mut out)
67 }
68 }
69
70 1 => {
71 if let Some(value) = self.name.take() {
72 ::fidl_next::wire::Envelope::encode_value::<
73 ::fidl_next::wire::String<'static>,
74 ___E,
75 >(
76 value, preallocated.encoder, &mut out, 255
77 )?;
78 } else {
79 ::fidl_next::wire::Envelope::encode_zero(&mut out)
80 }
81 }
82
83 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
84 }
85 unsafe {
86 preallocated.write_next(out.assume_init_ref());
87 }
88 }
89
90 ::fidl_next::wire::Table::encode_len(table, max_ord);
91
92 Ok(())
93 }
94 }
95
96 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityRequestedPayload<'de>>
97 for CapabilityRequestedPayload
98 {
99 #[inline]
100 fn from_wire(wire_: crate::wire::CapabilityRequestedPayload<'de>) -> Self {
101 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
102
103 let name = wire_.table.get(1);
104
105 let capability = wire_.table.get(2);
106
107 Self {
108 name: name.map(|envelope| {
109 ::fidl_next::FromWire::from_wire(unsafe {
110 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
111 })
112 }),
113
114 capability: capability.map(|envelope| {
115 ::fidl_next::FromWire::from_wire(unsafe {
116 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
117 })
118 }),
119 }
120 }
121 }
122
123 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
124 #[repr(C)]
125 pub struct ControllerIsStartedResponse {
126 pub is_started: bool,
127 }
128
129 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
130 for ControllerIsStartedResponse
131 where
132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
133 ___E: ::fidl_next::fuchsia::HandleEncoder,
134 {
135 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
136 Self,
137 crate::wire::ControllerIsStartedResponse,
138 > = unsafe {
139 ::fidl_next::CopyOptimization::enable_if(
140 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
141 )
142 };
143
144 #[inline]
145 fn encode(
146 self,
147 encoder_: &mut ___E,
148 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
149 _: (),
150 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
151 ::fidl_next::munge! {
152 let crate::wire::ControllerIsStartedResponse {
153 is_started,
154
155 } = out_;
156 }
157
158 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
159
160 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_started.as_mut_ptr()) };
161
162 Ok(())
163 }
164 }
165
166 unsafe impl<___E>
167 ::fidl_next::EncodeOption<
168 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
169 ___E,
170 > for ControllerIsStartedResponse
171 where
172 ___E: ::fidl_next::Encoder + ?Sized,
173 ControllerIsStartedResponse:
174 ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>,
175 {
176 #[inline]
177 fn encode_option(
178 this: ::core::option::Option<Self>,
179 encoder: &mut ___E,
180 out: &mut ::core::mem::MaybeUninit<
181 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
182 >,
183 _: (),
184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
185 if let Some(inner) = this {
186 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
187 ::fidl_next::wire::Box::encode_present(out);
188 } else {
189 ::fidl_next::wire::Box::encode_absent(out);
190 }
191
192 Ok(())
193 }
194 }
195
196 impl ::fidl_next::FromWire<crate::wire::ControllerIsStartedResponse>
197 for ControllerIsStartedResponse
198 {
199 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
200 crate::wire::ControllerIsStartedResponse,
201 Self,
202 > = unsafe {
203 ::fidl_next::CopyOptimization::enable_if(
204 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
205 )
206 };
207
208 #[inline]
209 fn from_wire(wire: crate::wire::ControllerIsStartedResponse) -> Self {
210 Self { is_started: ::fidl_next::FromWire::from_wire(wire.is_started) }
211 }
212 }
213
214 #[derive(Debug, PartialEq)]
215 #[repr(C)]
216 pub struct ControllerGetExposedDictionaryResponse {
217 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
218 }
219
220 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
221 for ControllerGetExposedDictionaryResponse
222 where
223 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
224 ___E: ::fidl_next::fuchsia::HandleEncoder,
225 {
226 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
227 Self,
228 crate::wire::ControllerGetExposedDictionaryResponse,
229 > = unsafe {
230 ::fidl_next::CopyOptimization::enable_if(
231 true
232
233 && <
234 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
235 >::COPY_OPTIMIZATION.is_enabled()
236
237 )
238 };
239
240 #[inline]
241 fn encode(
242 self,
243 encoder_: &mut ___E,
244 out_: &mut ::core::mem::MaybeUninit<
245 crate::wire::ControllerGetExposedDictionaryResponse,
246 >,
247 _: (),
248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
249 ::fidl_next::munge! {
250 let crate::wire::ControllerGetExposedDictionaryResponse {
251 dictionary,
252
253 } = out_;
254 }
255
256 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
257
258 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
259
260 Ok(())
261 }
262 }
263
264 unsafe impl<___E>
265 ::fidl_next::EncodeOption<
266 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetExposedDictionaryResponse>,
267 ___E,
268 > for ControllerGetExposedDictionaryResponse
269 where
270 ___E: ::fidl_next::Encoder + ?Sized,
271 ControllerGetExposedDictionaryResponse:
272 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>,
273 {
274 #[inline]
275 fn encode_option(
276 this: ::core::option::Option<Self>,
277 encoder: &mut ___E,
278 out: &mut ::core::mem::MaybeUninit<
279 ::fidl_next::wire::Box<
280 'static,
281 crate::wire::ControllerGetExposedDictionaryResponse,
282 >,
283 >,
284 _: (),
285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
286 if let Some(inner) = this {
287 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
288 ::fidl_next::wire::Box::encode_present(out);
289 } else {
290 ::fidl_next::wire::Box::encode_absent(out);
291 }
292
293 Ok(())
294 }
295 }
296
297 impl ::fidl_next::FromWire<crate::wire::ControllerGetExposedDictionaryResponse>
298 for ControllerGetExposedDictionaryResponse
299 {
300 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
301 crate::wire::ControllerGetExposedDictionaryResponse,
302 Self,
303 > = unsafe {
304 ::fidl_next::CopyOptimization::enable_if(
305 true
306
307 && <
308 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
309 >::COPY_OPTIMIZATION.is_enabled()
310
311 )
312 };
313
314 #[inline]
315 fn from_wire(wire: crate::wire::ControllerGetExposedDictionaryResponse) -> Self {
316 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
317 }
318 }
319
320 #[derive(Debug, PartialEq)]
321 #[repr(C)]
322 pub struct ControllerGetOutputDictionaryResponse {
323 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
324 }
325
326 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
327 for ControllerGetOutputDictionaryResponse
328 where
329 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
330 ___E: ::fidl_next::fuchsia::HandleEncoder,
331 {
332 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
333 Self,
334 crate::wire::ControllerGetOutputDictionaryResponse,
335 > = unsafe {
336 ::fidl_next::CopyOptimization::enable_if(
337 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
338 ::fidl_next::wire::fuchsia::EventPair,
339 ___E,
340 >>::COPY_OPTIMIZATION
341 .is_enabled(),
342 )
343 };
344
345 #[inline]
346 fn encode(
347 self,
348 encoder_: &mut ___E,
349 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
350 _: (),
351 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
352 ::fidl_next::munge! {
353 let crate::wire::ControllerGetOutputDictionaryResponse {
354 dictionary,
355
356 } = out_;
357 }
358
359 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
360
361 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
362
363 Ok(())
364 }
365 }
366
367 unsafe impl<___E>
368 ::fidl_next::EncodeOption<
369 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
370 ___E,
371 > for ControllerGetOutputDictionaryResponse
372 where
373 ___E: ::fidl_next::Encoder + ?Sized,
374 ControllerGetOutputDictionaryResponse:
375 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>,
376 {
377 #[inline]
378 fn encode_option(
379 this: ::core::option::Option<Self>,
380 encoder: &mut ___E,
381 out: &mut ::core::mem::MaybeUninit<
382 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
383 >,
384 _: (),
385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
386 if let Some(inner) = this {
387 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
388 ::fidl_next::wire::Box::encode_present(out);
389 } else {
390 ::fidl_next::wire::Box::encode_absent(out);
391 }
392
393 Ok(())
394 }
395 }
396
397 impl ::fidl_next::FromWire<crate::wire::ControllerGetOutputDictionaryResponse>
398 for ControllerGetOutputDictionaryResponse
399 {
400 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
401 crate::wire::ControllerGetOutputDictionaryResponse,
402 Self,
403 > = unsafe {
404 ::fidl_next::CopyOptimization::enable_if(
405 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
406 ::fidl_next::wire::fuchsia::EventPair,
407 >>::COPY_OPTIMIZATION
408 .is_enabled(),
409 )
410 };
411
412 #[inline]
413 fn from_wire(wire: crate::wire::ControllerGetOutputDictionaryResponse) -> Self {
414 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
415 }
416 }
417
418 #[doc = " A single component namespace entry, which describes a namespace mount point\n (`path`) and the directory backing it (`directory`). This type is usually\n composed inside a vector. See `ComponentStartInfo.ns` for more details.\n"]
419 #[derive(Debug, Default, PartialEq)]
420 pub struct NamespaceEntry {
421 pub path: ::core::option::Option<::std::string::String>,
422
423 pub directory: ::core::option::Option<
424 ::fidl_next::ClientEnd<
425 ::fidl_next_fuchsia_io::Directory,
426 ::fidl_next::fuchsia::zx::Channel,
427 >,
428 >,
429 }
430
431 impl NamespaceEntry {
432 fn __max_ordinal(&self) -> usize {
433 if self.directory.is_some() {
434 return 2;
435 }
436
437 if self.path.is_some() {
438 return 1;
439 }
440
441 0
442 }
443 }
444
445 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceEntry<'static>, ___E> for NamespaceEntry
446 where
447 ___E: ::fidl_next::Encoder + ?Sized,
448 ___E: ::fidl_next::fuchsia::HandleEncoder,
449 {
450 #[inline]
451 fn encode(
452 mut self,
453 encoder: &mut ___E,
454 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceEntry<'static>>,
455 _: (),
456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
457 ::fidl_next::munge!(let crate::wire::NamespaceEntry { table } = out);
458
459 let max_ord = self.__max_ordinal();
460
461 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
462 ::fidl_next::Wire::zero_padding(&mut out);
463
464 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
465 ::fidl_next::wire::Envelope,
466 >(encoder, max_ord);
467
468 for i in 1..=max_ord {
469 match i {
470 2 => {
471 if let Some(value) = self.directory.take() {
472 ::fidl_next::wire::Envelope::encode_value::<
473 ::fidl_next::ClientEnd<
474 ::fidl_next_fuchsia_io::Directory,
475 ::fidl_next::wire::fuchsia::Channel,
476 >,
477 ___E,
478 >(
479 value, preallocated.encoder, &mut out, ()
480 )?;
481 } else {
482 ::fidl_next::wire::Envelope::encode_zero(&mut out)
483 }
484 }
485
486 1 => {
487 if let Some(value) = self.path.take() {
488 ::fidl_next::wire::Envelope::encode_value::<
489 ::fidl_next::wire::String<'static>,
490 ___E,
491 >(
492 value, preallocated.encoder, &mut out, 4095
493 )?;
494 } else {
495 ::fidl_next::wire::Envelope::encode_zero(&mut out)
496 }
497 }
498
499 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
500 }
501 unsafe {
502 preallocated.write_next(out.assume_init_ref());
503 }
504 }
505
506 ::fidl_next::wire::Table::encode_len(table, max_ord);
507
508 Ok(())
509 }
510 }
511
512 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceEntry<'de>> for NamespaceEntry {
513 #[inline]
514 fn from_wire(wire_: crate::wire::NamespaceEntry<'de>) -> Self {
515 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
516
517 let path = wire_.table.get(1);
518
519 let directory = wire_.table.get(2);
520
521 Self {
522 path: path.map(|envelope| {
523 ::fidl_next::FromWire::from_wire(unsafe {
524 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
525 })
526 }),
527
528 directory: directory.map(|envelope| {
529 ::fidl_next::FromWire::from_wire(unsafe {
530 envelope.read_unchecked::<::fidl_next::ClientEnd<
531 ::fidl_next_fuchsia_io::Directory,
532 ::fidl_next::wire::fuchsia::Channel,
533 >>()
534 })
535 }),
536 }
537 }
538 }
539
540 #[derive(Debug, Default, PartialEq)]
541 pub struct StartChildArgs {
542 pub numbered_handles: ::core::option::Option<
543 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
544 >,
545
546 pub namespace_entries:
547 ::core::option::Option<::std::vec::Vec<crate::natural::NamespaceEntry>>,
548
549 pub dictionary:
550 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
551
552 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
553 }
554
555 impl StartChildArgs {
556 fn __max_ordinal(&self) -> usize {
557 if self.additional_inputs.is_some() {
558 return 4;
559 }
560
561 if self.dictionary.is_some() {
562 return 3;
563 }
564
565 if self.namespace_entries.is_some() {
566 return 2;
567 }
568
569 if self.numbered_handles.is_some() {
570 return 1;
571 }
572
573 0
574 }
575 }
576
577 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E> for StartChildArgs
578 where
579 ___E: ::fidl_next::Encoder + ?Sized,
580 ___E: ::fidl_next::fuchsia::HandleEncoder,
581 {
582 #[inline]
583 fn encode(
584 mut self,
585 encoder: &mut ___E,
586 out: &mut ::core::mem::MaybeUninit<crate::wire::StartChildArgs<'static>>,
587 _: (),
588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
589 ::fidl_next::munge!(let crate::wire::StartChildArgs { table } = out);
590
591 let max_ord = self.__max_ordinal();
592
593 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
594 ::fidl_next::Wire::zero_padding(&mut out);
595
596 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
597 ::fidl_next::wire::Envelope,
598 >(encoder, max_ord);
599
600 for i in 1..=max_ord {
601 match i {
602 4 => {
603 if let Some(value) = self.additional_inputs.take() {
604 ::fidl_next::wire::Envelope::encode_value::<
605 ::fidl_next::wire::fuchsia::EventPair,
606 ___E,
607 >(
608 value, preallocated.encoder, &mut out, ()
609 )?;
610 } else {
611 ::fidl_next::wire::Envelope::encode_zero(&mut out)
612 }
613 }
614
615 3 => {
616 if let Some(value) = self.dictionary.take() {
617 ::fidl_next::wire::Envelope::encode_value::<
618 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
619 ___E,
620 >(
621 value, preallocated.encoder, &mut out, ()
622 )?;
623 } else {
624 ::fidl_next::wire::Envelope::encode_zero(&mut out)
625 }
626 }
627
628 2 => {
629 if let Some(value) = self.namespace_entries.take() {
630 ::fidl_next::wire::Envelope::encode_value::<
631 ::fidl_next::wire::Vector<
632 'static,
633 crate::wire::NamespaceEntry<'static>,
634 >,
635 ___E,
636 >(
637 value, preallocated.encoder, &mut out, (32, ())
638 )?;
639 } else {
640 ::fidl_next::wire::Envelope::encode_zero(&mut out)
641 }
642 }
643
644 1 => {
645 if let Some(value) = self.numbered_handles.take() {
646 ::fidl_next::wire::Envelope::encode_value::<
647 ::fidl_next::wire::Vector<
648 'static,
649 ::fidl_next_fuchsia_process::wire::HandleInfo,
650 >,
651 ___E,
652 >(
653 value, preallocated.encoder, &mut out, (128, ())
654 )?;
655 } else {
656 ::fidl_next::wire::Envelope::encode_zero(&mut out)
657 }
658 }
659
660 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
661 }
662 unsafe {
663 preallocated.write_next(out.assume_init_ref());
664 }
665 }
666
667 ::fidl_next::wire::Table::encode_len(table, max_ord);
668
669 Ok(())
670 }
671 }
672
673 impl<'de> ::fidl_next::FromWire<crate::wire::StartChildArgs<'de>> for StartChildArgs {
674 #[inline]
675 fn from_wire(wire_: crate::wire::StartChildArgs<'de>) -> Self {
676 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
677
678 let numbered_handles = wire_.table.get(1);
679
680 let namespace_entries = wire_.table.get(2);
681
682 let dictionary = wire_.table.get(3);
683
684 let additional_inputs = wire_.table.get(4);
685
686 Self {
687
688
689 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
690 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
691 )),
692
693
694 namespace_entries: namespace_entries.map(|envelope| ::fidl_next::FromWire::from_wire(
695 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>() }
696 )),
697
698
699 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
700 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
701 )),
702
703
704 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
705 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
706 )),
707
708 }
709 }
710 }
711
712 #[derive(Debug, PartialEq)]
713 pub struct ControllerStartRequest {
714 pub args: crate::natural::StartChildArgs,
715
716 pub execution_controller:
717 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::fuchsia::zx::Channel>,
718 }
719
720 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
721 for ControllerStartRequest
722 where
723 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
724 ___E: ::fidl_next::Encoder,
725 ___E: ::fidl_next::fuchsia::HandleEncoder,
726 {
727 #[inline]
728 fn encode(
729 self,
730 encoder_: &mut ___E,
731 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
732 _: (),
733 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
734 ::fidl_next::munge! {
735 let crate::wire::ControllerStartRequest {
736 args,
737 execution_controller,
738
739 } = out_;
740 }
741
742 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
743
744 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
745
746 ::fidl_next::Encode::encode(
747 self.execution_controller,
748 encoder_,
749 execution_controller,
750 (),
751 )?;
752
753 let mut _field =
754 unsafe { ::fidl_next::Slot::new_unchecked(execution_controller.as_mut_ptr()) };
755
756 Ok(())
757 }
758 }
759
760 unsafe impl<___E>
761 ::fidl_next::EncodeOption<
762 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
763 ___E,
764 > for ControllerStartRequest
765 where
766 ___E: ::fidl_next::Encoder + ?Sized,
767 ControllerStartRequest:
768 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>,
769 {
770 #[inline]
771 fn encode_option(
772 this: ::core::option::Option<Self>,
773 encoder: &mut ___E,
774 out: &mut ::core::mem::MaybeUninit<
775 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
776 >,
777 _: (),
778 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
779 if let Some(inner) = this {
780 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
781 ::fidl_next::wire::Box::encode_present(out);
782 } else {
783 ::fidl_next::wire::Box::encode_absent(out);
784 }
785
786 Ok(())
787 }
788 }
789
790 impl<'de> ::fidl_next::FromWire<crate::wire::ControllerStartRequest<'de>>
791 for ControllerStartRequest
792 {
793 #[inline]
794 fn from_wire(wire: crate::wire::ControllerStartRequest<'de>) -> Self {
795 Self {
796 args: ::fidl_next::FromWire::from_wire(wire.args),
797
798 execution_controller: ::fidl_next::FromWire::from_wire(wire.execution_controller),
799 }
800 }
801 }
802
803 #[derive(Debug, PartialEq)]
804 #[repr(C)]
805 pub struct ControllerOpenExposedDirRequest {
806 pub exposed_dir: ::fidl_next::ServerEnd<
807 ::fidl_next_fuchsia_io::Directory,
808 ::fidl_next::fuchsia::zx::Channel,
809 >,
810 }
811
812 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
813 for ControllerOpenExposedDirRequest
814 where
815 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
816 ___E: ::fidl_next::fuchsia::HandleEncoder,
817 {
818 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
819 Self,
820 crate::wire::ControllerOpenExposedDirRequest,
821 > = unsafe {
822 ::fidl_next::CopyOptimization::enable_if(
823 true && <::fidl_next::ServerEnd<
824 ::fidl_next_fuchsia_io::Directory,
825 ::fidl_next::fuchsia::zx::Channel,
826 > as ::fidl_next::Encode<
827 ::fidl_next::ServerEnd<
828 ::fidl_next_fuchsia_io::Directory,
829 ::fidl_next::wire::fuchsia::Channel,
830 >,
831 ___E,
832 >>::COPY_OPTIMIZATION
833 .is_enabled(),
834 )
835 };
836
837 #[inline]
838 fn encode(
839 self,
840 encoder_: &mut ___E,
841 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
842 _: (),
843 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
844 ::fidl_next::munge! {
845 let crate::wire::ControllerOpenExposedDirRequest {
846 exposed_dir,
847
848 } = out_;
849 }
850
851 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
852
853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
854
855 Ok(())
856 }
857 }
858
859 unsafe impl<___E>
860 ::fidl_next::EncodeOption<
861 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
862 ___E,
863 > for ControllerOpenExposedDirRequest
864 where
865 ___E: ::fidl_next::Encoder + ?Sized,
866 ControllerOpenExposedDirRequest:
867 ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>,
868 {
869 #[inline]
870 fn encode_option(
871 this: ::core::option::Option<Self>,
872 encoder: &mut ___E,
873 out: &mut ::core::mem::MaybeUninit<
874 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
875 >,
876 _: (),
877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
878 if let Some(inner) = this {
879 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
880 ::fidl_next::wire::Box::encode_present(out);
881 } else {
882 ::fidl_next::wire::Box::encode_absent(out);
883 }
884
885 Ok(())
886 }
887 }
888
889 impl ::fidl_next::FromWire<crate::wire::ControllerOpenExposedDirRequest>
890 for ControllerOpenExposedDirRequest
891 {
892 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
893 crate::wire::ControllerOpenExposedDirRequest,
894 Self,
895 > = unsafe {
896 ::fidl_next::CopyOptimization::enable_if(
897 true && <::fidl_next::ServerEnd<
898 ::fidl_next_fuchsia_io::Directory,
899 ::fidl_next::fuchsia::zx::Channel,
900 > as ::fidl_next::FromWire<
901 ::fidl_next::ServerEnd<
902 ::fidl_next_fuchsia_io::Directory,
903 ::fidl_next::wire::fuchsia::Channel,
904 >,
905 >>::COPY_OPTIMIZATION
906 .is_enabled(),
907 )
908 };
909
910 #[inline]
911 fn from_wire(wire: crate::wire::ControllerOpenExposedDirRequest) -> Self {
912 Self { exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir) }
913 }
914 }
915
916 #[derive(Debug, Default, PartialEq)]
917 pub struct CreateChildArgs {
918 pub numbered_handles: ::core::option::Option<
919 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
920 >,
921
922 pub dynamic_offers: ::core::option::Option<
923 ::std::vec::Vec<::fidl_next_fuchsia_component_decl::natural::Offer>,
924 >,
925
926 pub controller: ::core::option::Option<
927 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
928 >,
929
930 pub dictionary:
931 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
932
933 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
934 }
935
936 impl CreateChildArgs {
937 fn __max_ordinal(&self) -> usize {
938 if self.additional_inputs.is_some() {
939 return 5;
940 }
941
942 if self.dictionary.is_some() {
943 return 4;
944 }
945
946 if self.controller.is_some() {
947 return 3;
948 }
949
950 if self.dynamic_offers.is_some() {
951 return 2;
952 }
953
954 if self.numbered_handles.is_some() {
955 return 1;
956 }
957
958 0
959 }
960 }
961
962 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>
963 for CreateChildArgs
964 where
965 ___E: ::fidl_next::Encoder + ?Sized,
966 ___E: ::fidl_next::fuchsia::HandleEncoder,
967 {
968 #[inline]
969 fn encode(
970 mut self,
971 encoder: &mut ___E,
972 out: &mut ::core::mem::MaybeUninit<crate::wire::CreateChildArgs<'static>>,
973 _: (),
974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
975 ::fidl_next::munge!(let crate::wire::CreateChildArgs { table } = out);
976
977 let max_ord = self.__max_ordinal();
978
979 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
980 ::fidl_next::Wire::zero_padding(&mut out);
981
982 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
983 ::fidl_next::wire::Envelope,
984 >(encoder, max_ord);
985
986 for i in 1..=max_ord {
987 match i {
988 5 => {
989 if let Some(value) = self.additional_inputs.take() {
990 ::fidl_next::wire::Envelope::encode_value::<
991 ::fidl_next::wire::fuchsia::EventPair,
992 ___E,
993 >(
994 value, preallocated.encoder, &mut out, ()
995 )?;
996 } else {
997 ::fidl_next::wire::Envelope::encode_zero(&mut out)
998 }
999 }
1000
1001 4 => {
1002 if let Some(value) = self.dictionary.take() {
1003 ::fidl_next::wire::Envelope::encode_value::<
1004 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
1005 ___E,
1006 >(
1007 value, preallocated.encoder, &mut out, ()
1008 )?;
1009 } else {
1010 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1011 }
1012 }
1013
1014 3 => {
1015 if let Some(value) = self.controller.take() {
1016 ::fidl_next::wire::Envelope::encode_value::<
1017 ::fidl_next::ServerEnd<
1018 crate::Controller,
1019 ::fidl_next::wire::fuchsia::Channel,
1020 >,
1021 ___E,
1022 >(
1023 value, preallocated.encoder, &mut out, ()
1024 )?;
1025 } else {
1026 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1027 }
1028 }
1029
1030 2 => {
1031 if let Some(value) = self.dynamic_offers.take() {
1032 ::fidl_next::wire::Envelope::encode_value::<
1033 ::fidl_next::wire::Vector<
1034 'static,
1035 ::fidl_next_fuchsia_component_decl::wire::Offer<'static>,
1036 >,
1037 ___E,
1038 >(
1039 value, preallocated.encoder, &mut out, (128, ())
1040 )?;
1041 } else {
1042 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1043 }
1044 }
1045
1046 1 => {
1047 if let Some(value) = self.numbered_handles.take() {
1048 ::fidl_next::wire::Envelope::encode_value::<
1049 ::fidl_next::wire::Vector<
1050 'static,
1051 ::fidl_next_fuchsia_process::wire::HandleInfo,
1052 >,
1053 ___E,
1054 >(
1055 value, preallocated.encoder, &mut out, (128, ())
1056 )?;
1057 } else {
1058 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1059 }
1060 }
1061
1062 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1063 }
1064 unsafe {
1065 preallocated.write_next(out.assume_init_ref());
1066 }
1067 }
1068
1069 ::fidl_next::wire::Table::encode_len(table, max_ord);
1070
1071 Ok(())
1072 }
1073 }
1074
1075 impl<'de> ::fidl_next::FromWire<crate::wire::CreateChildArgs<'de>> for CreateChildArgs {
1076 #[inline]
1077 fn from_wire(wire_: crate::wire::CreateChildArgs<'de>) -> Self {
1078 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1079
1080 let numbered_handles = wire_.table.get(1);
1081
1082 let dynamic_offers = wire_.table.get(2);
1083
1084 let controller = wire_.table.get(3);
1085
1086 let dictionary = wire_.table.get(4);
1087
1088 let additional_inputs = wire_.table.get(5);
1089
1090 Self {
1091
1092
1093 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
1094 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
1095 )),
1096
1097
1098 dynamic_offers: dynamic_offers.map(|envelope| ::fidl_next::FromWire::from_wire(
1099 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>>() }
1100 )),
1101
1102
1103 controller: controller.map(|envelope| ::fidl_next::FromWire::from_wire(
1104 unsafe { envelope.read_unchecked::<::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>>() }
1105 )),
1106
1107
1108 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
1109 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
1110 )),
1111
1112
1113 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
1114 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
1115 )),
1116
1117 }
1118 }
1119 }
1120
1121 #[doc = " Payload for DebugStarted events.\n"]
1122 #[derive(Debug, Default, PartialEq)]
1123 pub struct DebugStartedPayload {
1124 pub runtime_dir: ::core::option::Option<
1125 ::fidl_next::ClientEnd<
1126 ::fidl_next_fuchsia_io::Directory,
1127 ::fidl_next::fuchsia::zx::Channel,
1128 >,
1129 >,
1130
1131 pub break_on_start: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
1132 }
1133
1134 impl DebugStartedPayload {
1135 fn __max_ordinal(&self) -> usize {
1136 if self.break_on_start.is_some() {
1137 return 2;
1138 }
1139
1140 if self.runtime_dir.is_some() {
1141 return 1;
1142 }
1143
1144 0
1145 }
1146 }
1147
1148 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugStartedPayload<'static>, ___E>
1149 for DebugStartedPayload
1150 where
1151 ___E: ::fidl_next::Encoder + ?Sized,
1152 ___E: ::fidl_next::fuchsia::HandleEncoder,
1153 {
1154 #[inline]
1155 fn encode(
1156 mut self,
1157 encoder: &mut ___E,
1158 out: &mut ::core::mem::MaybeUninit<crate::wire::DebugStartedPayload<'static>>,
1159 _: (),
1160 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1161 ::fidl_next::munge!(let crate::wire::DebugStartedPayload { table } = out);
1162
1163 let max_ord = self.__max_ordinal();
1164
1165 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1166 ::fidl_next::Wire::zero_padding(&mut out);
1167
1168 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1169 ::fidl_next::wire::Envelope,
1170 >(encoder, max_ord);
1171
1172 for i in 1..=max_ord {
1173 match i {
1174 2 => {
1175 if let Some(value) = self.break_on_start.take() {
1176 ::fidl_next::wire::Envelope::encode_value::<
1177 ::fidl_next::wire::fuchsia::EventPair,
1178 ___E,
1179 >(
1180 value, preallocated.encoder, &mut out, ()
1181 )?;
1182 } else {
1183 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1184 }
1185 }
1186
1187 1 => {
1188 if let Some(value) = self.runtime_dir.take() {
1189 ::fidl_next::wire::Envelope::encode_value::<
1190 ::fidl_next::ClientEnd<
1191 ::fidl_next_fuchsia_io::Directory,
1192 ::fidl_next::wire::fuchsia::Channel,
1193 >,
1194 ___E,
1195 >(
1196 value, preallocated.encoder, &mut out, ()
1197 )?;
1198 } else {
1199 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1200 }
1201 }
1202
1203 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1204 }
1205 unsafe {
1206 preallocated.write_next(out.assume_init_ref());
1207 }
1208 }
1209
1210 ::fidl_next::wire::Table::encode_len(table, max_ord);
1211
1212 Ok(())
1213 }
1214 }
1215
1216 impl<'de> ::fidl_next::FromWire<crate::wire::DebugStartedPayload<'de>> for DebugStartedPayload {
1217 #[inline]
1218 fn from_wire(wire_: crate::wire::DebugStartedPayload<'de>) -> Self {
1219 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1220
1221 let runtime_dir = wire_.table.get(1);
1222
1223 let break_on_start = wire_.table.get(2);
1224
1225 Self {
1226 runtime_dir: runtime_dir.map(|envelope| {
1227 ::fidl_next::FromWire::from_wire(unsafe {
1228 envelope.read_unchecked::<::fidl_next::ClientEnd<
1229 ::fidl_next_fuchsia_io::Directory,
1230 ::fidl_next::wire::fuchsia::Channel,
1231 >>()
1232 })
1233 }),
1234
1235 break_on_start: break_on_start.map(|envelope| {
1236 ::fidl_next::FromWire::from_wire(unsafe {
1237 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
1238 })
1239 }),
1240 }
1241 }
1242 }
1243
1244 #[doc = " Encapsulates additional data/protocols for some event types.\n"]
1245 #[derive(Debug, PartialEq)]
1246 pub enum EventPayload {
1247 CapabilityRequested(crate::natural::CapabilityRequestedPayload),
1248
1249 Purged(crate::natural::PurgedPayload),
1250
1251 Discovered(crate::natural::DiscoveredPayload),
1252
1253 Destroyed(crate::natural::DestroyedPayload),
1254
1255 Resolved(crate::natural::ResolvedPayload),
1256
1257 Started(crate::natural::StartedPayload),
1258
1259 Stopped(crate::natural::StoppedPayload),
1260
1261 DebugStarted(crate::natural::DebugStartedPayload),
1262
1263 Unresolved(crate::natural::UnresolvedPayload),
1264
1265 UnknownOrdinal_(u64),
1266 }
1267
1268 impl EventPayload {
1269 pub fn is_unknown(&self) -> bool {
1270 #[allow(unreachable_patterns)]
1271 match self {
1272 Self::UnknownOrdinal_(_) => true,
1273 _ => false,
1274 }
1275 }
1276 }
1277
1278 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E> for EventPayload
1279 where
1280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1281 ___E: ::fidl_next::Encoder,
1282 ___E: ::fidl_next::fuchsia::HandleEncoder,
1283 {
1284 #[inline]
1285 fn encode(
1286 self,
1287 encoder: &mut ___E,
1288 out: &mut ::core::mem::MaybeUninit<crate::wire::EventPayload<'static>>,
1289 _: (),
1290 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1291 ::fidl_next::munge!(let crate::wire::EventPayload { raw, _phantom: _ } = out);
1292
1293 match self {
1294 Self::CapabilityRequested(value) => ::fidl_next::wire::Union::encode_as::<
1295 ___E,
1296 crate::wire::CapabilityRequestedPayload<'static>,
1297 >(value, 1, encoder, raw, ())?,
1298
1299 Self::Purged(value) => ::fidl_next::wire::Union::encode_as::<
1300 ___E,
1301 crate::wire::PurgedPayload<'static>,
1302 >(value, 2, encoder, raw, ())?,
1303
1304 Self::Discovered(value) => ::fidl_next::wire::Union::encode_as::<
1305 ___E,
1306 crate::wire::DiscoveredPayload<'static>,
1307 >(value, 4, encoder, raw, ())?,
1308
1309 Self::Destroyed(value) => ::fidl_next::wire::Union::encode_as::<
1310 ___E,
1311 crate::wire::DestroyedPayload<'static>,
1312 >(value, 5, encoder, raw, ())?,
1313
1314 Self::Resolved(value) => ::fidl_next::wire::Union::encode_as::<
1315 ___E,
1316 crate::wire::ResolvedPayload<'static>,
1317 >(value, 6, encoder, raw, ())?,
1318
1319 Self::Started(value) => ::fidl_next::wire::Union::encode_as::<
1320 ___E,
1321 crate::wire::StartedPayload<'static>,
1322 >(value, 7, encoder, raw, ())?,
1323
1324 Self::Stopped(value) => ::fidl_next::wire::Union::encode_as::<
1325 ___E,
1326 crate::wire::StoppedPayload<'static>,
1327 >(value, 8, encoder, raw, ())?,
1328
1329 Self::DebugStarted(value) => ::fidl_next::wire::Union::encode_as::<
1330 ___E,
1331 crate::wire::DebugStartedPayload<'static>,
1332 >(value, 9, encoder, raw, ())?,
1333
1334 Self::Unresolved(value) => ::fidl_next::wire::Union::encode_as::<
1335 ___E,
1336 crate::wire::UnresolvedPayload<'static>,
1337 >(value, 10, encoder, raw, ())?,
1338
1339 Self::UnknownOrdinal_(ordinal) => {
1340 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1341 }
1342 }
1343
1344 Ok(())
1345 }
1346 }
1347
1348 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::EventPayload<'static>, ___E>
1349 for EventPayload
1350 where
1351 ___E: ?Sized,
1352 EventPayload: ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E>,
1353 {
1354 #[inline]
1355 fn encode_option(
1356 this: ::core::option::Option<Self>,
1357 encoder: &mut ___E,
1358 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::EventPayload<'static>>,
1359 _: (),
1360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1361 ::fidl_next::munge!(let crate::wire_optional::EventPayload { raw, _phantom: _ } = &mut *out);
1362
1363 if let Some(inner) = this {
1364 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1365 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1366 } else {
1367 ::fidl_next::wire::Union::encode_absent(raw);
1368 }
1369
1370 Ok(())
1371 }
1372 }
1373
1374 impl<'de> ::fidl_next::FromWire<crate::wire::EventPayload<'de>> for EventPayload {
1375 #[inline]
1376 fn from_wire(wire: crate::wire::EventPayload<'de>) -> Self {
1377 let wire = ::core::mem::ManuallyDrop::new(wire);
1378 match wire.raw.ordinal() {
1379 1 => Self::CapabilityRequested(::fidl_next::FromWire::from_wire(unsafe {
1380 wire.raw.get().read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
1381 })),
1382
1383 2 => Self::Purged(::fidl_next::FromWire::from_wire(unsafe {
1384 wire.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
1385 })),
1386
1387 4 => Self::Discovered(::fidl_next::FromWire::from_wire(unsafe {
1388 wire.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
1389 })),
1390
1391 5 => Self::Destroyed(::fidl_next::FromWire::from_wire(unsafe {
1392 wire.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
1393 })),
1394
1395 6 => Self::Resolved(::fidl_next::FromWire::from_wire(unsafe {
1396 wire.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
1397 })),
1398
1399 7 => Self::Started(::fidl_next::FromWire::from_wire(unsafe {
1400 wire.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
1401 })),
1402
1403 8 => Self::Stopped(::fidl_next::FromWire::from_wire(unsafe {
1404 wire.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
1405 })),
1406
1407 9 => Self::DebugStarted(::fidl_next::FromWire::from_wire(unsafe {
1408 wire.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
1409 })),
1410
1411 10 => Self::Unresolved(::fidl_next::FromWire::from_wire(unsafe {
1412 wire.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
1413 })),
1414
1415 ord => return Self::UnknownOrdinal_(ord as u64),
1416 }
1417 }
1418 }
1419
1420 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>> for EventPayload {
1421 #[inline]
1422 fn from_wire_option(
1423 wire: crate::wire_optional::EventPayload<'de>,
1424 ) -> ::core::option::Option<Self> {
1425 if let Some(inner) = wire.into_option() {
1426 Some(::fidl_next::FromWire::from_wire(inner))
1427 } else {
1428 None
1429 }
1430 }
1431 }
1432
1433 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1434 for Box<EventPayload>
1435 {
1436 #[inline]
1437 fn from_wire_option(
1438 wire: crate::wire_optional::EventPayload<'de>,
1439 ) -> ::core::option::Option<Self> {
1440 <
1441 EventPayload as ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1442 >::from_wire_option(wire).map(Box::new)
1443 }
1444 }
1445
1446 #[doc = " Contains all information about a single event\n"]
1447 #[derive(Debug, Default, PartialEq)]
1448 pub struct Event {
1449 pub header: ::core::option::Option<crate::natural::EventHeader>,
1450
1451 pub payload: ::core::option::Option<crate::natural::EventPayload>,
1452 }
1453
1454 impl Event {
1455 fn __max_ordinal(&self) -> usize {
1456 if self.payload.is_some() {
1457 return 2;
1458 }
1459
1460 if self.header.is_some() {
1461 return 1;
1462 }
1463
1464 0
1465 }
1466 }
1467
1468 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Event<'static>, ___E> for Event
1469 where
1470 ___E: ::fidl_next::Encoder + ?Sized,
1471 ___E: ::fidl_next::fuchsia::HandleEncoder,
1472 {
1473 #[inline]
1474 fn encode(
1475 mut self,
1476 encoder: &mut ___E,
1477 out: &mut ::core::mem::MaybeUninit<crate::wire::Event<'static>>,
1478 _: (),
1479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1480 ::fidl_next::munge!(let crate::wire::Event { table } = out);
1481
1482 let max_ord = self.__max_ordinal();
1483
1484 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1485 ::fidl_next::Wire::zero_padding(&mut out);
1486
1487 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1488 ::fidl_next::wire::Envelope,
1489 >(encoder, max_ord);
1490
1491 for i in 1..=max_ord {
1492 match i {
1493 2 => {
1494 if let Some(value) = self.payload.take() {
1495 ::fidl_next::wire::Envelope::encode_value::<
1496 crate::wire::EventPayload<'static>,
1497 ___E,
1498 >(
1499 value, preallocated.encoder, &mut out, ()
1500 )?;
1501 } else {
1502 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1503 }
1504 }
1505
1506 1 => {
1507 if let Some(value) = self.header.take() {
1508 ::fidl_next::wire::Envelope::encode_value::<
1509 crate::wire::EventHeader<'static>,
1510 ___E,
1511 >(
1512 value, preallocated.encoder, &mut out, ()
1513 )?;
1514 } else {
1515 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1516 }
1517 }
1518
1519 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1520 }
1521 unsafe {
1522 preallocated.write_next(out.assume_init_ref());
1523 }
1524 }
1525
1526 ::fidl_next::wire::Table::encode_len(table, max_ord);
1527
1528 Ok(())
1529 }
1530 }
1531
1532 impl<'de> ::fidl_next::FromWire<crate::wire::Event<'de>> for Event {
1533 #[inline]
1534 fn from_wire(wire_: crate::wire::Event<'de>) -> Self {
1535 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1536
1537 let header = wire_.table.get(1);
1538
1539 let payload = wire_.table.get(2);
1540
1541 Self {
1542 header: header.map(|envelope| {
1543 ::fidl_next::FromWire::from_wire(unsafe {
1544 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
1545 })
1546 }),
1547
1548 payload: payload.map(|envelope| {
1549 ::fidl_next::FromWire::from_wire(unsafe {
1550 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
1551 })
1552 }),
1553 }
1554 }
1555 }
1556
1557 #[derive(Debug, PartialEq)]
1558 pub struct EventStreamGetNextResponse {
1559 pub events: ::std::vec::Vec<crate::natural::Event>,
1560 }
1561
1562 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
1563 for EventStreamGetNextResponse
1564 where
1565 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1566 ___E: ::fidl_next::Encoder,
1567 ___E: ::fidl_next::fuchsia::HandleEncoder,
1568 {
1569 #[inline]
1570 fn encode(
1571 self,
1572 encoder_: &mut ___E,
1573 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
1574 _: (),
1575 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1576 ::fidl_next::munge! {
1577 let crate::wire::EventStreamGetNextResponse {
1578 events,
1579
1580 } = out_;
1581 }
1582
1583 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
1584
1585 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(events.as_mut_ptr()) };
1586 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1587
1588 Ok(())
1589 }
1590 }
1591
1592 unsafe impl<___E>
1593 ::fidl_next::EncodeOption<
1594 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1595 ___E,
1596 > for EventStreamGetNextResponse
1597 where
1598 ___E: ::fidl_next::Encoder + ?Sized,
1599 EventStreamGetNextResponse:
1600 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>,
1601 {
1602 #[inline]
1603 fn encode_option(
1604 this: ::core::option::Option<Self>,
1605 encoder: &mut ___E,
1606 out: &mut ::core::mem::MaybeUninit<
1607 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1608 >,
1609 _: (),
1610 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1611 if let Some(inner) = this {
1612 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1613 ::fidl_next::wire::Box::encode_present(out);
1614 } else {
1615 ::fidl_next::wire::Box::encode_absent(out);
1616 }
1617
1618 Ok(())
1619 }
1620 }
1621
1622 impl<'de> ::fidl_next::FromWire<crate::wire::EventStreamGetNextResponse<'de>>
1623 for EventStreamGetNextResponse
1624 {
1625 #[inline]
1626 fn from_wire(wire: crate::wire::EventStreamGetNextResponse<'de>) -> Self {
1627 Self { events: ::fidl_next::FromWire::from_wire(wire.events) }
1628 }
1629 }
1630
1631 #[derive(Debug, PartialEq)]
1632 #[repr(C)]
1633 pub struct IntrospectorGetMonikerRequest {
1634 pub component_instance: ::fidl_next::fuchsia::zx::Event,
1635 }
1636
1637 unsafe impl<___E> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
1638 for IntrospectorGetMonikerRequest
1639 where
1640 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1641 ___E: ::fidl_next::fuchsia::HandleEncoder,
1642 {
1643 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1644 Self,
1645 crate::wire::IntrospectorGetMonikerRequest,
1646 > = unsafe {
1647 ::fidl_next::CopyOptimization::enable_if(
1648 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
1649 ::fidl_next::wire::fuchsia::Event,
1650 ___E,
1651 >>::COPY_OPTIMIZATION
1652 .is_enabled(),
1653 )
1654 };
1655
1656 #[inline]
1657 fn encode(
1658 self,
1659 encoder_: &mut ___E,
1660 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
1661 _: (),
1662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1663 ::fidl_next::munge! {
1664 let crate::wire::IntrospectorGetMonikerRequest {
1665 component_instance,
1666
1667 } = out_;
1668 }
1669
1670 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
1671
1672 let mut _field =
1673 unsafe { ::fidl_next::Slot::new_unchecked(component_instance.as_mut_ptr()) };
1674
1675 Ok(())
1676 }
1677 }
1678
1679 unsafe impl<___E>
1680 ::fidl_next::EncodeOption<
1681 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1682 ___E,
1683 > for IntrospectorGetMonikerRequest
1684 where
1685 ___E: ::fidl_next::Encoder + ?Sized,
1686 IntrospectorGetMonikerRequest:
1687 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>,
1688 {
1689 #[inline]
1690 fn encode_option(
1691 this: ::core::option::Option<Self>,
1692 encoder: &mut ___E,
1693 out: &mut ::core::mem::MaybeUninit<
1694 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1695 >,
1696 _: (),
1697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1698 if let Some(inner) = this {
1699 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1700 ::fidl_next::wire::Box::encode_present(out);
1701 } else {
1702 ::fidl_next::wire::Box::encode_absent(out);
1703 }
1704
1705 Ok(())
1706 }
1707 }
1708
1709 impl ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerRequest>
1710 for IntrospectorGetMonikerRequest
1711 {
1712 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1713 crate::wire::IntrospectorGetMonikerRequest,
1714 Self,
1715 > = unsafe {
1716 ::fidl_next::CopyOptimization::enable_if(
1717 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
1718 ::fidl_next::wire::fuchsia::Event,
1719 >>::COPY_OPTIMIZATION
1720 .is_enabled(),
1721 )
1722 };
1723
1724 #[inline]
1725 fn from_wire(wire: crate::wire::IntrospectorGetMonikerRequest) -> Self {
1726 Self { component_instance: ::fidl_next::FromWire::from_wire(wire.component_instance) }
1727 }
1728 }
1729
1730 #[derive(Debug, PartialEq)]
1731 pub struct NamespaceInputEntry {
1732 pub path: ::std::string::String,
1733
1734 pub dictionary: ::fidl_next::ClientEnd<
1735 ::fidl_next_fuchsia_component_sandbox::Dictionary,
1736 ::fidl_next::fuchsia::zx::Channel,
1737 >,
1738 }
1739
1740 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
1741 for NamespaceInputEntry
1742 where
1743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1744 ___E: ::fidl_next::Encoder,
1745 ___E: ::fidl_next::fuchsia::HandleEncoder,
1746 {
1747 #[inline]
1748 fn encode(
1749 self,
1750 encoder_: &mut ___E,
1751 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
1752 _: (),
1753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1754 ::fidl_next::munge! {
1755 let crate::wire::NamespaceInputEntry {
1756 path,
1757 dictionary,
1758
1759 } = out_;
1760 }
1761
1762 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1763
1764 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1765 ::fidl_next::Constrained::validate(_field, 4095)?;
1766
1767 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
1768
1769 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
1770
1771 Ok(())
1772 }
1773 }
1774
1775 unsafe impl<___E>
1776 ::fidl_next::EncodeOption<
1777 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1778 ___E,
1779 > for NamespaceInputEntry
1780 where
1781 ___E: ::fidl_next::Encoder + ?Sized,
1782 NamespaceInputEntry: ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>,
1783 {
1784 #[inline]
1785 fn encode_option(
1786 this: ::core::option::Option<Self>,
1787 encoder: &mut ___E,
1788 out: &mut ::core::mem::MaybeUninit<
1789 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1790 >,
1791 _: (),
1792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1793 if let Some(inner) = this {
1794 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1795 ::fidl_next::wire::Box::encode_present(out);
1796 } else {
1797 ::fidl_next::wire::Box::encode_absent(out);
1798 }
1799
1800 Ok(())
1801 }
1802 }
1803
1804 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry<'de>> for NamespaceInputEntry {
1805 #[inline]
1806 fn from_wire(wire: crate::wire::NamespaceInputEntry<'de>) -> Self {
1807 Self {
1808 path: ::fidl_next::FromWire::from_wire(wire.path),
1809
1810 dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary),
1811 }
1812 }
1813 }
1814
1815 #[derive(Debug, PartialEq)]
1816 pub struct NamespaceCreateRequest {
1817 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry>,
1818 }
1819
1820 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
1821 for NamespaceCreateRequest
1822 where
1823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1824 ___E: ::fidl_next::Encoder,
1825 ___E: ::fidl_next::fuchsia::HandleEncoder,
1826 {
1827 #[inline]
1828 fn encode(
1829 self,
1830 encoder_: &mut ___E,
1831 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
1832 _: (),
1833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1834 ::fidl_next::munge! {
1835 let crate::wire::NamespaceCreateRequest {
1836 entries,
1837
1838 } = out_;
1839 }
1840
1841 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1842
1843 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
1844 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1845
1846 Ok(())
1847 }
1848 }
1849
1850 unsafe impl<___E>
1851 ::fidl_next::EncodeOption<
1852 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1853 ___E,
1854 > for NamespaceCreateRequest
1855 where
1856 ___E: ::fidl_next::Encoder + ?Sized,
1857 NamespaceCreateRequest:
1858 ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>,
1859 {
1860 #[inline]
1861 fn encode_option(
1862 this: ::core::option::Option<Self>,
1863 encoder: &mut ___E,
1864 out: &mut ::core::mem::MaybeUninit<
1865 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1866 >,
1867 _: (),
1868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1869 if let Some(inner) = this {
1870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1871 ::fidl_next::wire::Box::encode_present(out);
1872 } else {
1873 ::fidl_next::wire::Box::encode_absent(out);
1874 }
1875
1876 Ok(())
1877 }
1878 }
1879
1880 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateRequest<'de>>
1881 for NamespaceCreateRequest
1882 {
1883 #[inline]
1884 fn from_wire(wire: crate::wire::NamespaceCreateRequest<'de>) -> Self {
1885 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
1886 }
1887 }
1888
1889 #[derive(Debug, PartialEq)]
1890 pub struct NamespaceInputEntry2 {
1891 pub path: ::std::string::String,
1892
1893 pub capability: ::fidl_next::fuchsia::zx::EventPair,
1894 }
1895
1896 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
1897 for NamespaceInputEntry2
1898 where
1899 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1900 ___E: ::fidl_next::Encoder,
1901 ___E: ::fidl_next::fuchsia::HandleEncoder,
1902 {
1903 #[inline]
1904 fn encode(
1905 self,
1906 encoder_: &mut ___E,
1907 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
1908 _: (),
1909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1910 ::fidl_next::munge! {
1911 let crate::wire::NamespaceInputEntry2 {
1912 path,
1913 capability,
1914
1915 } = out_;
1916 }
1917
1918 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1919
1920 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1921 ::fidl_next::Constrained::validate(_field, 4095)?;
1922
1923 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1924
1925 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1926
1927 Ok(())
1928 }
1929 }
1930
1931 unsafe impl<___E>
1932 ::fidl_next::EncodeOption<
1933 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1934 ___E,
1935 > for NamespaceInputEntry2
1936 where
1937 ___E: ::fidl_next::Encoder + ?Sized,
1938 NamespaceInputEntry2: ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>,
1939 {
1940 #[inline]
1941 fn encode_option(
1942 this: ::core::option::Option<Self>,
1943 encoder: &mut ___E,
1944 out: &mut ::core::mem::MaybeUninit<
1945 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1946 >,
1947 _: (),
1948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1949 if let Some(inner) = this {
1950 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1951 ::fidl_next::wire::Box::encode_present(out);
1952 } else {
1953 ::fidl_next::wire::Box::encode_absent(out);
1954 }
1955
1956 Ok(())
1957 }
1958 }
1959
1960 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry2<'de>> for NamespaceInputEntry2 {
1961 #[inline]
1962 fn from_wire(wire: crate::wire::NamespaceInputEntry2<'de>) -> Self {
1963 Self {
1964 path: ::fidl_next::FromWire::from_wire(wire.path),
1965
1966 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1967 }
1968 }
1969 }
1970
1971 #[derive(Debug, PartialEq)]
1972 pub struct NamespaceCreate2Request {
1973 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry2>,
1974 }
1975
1976 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
1977 for NamespaceCreate2Request
1978 where
1979 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1980 ___E: ::fidl_next::Encoder,
1981 ___E: ::fidl_next::fuchsia::HandleEncoder,
1982 {
1983 #[inline]
1984 fn encode(
1985 self,
1986 encoder_: &mut ___E,
1987 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
1988 _: (),
1989 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1990 ::fidl_next::munge! {
1991 let crate::wire::NamespaceCreate2Request {
1992 entries,
1993
1994 } = out_;
1995 }
1996
1997 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1998
1999 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2000 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2001
2002 Ok(())
2003 }
2004 }
2005
2006 unsafe impl<___E>
2007 ::fidl_next::EncodeOption<
2008 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2009 ___E,
2010 > for NamespaceCreate2Request
2011 where
2012 ___E: ::fidl_next::Encoder + ?Sized,
2013 NamespaceCreate2Request:
2014 ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>,
2015 {
2016 #[inline]
2017 fn encode_option(
2018 this: ::core::option::Option<Self>,
2019 encoder: &mut ___E,
2020 out: &mut ::core::mem::MaybeUninit<
2021 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2022 >,
2023 _: (),
2024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2025 if let Some(inner) = this {
2026 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2027 ::fidl_next::wire::Box::encode_present(out);
2028 } else {
2029 ::fidl_next::wire::Box::encode_absent(out);
2030 }
2031
2032 Ok(())
2033 }
2034 }
2035
2036 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Request<'de>>
2037 for NamespaceCreate2Request
2038 {
2039 #[inline]
2040 fn from_wire(wire: crate::wire::NamespaceCreate2Request<'de>) -> Self {
2041 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2042 }
2043 }
2044
2045 #[derive(Debug, PartialEq)]
2046 pub struct NamespaceCreateResponse {
2047 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2048 }
2049
2050 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
2051 for NamespaceCreateResponse
2052 where
2053 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2054 ___E: ::fidl_next::Encoder,
2055 ___E: ::fidl_next::fuchsia::HandleEncoder,
2056 {
2057 #[inline]
2058 fn encode(
2059 self,
2060 encoder_: &mut ___E,
2061 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
2062 _: (),
2063 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2064 ::fidl_next::munge! {
2065 let crate::wire::NamespaceCreateResponse {
2066 entries,
2067
2068 } = out_;
2069 }
2070
2071 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2072
2073 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2074 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2075
2076 Ok(())
2077 }
2078 }
2079
2080 unsafe impl<___E>
2081 ::fidl_next::EncodeOption<
2082 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2083 ___E,
2084 > for NamespaceCreateResponse
2085 where
2086 ___E: ::fidl_next::Encoder + ?Sized,
2087 NamespaceCreateResponse:
2088 ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>,
2089 {
2090 #[inline]
2091 fn encode_option(
2092 this: ::core::option::Option<Self>,
2093 encoder: &mut ___E,
2094 out: &mut ::core::mem::MaybeUninit<
2095 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2096 >,
2097 _: (),
2098 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2099 if let Some(inner) = this {
2100 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2101 ::fidl_next::wire::Box::encode_present(out);
2102 } else {
2103 ::fidl_next::wire::Box::encode_absent(out);
2104 }
2105
2106 Ok(())
2107 }
2108 }
2109
2110 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateResponse<'de>>
2111 for NamespaceCreateResponse
2112 {
2113 #[inline]
2114 fn from_wire(wire: crate::wire::NamespaceCreateResponse<'de>) -> Self {
2115 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2116 }
2117 }
2118
2119 #[derive(Debug, PartialEq)]
2120 pub struct NamespaceCreate2Response {
2121 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2122 }
2123
2124 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
2125 for NamespaceCreate2Response
2126 where
2127 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2128 ___E: ::fidl_next::Encoder,
2129 ___E: ::fidl_next::fuchsia::HandleEncoder,
2130 {
2131 #[inline]
2132 fn encode(
2133 self,
2134 encoder_: &mut ___E,
2135 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
2136 _: (),
2137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2138 ::fidl_next::munge! {
2139 let crate::wire::NamespaceCreate2Response {
2140 entries,
2141
2142 } = out_;
2143 }
2144
2145 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2146
2147 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2148 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2149
2150 Ok(())
2151 }
2152 }
2153
2154 unsafe impl<___E>
2155 ::fidl_next::EncodeOption<
2156 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2157 ___E,
2158 > for NamespaceCreate2Response
2159 where
2160 ___E: ::fidl_next::Encoder + ?Sized,
2161 NamespaceCreate2Response:
2162 ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>,
2163 {
2164 #[inline]
2165 fn encode_option(
2166 this: ::core::option::Option<Self>,
2167 encoder: &mut ___E,
2168 out: &mut ::core::mem::MaybeUninit<
2169 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2170 >,
2171 _: (),
2172 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2173 if let Some(inner) = this {
2174 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2175 ::fidl_next::wire::Box::encode_present(out);
2176 } else {
2177 ::fidl_next::wire::Box::encode_absent(out);
2178 }
2179
2180 Ok(())
2181 }
2182 }
2183
2184 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Response<'de>>
2185 for NamespaceCreate2Response
2186 {
2187 #[inline]
2188 fn from_wire(wire: crate::wire::NamespaceCreate2Response<'de>) -> Self {
2189 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2190 }
2191 }
2192
2193 #[derive(Debug, PartialEq)]
2194 pub struct RealmListChildrenRequest {
2195 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2196
2197 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::fuchsia::zx::Channel>,
2198 }
2199
2200 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
2201 for RealmListChildrenRequest
2202 where
2203 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2204 ___E: ::fidl_next::Encoder,
2205 ___E: ::fidl_next::fuchsia::HandleEncoder,
2206 {
2207 #[inline]
2208 fn encode(
2209 self,
2210 encoder_: &mut ___E,
2211 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
2212 _: (),
2213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2214 ::fidl_next::munge! {
2215 let crate::wire::RealmListChildrenRequest {
2216 collection,
2217 iter,
2218
2219 } = out_;
2220 }
2221
2222 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2223
2224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2225
2226 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
2227
2228 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iter.as_mut_ptr()) };
2229
2230 Ok(())
2231 }
2232 }
2233
2234 unsafe impl<___E>
2235 ::fidl_next::EncodeOption<
2236 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2237 ___E,
2238 > for RealmListChildrenRequest
2239 where
2240 ___E: ::fidl_next::Encoder + ?Sized,
2241 RealmListChildrenRequest:
2242 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>,
2243 {
2244 #[inline]
2245 fn encode_option(
2246 this: ::core::option::Option<Self>,
2247 encoder: &mut ___E,
2248 out: &mut ::core::mem::MaybeUninit<
2249 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2250 >,
2251 _: (),
2252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2253 if let Some(inner) = this {
2254 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2255 ::fidl_next::wire::Box::encode_present(out);
2256 } else {
2257 ::fidl_next::wire::Box::encode_absent(out);
2258 }
2259
2260 Ok(())
2261 }
2262 }
2263
2264 impl<'de> ::fidl_next::FromWire<crate::wire::RealmListChildrenRequest<'de>>
2265 for RealmListChildrenRequest
2266 {
2267 #[inline]
2268 fn from_wire(wire: crate::wire::RealmListChildrenRequest<'de>) -> Self {
2269 Self {
2270 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2271
2272 iter: ::fidl_next::FromWire::from_wire(wire.iter),
2273 }
2274 }
2275 }
2276
2277 #[derive(Debug, Clone, PartialEq)]
2278 pub struct RealmGetChildOutputDictionaryDeprecatedRequest {
2279 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2280 }
2281
2282 unsafe impl<___E>
2283 ::fidl_next::Encode<
2284 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2285 ___E,
2286 > for RealmGetChildOutputDictionaryDeprecatedRequest
2287 where
2288 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2289 ___E: ::fidl_next::Encoder,
2290 ___E: ::fidl_next::fuchsia::HandleEncoder,
2291 {
2292 #[inline]
2293 fn encode(
2294 self,
2295 encoder_: &mut ___E,
2296 out_: &mut ::core::mem::MaybeUninit<
2297 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2298 >,
2299 _: (),
2300 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2301 ::fidl_next::munge! {
2302 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
2303 child,
2304
2305 } = out_;
2306 }
2307
2308 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2309
2310 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2311
2312 Ok(())
2313 }
2314 }
2315
2316 unsafe impl<___E>
2317 ::fidl_next::EncodeOption<
2318 ::fidl_next::wire::Box<
2319 'static,
2320 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2321 >,
2322 ___E,
2323 > for RealmGetChildOutputDictionaryDeprecatedRequest
2324 where
2325 ___E: ::fidl_next::Encoder + ?Sized,
2326 RealmGetChildOutputDictionaryDeprecatedRequest: ::fidl_next::Encode<
2327 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2328 ___E,
2329 >,
2330 {
2331 #[inline]
2332 fn encode_option(
2333 this: ::core::option::Option<Self>,
2334 encoder: &mut ___E,
2335 out: &mut ::core::mem::MaybeUninit<
2336 ::fidl_next::wire::Box<
2337 'static,
2338 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2339 >,
2340 >,
2341 _: (),
2342 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2343 if let Some(inner) = this {
2344 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2345 ::fidl_next::wire::Box::encode_present(out);
2346 } else {
2347 ::fidl_next::wire::Box::encode_absent(out);
2348 }
2349
2350 Ok(())
2351 }
2352 }
2353
2354 impl<'de>
2355 ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>>
2356 for RealmGetChildOutputDictionaryDeprecatedRequest
2357 {
2358 #[inline]
2359 fn from_wire(
2360 wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>,
2361 ) -> Self {
2362 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2363 }
2364 }
2365
2366 #[derive(Debug, PartialEq)]
2367 #[repr(C)]
2368 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
2369 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
2370 }
2371
2372 unsafe impl<___E>
2373 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
2374 for RealmGetChildOutputDictionaryDeprecatedResponse
2375 where
2376 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2377 ___E: ::fidl_next::fuchsia::HandleEncoder,
2378 {
2379 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2380 Self,
2381 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2382 > = unsafe {
2383 ::fidl_next::CopyOptimization::enable_if(
2384 true
2385
2386 && <
2387 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
2388 >::COPY_OPTIMIZATION.is_enabled()
2389
2390 )
2391 };
2392
2393 #[inline]
2394 fn encode(
2395 self,
2396 encoder_: &mut ___E,
2397 out_: &mut ::core::mem::MaybeUninit<
2398 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2399 >,
2400 _: (),
2401 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2402 ::fidl_next::munge! {
2403 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
2404 dictionary,
2405
2406 } = out_;
2407 }
2408
2409 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2410
2411 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2412
2413 Ok(())
2414 }
2415 }
2416
2417 unsafe impl<___E>
2418 ::fidl_next::EncodeOption<
2419 ::fidl_next::wire::Box<
2420 'static,
2421 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2422 >,
2423 ___E,
2424 > for RealmGetChildOutputDictionaryDeprecatedResponse
2425 where
2426 ___E: ::fidl_next::Encoder + ?Sized,
2427 RealmGetChildOutputDictionaryDeprecatedResponse:
2428 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>,
2429 {
2430 #[inline]
2431 fn encode_option(
2432 this: ::core::option::Option<Self>,
2433 encoder: &mut ___E,
2434 out: &mut ::core::mem::MaybeUninit<
2435 ::fidl_next::wire::Box<
2436 'static,
2437 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2438 >,
2439 >,
2440 _: (),
2441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2442 if let Some(inner) = this {
2443 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2444 ::fidl_next::wire::Box::encode_present(out);
2445 } else {
2446 ::fidl_next::wire::Box::encode_absent(out);
2447 }
2448
2449 Ok(())
2450 }
2451 }
2452
2453 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse>
2454 for RealmGetChildOutputDictionaryDeprecatedResponse
2455 {
2456 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2457 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2458 Self,
2459 > = unsafe {
2460 ::fidl_next::CopyOptimization::enable_if(
2461 true
2462
2463 && <
2464 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
2465 >::COPY_OPTIMIZATION.is_enabled()
2466
2467 )
2468 };
2469
2470 #[inline]
2471 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse) -> Self {
2472 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2473 }
2474 }
2475
2476 #[derive(Debug, Clone, PartialEq)]
2477 pub struct RealmGetChildOutputDictionaryRequest {
2478 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2479 }
2480
2481 unsafe impl<___E>
2482 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
2483 for RealmGetChildOutputDictionaryRequest
2484 where
2485 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2486 ___E: ::fidl_next::Encoder,
2487 ___E: ::fidl_next::fuchsia::HandleEncoder,
2488 {
2489 #[inline]
2490 fn encode(
2491 self,
2492 encoder_: &mut ___E,
2493 out_: &mut ::core::mem::MaybeUninit<
2494 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2495 >,
2496 _: (),
2497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2498 ::fidl_next::munge! {
2499 let crate::wire::RealmGetChildOutputDictionaryRequest {
2500 child,
2501
2502 } = out_;
2503 }
2504
2505 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2506
2507 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2508
2509 Ok(())
2510 }
2511 }
2512
2513 unsafe impl<___E>
2514 ::fidl_next::EncodeOption<
2515 ::fidl_next::wire::Box<
2516 'static,
2517 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2518 >,
2519 ___E,
2520 > for RealmGetChildOutputDictionaryRequest
2521 where
2522 ___E: ::fidl_next::Encoder + ?Sized,
2523 RealmGetChildOutputDictionaryRequest:
2524 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>,
2525 {
2526 #[inline]
2527 fn encode_option(
2528 this: ::core::option::Option<Self>,
2529 encoder: &mut ___E,
2530 out: &mut ::core::mem::MaybeUninit<
2531 ::fidl_next::wire::Box<
2532 'static,
2533 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2534 >,
2535 >,
2536 _: (),
2537 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2538 if let Some(inner) = this {
2539 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2540 ::fidl_next::wire::Box::encode_present(out);
2541 } else {
2542 ::fidl_next::wire::Box::encode_absent(out);
2543 }
2544
2545 Ok(())
2546 }
2547 }
2548
2549 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryRequest<'de>>
2550 for RealmGetChildOutputDictionaryRequest
2551 {
2552 #[inline]
2553 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryRequest<'de>) -> Self {
2554 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2555 }
2556 }
2557
2558 #[derive(Debug, PartialEq)]
2559 #[repr(C)]
2560 pub struct RealmGetChildOutputDictionaryResponse {
2561 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
2562 }
2563
2564 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
2565 for RealmGetChildOutputDictionaryResponse
2566 where
2567 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2568 ___E: ::fidl_next::fuchsia::HandleEncoder,
2569 {
2570 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2571 Self,
2572 crate::wire::RealmGetChildOutputDictionaryResponse,
2573 > = unsafe {
2574 ::fidl_next::CopyOptimization::enable_if(
2575 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
2576 ::fidl_next::wire::fuchsia::EventPair,
2577 ___E,
2578 >>::COPY_OPTIMIZATION
2579 .is_enabled(),
2580 )
2581 };
2582
2583 #[inline]
2584 fn encode(
2585 self,
2586 encoder_: &mut ___E,
2587 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
2588 _: (),
2589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590 ::fidl_next::munge! {
2591 let crate::wire::RealmGetChildOutputDictionaryResponse {
2592 dictionary,
2593
2594 } = out_;
2595 }
2596
2597 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2598
2599 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2600
2601 Ok(())
2602 }
2603 }
2604
2605 unsafe impl<___E>
2606 ::fidl_next::EncodeOption<
2607 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2608 ___E,
2609 > for RealmGetChildOutputDictionaryResponse
2610 where
2611 ___E: ::fidl_next::Encoder + ?Sized,
2612 RealmGetChildOutputDictionaryResponse:
2613 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>,
2614 {
2615 #[inline]
2616 fn encode_option(
2617 this: ::core::option::Option<Self>,
2618 encoder: &mut ___E,
2619 out: &mut ::core::mem::MaybeUninit<
2620 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2621 >,
2622 _: (),
2623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2624 if let Some(inner) = this {
2625 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2626 ::fidl_next::wire::Box::encode_present(out);
2627 } else {
2628 ::fidl_next::wire::Box::encode_absent(out);
2629 }
2630
2631 Ok(())
2632 }
2633 }
2634
2635 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryResponse>
2636 for RealmGetChildOutputDictionaryResponse
2637 {
2638 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2639 crate::wire::RealmGetChildOutputDictionaryResponse,
2640 Self,
2641 > = unsafe {
2642 ::fidl_next::CopyOptimization::enable_if(
2643 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
2644 ::fidl_next::wire::fuchsia::EventPair,
2645 >>::COPY_OPTIMIZATION
2646 .is_enabled(),
2647 )
2648 };
2649
2650 #[inline]
2651 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryResponse) -> Self {
2652 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2653 }
2654 }
2655
2656 #[derive(Debug, PartialEq)]
2657 pub struct RealmOpenControllerRequest {
2658 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2659
2660 pub controller:
2661 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
2662 }
2663
2664 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
2665 for RealmOpenControllerRequest
2666 where
2667 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2668 ___E: ::fidl_next::Encoder,
2669 ___E: ::fidl_next::fuchsia::HandleEncoder,
2670 {
2671 #[inline]
2672 fn encode(
2673 self,
2674 encoder_: &mut ___E,
2675 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
2676 _: (),
2677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2678 ::fidl_next::munge! {
2679 let crate::wire::RealmOpenControllerRequest {
2680 child,
2681 controller,
2682
2683 } = out_;
2684 }
2685
2686 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2687
2688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2689
2690 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
2691
2692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(controller.as_mut_ptr()) };
2693
2694 Ok(())
2695 }
2696 }
2697
2698 unsafe impl<___E>
2699 ::fidl_next::EncodeOption<
2700 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2701 ___E,
2702 > for RealmOpenControllerRequest
2703 where
2704 ___E: ::fidl_next::Encoder + ?Sized,
2705 RealmOpenControllerRequest:
2706 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>,
2707 {
2708 #[inline]
2709 fn encode_option(
2710 this: ::core::option::Option<Self>,
2711 encoder: &mut ___E,
2712 out: &mut ::core::mem::MaybeUninit<
2713 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2714 >,
2715 _: (),
2716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2717 if let Some(inner) = this {
2718 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2719 ::fidl_next::wire::Box::encode_present(out);
2720 } else {
2721 ::fidl_next::wire::Box::encode_absent(out);
2722 }
2723
2724 Ok(())
2725 }
2726 }
2727
2728 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenControllerRequest<'de>>
2729 for RealmOpenControllerRequest
2730 {
2731 #[inline]
2732 fn from_wire(wire: crate::wire::RealmOpenControllerRequest<'de>) -> Self {
2733 Self {
2734 child: ::fidl_next::FromWire::from_wire(wire.child),
2735
2736 controller: ::fidl_next::FromWire::from_wire(wire.controller),
2737 }
2738 }
2739 }
2740
2741 #[derive(Debug, PartialEq)]
2742 pub struct RealmOpenExposedDirRequest {
2743 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2744
2745 pub exposed_dir: ::fidl_next::ServerEnd<
2746 ::fidl_next_fuchsia_io::Directory,
2747 ::fidl_next::fuchsia::zx::Channel,
2748 >,
2749 }
2750
2751 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
2752 for RealmOpenExposedDirRequest
2753 where
2754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2755 ___E: ::fidl_next::Encoder,
2756 ___E: ::fidl_next::fuchsia::HandleEncoder,
2757 {
2758 #[inline]
2759 fn encode(
2760 self,
2761 encoder_: &mut ___E,
2762 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
2763 _: (),
2764 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2765 ::fidl_next::munge! {
2766 let crate::wire::RealmOpenExposedDirRequest {
2767 child,
2768 exposed_dir,
2769
2770 } = out_;
2771 }
2772
2773 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2774
2775 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2776
2777 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
2778
2779 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
2780
2781 Ok(())
2782 }
2783 }
2784
2785 unsafe impl<___E>
2786 ::fidl_next::EncodeOption<
2787 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2788 ___E,
2789 > for RealmOpenExposedDirRequest
2790 where
2791 ___E: ::fidl_next::Encoder + ?Sized,
2792 RealmOpenExposedDirRequest:
2793 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>,
2794 {
2795 #[inline]
2796 fn encode_option(
2797 this: ::core::option::Option<Self>,
2798 encoder: &mut ___E,
2799 out: &mut ::core::mem::MaybeUninit<
2800 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2801 >,
2802 _: (),
2803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2804 if let Some(inner) = this {
2805 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2806 ::fidl_next::wire::Box::encode_present(out);
2807 } else {
2808 ::fidl_next::wire::Box::encode_absent(out);
2809 }
2810
2811 Ok(())
2812 }
2813 }
2814
2815 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenExposedDirRequest<'de>>
2816 for RealmOpenExposedDirRequest
2817 {
2818 #[inline]
2819 fn from_wire(wire: crate::wire::RealmOpenExposedDirRequest<'de>) -> Self {
2820 Self {
2821 child: ::fidl_next::FromWire::from_wire(wire.child),
2822
2823 exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir),
2824 }
2825 }
2826 }
2827
2828 #[derive(Debug, PartialEq)]
2829 pub struct RealmCreateChildRequest {
2830 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2831
2832 pub decl: ::fidl_next_fuchsia_component_decl::natural::Child,
2833
2834 pub args: crate::natural::CreateChildArgs,
2835 }
2836
2837 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
2838 for RealmCreateChildRequest
2839 where
2840 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2841 ___E: ::fidl_next::Encoder,
2842 ___E: ::fidl_next::fuchsia::HandleEncoder,
2843 {
2844 #[inline]
2845 fn encode(
2846 self,
2847 encoder_: &mut ___E,
2848 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
2849 _: (),
2850 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2851 ::fidl_next::munge! {
2852 let crate::wire::RealmCreateChildRequest {
2853 collection,
2854 decl,
2855 args,
2856
2857 } = out_;
2858 }
2859
2860 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2861
2862 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2863
2864 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
2865
2866 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(decl.as_mut_ptr()) };
2867
2868 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
2869
2870 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
2871
2872 Ok(())
2873 }
2874 }
2875
2876 unsafe impl<___E>
2877 ::fidl_next::EncodeOption<
2878 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2879 ___E,
2880 > for RealmCreateChildRequest
2881 where
2882 ___E: ::fidl_next::Encoder + ?Sized,
2883 RealmCreateChildRequest:
2884 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>,
2885 {
2886 #[inline]
2887 fn encode_option(
2888 this: ::core::option::Option<Self>,
2889 encoder: &mut ___E,
2890 out: &mut ::core::mem::MaybeUninit<
2891 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2892 >,
2893 _: (),
2894 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2895 if let Some(inner) = this {
2896 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2897 ::fidl_next::wire::Box::encode_present(out);
2898 } else {
2899 ::fidl_next::wire::Box::encode_absent(out);
2900 }
2901
2902 Ok(())
2903 }
2904 }
2905
2906 impl<'de> ::fidl_next::FromWire<crate::wire::RealmCreateChildRequest<'de>>
2907 for RealmCreateChildRequest
2908 {
2909 #[inline]
2910 fn from_wire(wire: crate::wire::RealmCreateChildRequest<'de>) -> Self {
2911 Self {
2912 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2913
2914 decl: ::fidl_next::FromWire::from_wire(wire.decl),
2915
2916 args: ::fidl_next::FromWire::from_wire(wire.args),
2917 }
2918 }
2919 }
2920
2921 #[derive(Debug, PartialEq)]
2922 pub struct RealmGetResolvedInfoResponse {
2923 pub resolved_info: ::fidl_next_fuchsia_component_resolution::natural::Component,
2924 }
2925
2926 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
2927 for RealmGetResolvedInfoResponse
2928 where
2929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2930 ___E: ::fidl_next::Encoder,
2931 ___E: ::fidl_next::fuchsia::HandleEncoder,
2932 {
2933 #[inline]
2934 fn encode(
2935 self,
2936 encoder_: &mut ___E,
2937 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
2938 _: (),
2939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2940 ::fidl_next::munge! {
2941 let crate::wire::RealmGetResolvedInfoResponse {
2942 resolved_info,
2943
2944 } = out_;
2945 }
2946
2947 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
2948
2949 let mut _field =
2950 unsafe { ::fidl_next::Slot::new_unchecked(resolved_info.as_mut_ptr()) };
2951
2952 Ok(())
2953 }
2954 }
2955
2956 unsafe impl<___E>
2957 ::fidl_next::EncodeOption<
2958 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2959 ___E,
2960 > for RealmGetResolvedInfoResponse
2961 where
2962 ___E: ::fidl_next::Encoder + ?Sized,
2963 RealmGetResolvedInfoResponse:
2964 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>,
2965 {
2966 #[inline]
2967 fn encode_option(
2968 this: ::core::option::Option<Self>,
2969 encoder: &mut ___E,
2970 out: &mut ::core::mem::MaybeUninit<
2971 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2972 >,
2973 _: (),
2974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2975 if let Some(inner) = this {
2976 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2977 ::fidl_next::wire::Box::encode_present(out);
2978 } else {
2979 ::fidl_next::wire::Box::encode_absent(out);
2980 }
2981
2982 Ok(())
2983 }
2984 }
2985
2986 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetResolvedInfoResponse<'de>>
2987 for RealmGetResolvedInfoResponse
2988 {
2989 #[inline]
2990 fn from_wire(wire: crate::wire::RealmGetResolvedInfoResponse<'de>) -> Self {
2991 Self { resolved_info: ::fidl_next::FromWire::from_wire(wire.resolved_info) }
2992 }
2993 }
2994
2995 #[derive(Debug, PartialEq)]
2996 pub struct StorageAdminListStorageInRealmRequest {
2997 pub relative_moniker: ::std::string::String,
2998
2999 pub iterator:
3000 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::fuchsia::zx::Channel>,
3001 }
3002
3003 unsafe impl<___E>
3004 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
3005 for StorageAdminListStorageInRealmRequest
3006 where
3007 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3008 ___E: ::fidl_next::Encoder,
3009 ___E: ::fidl_next::fuchsia::HandleEncoder,
3010 {
3011 #[inline]
3012 fn encode(
3013 self,
3014 encoder_: &mut ___E,
3015 out_: &mut ::core::mem::MaybeUninit<
3016 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3017 >,
3018 _: (),
3019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3020 ::fidl_next::munge! {
3021 let crate::wire::StorageAdminListStorageInRealmRequest {
3022 relative_moniker,
3023 iterator,
3024
3025 } = out_;
3026 }
3027
3028 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3029
3030 let mut _field =
3031 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3032 ::fidl_next::Constrained::validate(_field, 4096)?;
3033
3034 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
3035
3036 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
3037
3038 Ok(())
3039 }
3040 }
3041
3042 unsafe impl<___E>
3043 ::fidl_next::EncodeOption<
3044 ::fidl_next::wire::Box<
3045 'static,
3046 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3047 >,
3048 ___E,
3049 > for StorageAdminListStorageInRealmRequest
3050 where
3051 ___E: ::fidl_next::Encoder + ?Sized,
3052 StorageAdminListStorageInRealmRequest:
3053 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>,
3054 {
3055 #[inline]
3056 fn encode_option(
3057 this: ::core::option::Option<Self>,
3058 encoder: &mut ___E,
3059 out: &mut ::core::mem::MaybeUninit<
3060 ::fidl_next::wire::Box<
3061 'static,
3062 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3063 >,
3064 >,
3065 _: (),
3066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3067 if let Some(inner) = this {
3068 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3069 ::fidl_next::wire::Box::encode_present(out);
3070 } else {
3071 ::fidl_next::wire::Box::encode_absent(out);
3072 }
3073
3074 Ok(())
3075 }
3076 }
3077
3078 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminListStorageInRealmRequest<'de>>
3079 for StorageAdminListStorageInRealmRequest
3080 {
3081 #[inline]
3082 fn from_wire(wire: crate::wire::StorageAdminListStorageInRealmRequest<'de>) -> Self {
3083 Self {
3084 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3085
3086 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
3087 }
3088 }
3089 }
3090
3091 #[derive(Debug, PartialEq)]
3092 pub struct StorageAdminOpenStorageRequest {
3093 pub relative_moniker: ::std::string::String,
3094
3095 pub object:
3096 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3097 }
3098
3099 unsafe impl<___E>
3100 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
3101 for StorageAdminOpenStorageRequest
3102 where
3103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3104 ___E: ::fidl_next::Encoder,
3105 ___E: ::fidl_next::fuchsia::HandleEncoder,
3106 {
3107 #[inline]
3108 fn encode(
3109 self,
3110 encoder_: &mut ___E,
3111 out_: &mut ::core::mem::MaybeUninit<
3112 crate::wire::StorageAdminOpenStorageRequest<'static>,
3113 >,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3116 ::fidl_next::munge! {
3117 let crate::wire::StorageAdminOpenStorageRequest {
3118 relative_moniker,
3119 object,
3120
3121 } = out_;
3122 }
3123
3124 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3125
3126 let mut _field =
3127 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3128 ::fidl_next::Constrained::validate(_field, 4096)?;
3129
3130 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3131
3132 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3133
3134 Ok(())
3135 }
3136 }
3137
3138 unsafe impl<___E>
3139 ::fidl_next::EncodeOption<
3140 ::fidl_next::wire::Box<'static, crate::wire::StorageAdminOpenStorageRequest<'static>>,
3141 ___E,
3142 > for StorageAdminOpenStorageRequest
3143 where
3144 ___E: ::fidl_next::Encoder + ?Sized,
3145 StorageAdminOpenStorageRequest:
3146 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>,
3147 {
3148 #[inline]
3149 fn encode_option(
3150 this: ::core::option::Option<Self>,
3151 encoder: &mut ___E,
3152 out: &mut ::core::mem::MaybeUninit<
3153 ::fidl_next::wire::Box<
3154 'static,
3155 crate::wire::StorageAdminOpenStorageRequest<'static>,
3156 >,
3157 >,
3158 _: (),
3159 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3160 if let Some(inner) = this {
3161 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3162 ::fidl_next::wire::Box::encode_present(out);
3163 } else {
3164 ::fidl_next::wire::Box::encode_absent(out);
3165 }
3166
3167 Ok(())
3168 }
3169 }
3170
3171 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenStorageRequest<'de>>
3172 for StorageAdminOpenStorageRequest
3173 {
3174 #[inline]
3175 fn from_wire(wire: crate::wire::StorageAdminOpenStorageRequest<'de>) -> Self {
3176 Self {
3177 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3178
3179 object: ::fidl_next::FromWire::from_wire(wire.object),
3180 }
3181 }
3182 }
3183
3184 #[derive(Debug, PartialEq)]
3185 pub struct StorageAdminOpenComponentStorageByIdRequest {
3186 pub id: ::std::string::String,
3187
3188 pub object:
3189 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3190 }
3191
3192 unsafe impl<___E>
3193 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
3194 for StorageAdminOpenComponentStorageByIdRequest
3195 where
3196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3197 ___E: ::fidl_next::Encoder,
3198 ___E: ::fidl_next::fuchsia::HandleEncoder,
3199 {
3200 #[inline]
3201 fn encode(
3202 self,
3203 encoder_: &mut ___E,
3204 out_: &mut ::core::mem::MaybeUninit<
3205 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3206 >,
3207 _: (),
3208 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3209 ::fidl_next::munge! {
3210 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
3211 id,
3212 object,
3213
3214 } = out_;
3215 }
3216
3217 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
3218
3219 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3220 ::fidl_next::Constrained::validate(_field, 64)?;
3221
3222 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3223
3224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3225
3226 Ok(())
3227 }
3228 }
3229
3230 unsafe impl<___E>
3231 ::fidl_next::EncodeOption<
3232 ::fidl_next::wire::Box<
3233 'static,
3234 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3235 >,
3236 ___E,
3237 > for StorageAdminOpenComponentStorageByIdRequest
3238 where
3239 ___E: ::fidl_next::Encoder + ?Sized,
3240 StorageAdminOpenComponentStorageByIdRequest: ::fidl_next::Encode<
3241 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3242 ___E,
3243 >,
3244 {
3245 #[inline]
3246 fn encode_option(
3247 this: ::core::option::Option<Self>,
3248 encoder: &mut ___E,
3249 out: &mut ::core::mem::MaybeUninit<
3250 ::fidl_next::wire::Box<
3251 'static,
3252 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3253 >,
3254 >,
3255 _: (),
3256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3257 if let Some(inner) = this {
3258 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3259 ::fidl_next::wire::Box::encode_present(out);
3260 } else {
3261 ::fidl_next::wire::Box::encode_absent(out);
3262 }
3263
3264 Ok(())
3265 }
3266 }
3267
3268 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>>
3269 for StorageAdminOpenComponentStorageByIdRequest
3270 {
3271 #[inline]
3272 fn from_wire(wire: crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>) -> Self {
3273 Self {
3274 id: ::fidl_next::FromWire::from_wire(wire.id),
3275
3276 object: ::fidl_next::FromWire::from_wire(wire.object),
3277 }
3278 }
3279 }
3280}
3281
3282pub mod wire {
3283
3284 pub use fidl_next_common_fuchsia_component::wire::*;
3285
3286 #[repr(C)]
3288 pub struct CapabilityRequestedPayload<'de> {
3289 pub(crate) table: ::fidl_next::wire::Table<'de>,
3290 }
3291
3292 impl<'de> Drop for CapabilityRequestedPayload<'de> {
3293 fn drop(&mut self) {
3294 let _ = self.table.get(1).map(|envelope| unsafe {
3295 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3296 });
3297
3298 let _ = self.table.get(2).map(|envelope| unsafe {
3299 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
3300 });
3301 }
3302 }
3303
3304 impl ::fidl_next::Constrained for CapabilityRequestedPayload<'_> {
3305 type Constraint = ();
3306
3307 fn validate(
3308 _: ::fidl_next::Slot<'_, Self>,
3309 _: Self::Constraint,
3310 ) -> Result<(), ::fidl_next::ValidationError> {
3311 Ok(())
3312 }
3313 }
3314
3315 unsafe impl ::fidl_next::Wire for CapabilityRequestedPayload<'static> {
3316 type Narrowed<'de> = CapabilityRequestedPayload<'de>;
3317
3318 #[inline]
3319 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3320 ::fidl_next::munge!(let Self { table } = out);
3321 ::fidl_next::wire::Table::zero_padding(table);
3322 }
3323 }
3324
3325 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityRequestedPayload<'de>
3326 where
3327 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3328 ___D: ::fidl_next::fuchsia::HandleDecoder,
3329 {
3330 fn decode(
3331 slot: ::fidl_next::Slot<'_, Self>,
3332 decoder: &mut ___D,
3333 _: (),
3334 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3335 ::fidl_next::munge!(let Self { table } = slot);
3336
3337 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3338 match ordinal {
3339 0 => unsafe { ::core::hint::unreachable_unchecked() },
3340
3341 1 => {
3342 ::fidl_next::wire::Envelope::decode_as::<
3343 ___D,
3344 ::fidl_next::wire::String<'de>,
3345 >(slot.as_mut(), decoder, 255)?;
3346
3347 let value = unsafe {
3348 slot.deref_unchecked()
3349 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3350 };
3351
3352 if value.len() > 255 {
3353 return Err(::fidl_next::DecodeError::VectorTooLong {
3354 size: value.len() as u64,
3355 limit: 255,
3356 });
3357 }
3358
3359 Ok(())
3360 }
3361
3362 2 => {
3363 ::fidl_next::wire::Envelope::decode_as::<
3364 ___D,
3365 ::fidl_next::wire::fuchsia::Channel,
3366 >(slot.as_mut(), decoder, ())?;
3367
3368 Ok(())
3369 }
3370
3371 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3372 }
3373 })
3374 }
3375 }
3376
3377 impl<'de> CapabilityRequestedPayload<'de> {
3378 pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3379 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3380 }
3381
3382 pub fn capability(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
3383 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3384 }
3385 }
3386
3387 impl<'de> ::core::fmt::Debug for CapabilityRequestedPayload<'de> {
3388 fn fmt(
3389 &self,
3390 f: &mut ::core::fmt::Formatter<'_>,
3391 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3392 f.debug_struct("CapabilityRequestedPayload")
3393 .field("name", &self.name())
3394 .field("capability", &self.capability())
3395 .finish()
3396 }
3397 }
3398
3399 impl<'de> ::fidl_next::IntoNatural for CapabilityRequestedPayload<'de> {
3400 type Natural = crate::natural::CapabilityRequestedPayload;
3401 }
3402
3403 #[derive(Debug)]
3405 #[repr(C)]
3406 pub struct ControllerIsStartedResponse {
3407 pub is_started: bool,
3408 }
3409
3410 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerIsStartedResponse>(), 1);
3411 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerIsStartedResponse>(), 1);
3412
3413 static_assertions::const_assert_eq!(
3414 std::mem::offset_of!(ControllerIsStartedResponse, is_started),
3415 0
3416 );
3417
3418 impl ::fidl_next::Constrained for ControllerIsStartedResponse {
3419 type Constraint = ();
3420
3421 fn validate(
3422 _: ::fidl_next::Slot<'_, Self>,
3423 _: Self::Constraint,
3424 ) -> Result<(), ::fidl_next::ValidationError> {
3425 Ok(())
3426 }
3427 }
3428
3429 unsafe impl ::fidl_next::Wire for ControllerIsStartedResponse {
3430 type Narrowed<'de> = ControllerIsStartedResponse;
3431
3432 #[inline]
3433 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3434 ::fidl_next::munge! {
3435 let Self {
3436 is_started,
3437
3438 } = &mut *out_;
3439 }
3440
3441 ::fidl_next::Wire::zero_padding(is_started);
3442 }
3443 }
3444
3445 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerIsStartedResponse
3446 where
3447 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3448 ___D: ::fidl_next::fuchsia::HandleDecoder,
3449 {
3450 fn decode(
3451 slot_: ::fidl_next::Slot<'_, Self>,
3452 decoder_: &mut ___D,
3453 _: (),
3454 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3455 ::fidl_next::munge! {
3456 let Self {
3457 mut is_started,
3458
3459 } = slot_;
3460 }
3461
3462 let _field = is_started.as_mut();
3463
3464 ::fidl_next::Decode::decode(is_started.as_mut(), decoder_, ())?;
3465
3466 Ok(())
3467 }
3468 }
3469
3470 impl ::fidl_next::IntoNatural for ControllerIsStartedResponse {
3471 type Natural = crate::natural::ControllerIsStartedResponse;
3472 }
3473
3474 #[derive(Debug)]
3476 #[repr(C)]
3477 pub struct ControllerGetExposedDictionaryResponse {
3478 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3479 }
3480
3481 static_assertions::const_assert_eq!(
3482 std::mem::size_of::<ControllerGetExposedDictionaryResponse>(),
3483 4
3484 );
3485 static_assertions::const_assert_eq!(
3486 std::mem::align_of::<ControllerGetExposedDictionaryResponse>(),
3487 4
3488 );
3489
3490 static_assertions::const_assert_eq!(
3491 std::mem::offset_of!(ControllerGetExposedDictionaryResponse, dictionary),
3492 0
3493 );
3494
3495 impl ::fidl_next::Constrained for ControllerGetExposedDictionaryResponse {
3496 type Constraint = ();
3497
3498 fn validate(
3499 _: ::fidl_next::Slot<'_, Self>,
3500 _: Self::Constraint,
3501 ) -> Result<(), ::fidl_next::ValidationError> {
3502 Ok(())
3503 }
3504 }
3505
3506 unsafe impl ::fidl_next::Wire for ControllerGetExposedDictionaryResponse {
3507 type Narrowed<'de> = ControllerGetExposedDictionaryResponse;
3508
3509 #[inline]
3510 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3511 ::fidl_next::munge! {
3512 let Self {
3513 dictionary,
3514
3515 } = &mut *out_;
3516 }
3517
3518 ::fidl_next::Wire::zero_padding(dictionary);
3519 }
3520 }
3521
3522 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetExposedDictionaryResponse
3523 where
3524 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3525 ___D: ::fidl_next::fuchsia::HandleDecoder,
3526 {
3527 fn decode(
3528 slot_: ::fidl_next::Slot<'_, Self>,
3529 decoder_: &mut ___D,
3530 _: (),
3531 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3532 ::fidl_next::munge! {
3533 let Self {
3534 mut dictionary,
3535
3536 } = slot_;
3537 }
3538
3539 let _field = dictionary.as_mut();
3540
3541 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3542
3543 Ok(())
3544 }
3545 }
3546
3547 impl ::fidl_next::IntoNatural for ControllerGetExposedDictionaryResponse {
3548 type Natural = crate::natural::ControllerGetExposedDictionaryResponse;
3549 }
3550
3551 #[derive(Debug)]
3553 #[repr(C)]
3554 pub struct ControllerGetOutputDictionaryResponse {
3555 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
3556 }
3557
3558 static_assertions::const_assert_eq!(
3559 std::mem::size_of::<ControllerGetOutputDictionaryResponse>(),
3560 4
3561 );
3562 static_assertions::const_assert_eq!(
3563 std::mem::align_of::<ControllerGetOutputDictionaryResponse>(),
3564 4
3565 );
3566
3567 static_assertions::const_assert_eq!(
3568 std::mem::offset_of!(ControllerGetOutputDictionaryResponse, dictionary),
3569 0
3570 );
3571
3572 impl ::fidl_next::Constrained for ControllerGetOutputDictionaryResponse {
3573 type Constraint = ();
3574
3575 fn validate(
3576 _: ::fidl_next::Slot<'_, Self>,
3577 _: Self::Constraint,
3578 ) -> Result<(), ::fidl_next::ValidationError> {
3579 Ok(())
3580 }
3581 }
3582
3583 unsafe impl ::fidl_next::Wire for ControllerGetOutputDictionaryResponse {
3584 type Narrowed<'de> = ControllerGetOutputDictionaryResponse;
3585
3586 #[inline]
3587 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3588 ::fidl_next::munge! {
3589 let Self {
3590 dictionary,
3591
3592 } = &mut *out_;
3593 }
3594
3595 ::fidl_next::Wire::zero_padding(dictionary);
3596 }
3597 }
3598
3599 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetOutputDictionaryResponse
3600 where
3601 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3602 ___D: ::fidl_next::fuchsia::HandleDecoder,
3603 {
3604 fn decode(
3605 slot_: ::fidl_next::Slot<'_, Self>,
3606 decoder_: &mut ___D,
3607 _: (),
3608 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3609 ::fidl_next::munge! {
3610 let Self {
3611 mut dictionary,
3612
3613 } = slot_;
3614 }
3615
3616 let _field = dictionary.as_mut();
3617
3618 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3619
3620 Ok(())
3621 }
3622 }
3623
3624 impl ::fidl_next::IntoNatural for ControllerGetOutputDictionaryResponse {
3625 type Natural = crate::natural::ControllerGetOutputDictionaryResponse;
3626 }
3627
3628 #[repr(C)]
3630 pub struct NamespaceEntry<'de> {
3631 pub(crate) table: ::fidl_next::wire::Table<'de>,
3632 }
3633
3634 impl<'de> Drop for NamespaceEntry<'de> {
3635 fn drop(&mut self) {
3636 let _ = self.table.get(1).map(|envelope| unsafe {
3637 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3638 });
3639
3640 let _ = self.table.get(2).map(|envelope| unsafe {
3641 envelope.read_unchecked::<::fidl_next::ClientEnd<
3642 ::fidl_next_fuchsia_io::Directory,
3643 ::fidl_next::wire::fuchsia::Channel,
3644 >>()
3645 });
3646 }
3647 }
3648
3649 impl ::fidl_next::Constrained for NamespaceEntry<'_> {
3650 type Constraint = ();
3651
3652 fn validate(
3653 _: ::fidl_next::Slot<'_, Self>,
3654 _: Self::Constraint,
3655 ) -> Result<(), ::fidl_next::ValidationError> {
3656 Ok(())
3657 }
3658 }
3659
3660 unsafe impl ::fidl_next::Wire for NamespaceEntry<'static> {
3661 type Narrowed<'de> = NamespaceEntry<'de>;
3662
3663 #[inline]
3664 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3665 ::fidl_next::munge!(let Self { table } = out);
3666 ::fidl_next::wire::Table::zero_padding(table);
3667 }
3668 }
3669
3670 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceEntry<'de>
3671 where
3672 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3673 ___D: ::fidl_next::fuchsia::HandleDecoder,
3674 {
3675 fn decode(
3676 slot: ::fidl_next::Slot<'_, Self>,
3677 decoder: &mut ___D,
3678 _: (),
3679 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3680 ::fidl_next::munge!(let Self { table } = slot);
3681
3682 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3683 match ordinal {
3684 0 => unsafe { ::core::hint::unreachable_unchecked() },
3685
3686 1 => {
3687 ::fidl_next::wire::Envelope::decode_as::<
3688 ___D,
3689 ::fidl_next::wire::String<'de>,
3690 >(slot.as_mut(), decoder, 4095)?;
3691
3692 let value = unsafe {
3693 slot.deref_unchecked()
3694 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3695 };
3696
3697 if value.len() > 4095 {
3698 return Err(::fidl_next::DecodeError::VectorTooLong {
3699 size: value.len() as u64,
3700 limit: 4095,
3701 });
3702 }
3703
3704 Ok(())
3705 }
3706
3707 2 => {
3708 ::fidl_next::wire::Envelope::decode_as::<
3709 ___D,
3710 ::fidl_next::ClientEnd<
3711 ::fidl_next_fuchsia_io::Directory,
3712 ::fidl_next::wire::fuchsia::Channel,
3713 >,
3714 >(slot.as_mut(), decoder, ())?;
3715
3716 Ok(())
3717 }
3718
3719 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3720 }
3721 })
3722 }
3723 }
3724
3725 impl<'de> NamespaceEntry<'de> {
3726 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3727 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3728 }
3729
3730 pub fn directory(
3731 &self,
3732 ) -> ::core::option::Option<
3733 &::fidl_next::ClientEnd<
3734 ::fidl_next_fuchsia_io::Directory,
3735 ::fidl_next::wire::fuchsia::Channel,
3736 >,
3737 > {
3738 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3739 }
3740 }
3741
3742 impl<'de> ::core::fmt::Debug for NamespaceEntry<'de> {
3743 fn fmt(
3744 &self,
3745 f: &mut ::core::fmt::Formatter<'_>,
3746 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3747 f.debug_struct("NamespaceEntry")
3748 .field("path", &self.path())
3749 .field("directory", &self.directory())
3750 .finish()
3751 }
3752 }
3753
3754 impl<'de> ::fidl_next::IntoNatural for NamespaceEntry<'de> {
3755 type Natural = crate::natural::NamespaceEntry;
3756 }
3757
3758 #[repr(C)]
3760 pub struct StartChildArgs<'de> {
3761 pub(crate) table: ::fidl_next::wire::Table<'de>,
3762 }
3763
3764 impl<'de> Drop for StartChildArgs<'de> {
3765 fn drop(&mut self) {
3766 let _ =
3767 self.table.get(1).map(|envelope| unsafe {
3768 envelope.read_unchecked::<::fidl_next::wire::Vector<
3769 'de,
3770 ::fidl_next_fuchsia_process::wire::HandleInfo,
3771 >>()
3772 });
3773
3774 let _ = self.table.get(2)
3775 .map(|envelope| unsafe {
3776 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>()
3777 });
3778
3779 let _ = self.table.get(3)
3780 .map(|envelope| unsafe {
3781 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
3782 });
3783
3784 let _ = self.table.get(4).map(|envelope| unsafe {
3785 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
3786 });
3787 }
3788 }
3789
3790 impl ::fidl_next::Constrained for StartChildArgs<'_> {
3791 type Constraint = ();
3792
3793 fn validate(
3794 _: ::fidl_next::Slot<'_, Self>,
3795 _: Self::Constraint,
3796 ) -> Result<(), ::fidl_next::ValidationError> {
3797 Ok(())
3798 }
3799 }
3800
3801 unsafe impl ::fidl_next::Wire for StartChildArgs<'static> {
3802 type Narrowed<'de> = StartChildArgs<'de>;
3803
3804 #[inline]
3805 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3806 ::fidl_next::munge!(let Self { table } = out);
3807 ::fidl_next::wire::Table::zero_padding(table);
3808 }
3809 }
3810
3811 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartChildArgs<'de>
3812 where
3813 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3814 ___D: ::fidl_next::fuchsia::HandleDecoder,
3815 {
3816 fn decode(
3817 slot: ::fidl_next::Slot<'_, Self>,
3818 decoder: &mut ___D,
3819 _: (),
3820 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3821 ::fidl_next::munge!(let Self { table } = slot);
3822
3823 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3824 match ordinal {
3825 0 => unsafe { ::core::hint::unreachable_unchecked() },
3826
3827 1 => {
3828 ::fidl_next::wire::Envelope::decode_as::<
3829 ___D,
3830 ::fidl_next::wire::Vector<
3831 'de,
3832 ::fidl_next_fuchsia_process::wire::HandleInfo,
3833 >,
3834 >(slot.as_mut(), decoder, (128, ()))?;
3835
3836 let value = unsafe {
3837 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
3838 '_,
3839 ::fidl_next_fuchsia_process::wire::HandleInfo,
3840 >>()
3841 };
3842
3843 if value.len() > 128 {
3844 return Err(::fidl_next::DecodeError::VectorTooLong {
3845 size: value.len() as u64,
3846 limit: 128,
3847 });
3848 }
3849
3850 Ok(())
3851 }
3852
3853 2 => {
3854 ::fidl_next::wire::Envelope::decode_as::<
3855 ___D,
3856 ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
3857 >(slot.as_mut(), decoder, (32, ()))?;
3858
3859 let value = unsafe {
3860 slot
3861 .deref_unchecked()
3862 .deref_unchecked::<
3863 ::fidl_next::wire::Vector<'_, crate::wire::NamespaceEntry<'_>>
3864 >()
3865 };
3866
3867 if value.len() > 32 {
3868 return Err(::fidl_next::DecodeError::VectorTooLong {
3869 size: value.len() as u64,
3870 limit: 32,
3871 });
3872 }
3873
3874 Ok(())
3875 }
3876
3877 3 => {
3878 ::fidl_next::wire::Envelope::decode_as::<
3879 ___D,
3880 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3881 >(slot.as_mut(), decoder, ())?;
3882
3883 Ok(())
3884 }
3885
3886 4 => {
3887 ::fidl_next::wire::Envelope::decode_as::<
3888 ___D,
3889 ::fidl_next::wire::fuchsia::EventPair,
3890 >(slot.as_mut(), decoder, ())?;
3891
3892 Ok(())
3893 }
3894
3895 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3896 }
3897 })
3898 }
3899 }
3900
3901 impl<'de> StartChildArgs<'de> {
3902 pub fn numbered_handles(
3903 &self,
3904 ) -> ::core::option::Option<
3905 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3906 > {
3907 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3908 }
3909
3910 pub fn namespace_entries(
3911 &self,
3912 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3913 {
3914 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3915 }
3916
3917 pub fn dictionary(
3918 &self,
3919 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3920 {
3921 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3922 }
3923
3924 pub fn additional_inputs(
3925 &self,
3926 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
3927 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3928 }
3929 }
3930
3931 impl<'de> ::core::fmt::Debug for StartChildArgs<'de> {
3932 fn fmt(
3933 &self,
3934 f: &mut ::core::fmt::Formatter<'_>,
3935 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3936 f.debug_struct("StartChildArgs")
3937 .field("numbered_handles", &self.numbered_handles())
3938 .field("namespace_entries", &self.namespace_entries())
3939 .field("dictionary", &self.dictionary())
3940 .field("additional_inputs", &self.additional_inputs())
3941 .finish()
3942 }
3943 }
3944
3945 impl<'de> ::fidl_next::IntoNatural for StartChildArgs<'de> {
3946 type Natural = crate::natural::StartChildArgs;
3947 }
3948
3949 #[derive(Debug)]
3951 #[repr(C)]
3952 pub struct ControllerStartRequest<'de> {
3953 pub args: crate::wire::StartChildArgs<'de>,
3954
3955 pub execution_controller:
3956 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::wire::fuchsia::Channel>,
3957 }
3958
3959 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerStartRequest<'_>>(), 24);
3960 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerStartRequest<'_>>(), 8);
3961
3962 static_assertions::const_assert_eq!(std::mem::offset_of!(ControllerStartRequest<'_>, args), 0);
3963
3964 static_assertions::const_assert_eq!(
3965 std::mem::offset_of!(ControllerStartRequest<'_>, execution_controller),
3966 16
3967 );
3968
3969 impl ::fidl_next::Constrained for ControllerStartRequest<'_> {
3970 type Constraint = ();
3971
3972 fn validate(
3973 _: ::fidl_next::Slot<'_, Self>,
3974 _: Self::Constraint,
3975 ) -> Result<(), ::fidl_next::ValidationError> {
3976 Ok(())
3977 }
3978 }
3979
3980 unsafe impl ::fidl_next::Wire for ControllerStartRequest<'static> {
3981 type Narrowed<'de> = ControllerStartRequest<'de>;
3982
3983 #[inline]
3984 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3985 ::fidl_next::munge! {
3986 let Self {
3987 args,
3988 execution_controller,
3989
3990 } = &mut *out_;
3991 }
3992
3993 ::fidl_next::Wire::zero_padding(args);
3994
3995 ::fidl_next::Wire::zero_padding(execution_controller);
3996
3997 unsafe {
3998 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
3999 }
4000 }
4001 }
4002
4003 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ControllerStartRequest<'de>
4004 where
4005 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4006 ___D: ::fidl_next::Decoder<'de>,
4007 ___D: ::fidl_next::fuchsia::HandleDecoder,
4008 {
4009 fn decode(
4010 slot_: ::fidl_next::Slot<'_, Self>,
4011 decoder_: &mut ___D,
4012 _: (),
4013 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4014 if slot_.as_bytes()[20..24] != [0u8; 4] {
4015 return Err(::fidl_next::DecodeError::InvalidPadding);
4016 }
4017
4018 ::fidl_next::munge! {
4019 let Self {
4020 mut args,
4021 mut execution_controller,
4022
4023 } = slot_;
4024 }
4025
4026 let _field = args.as_mut();
4027
4028 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
4029
4030 let _field = execution_controller.as_mut();
4031
4032 ::fidl_next::Decode::decode(execution_controller.as_mut(), decoder_, ())?;
4033
4034 Ok(())
4035 }
4036 }
4037
4038 impl<'de> ::fidl_next::IntoNatural for ControllerStartRequest<'de> {
4039 type Natural = crate::natural::ControllerStartRequest;
4040 }
4041
4042 #[derive(Debug)]
4044 #[repr(C)]
4045 pub struct ControllerOpenExposedDirRequest {
4046 pub exposed_dir: ::fidl_next::ServerEnd<
4047 ::fidl_next_fuchsia_io::Directory,
4048 ::fidl_next::wire::fuchsia::Channel,
4049 >,
4050 }
4051
4052 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerOpenExposedDirRequest>(), 4);
4053 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerOpenExposedDirRequest>(), 4);
4054
4055 static_assertions::const_assert_eq!(
4056 std::mem::offset_of!(ControllerOpenExposedDirRequest, exposed_dir),
4057 0
4058 );
4059
4060 impl ::fidl_next::Constrained for ControllerOpenExposedDirRequest {
4061 type Constraint = ();
4062
4063 fn validate(
4064 _: ::fidl_next::Slot<'_, Self>,
4065 _: Self::Constraint,
4066 ) -> Result<(), ::fidl_next::ValidationError> {
4067 Ok(())
4068 }
4069 }
4070
4071 unsafe impl ::fidl_next::Wire for ControllerOpenExposedDirRequest {
4072 type Narrowed<'de> = ControllerOpenExposedDirRequest;
4073
4074 #[inline]
4075 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4076 ::fidl_next::munge! {
4077 let Self {
4078 exposed_dir,
4079
4080 } = &mut *out_;
4081 }
4082
4083 ::fidl_next::Wire::zero_padding(exposed_dir);
4084 }
4085 }
4086
4087 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerOpenExposedDirRequest
4088 where
4089 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4090 ___D: ::fidl_next::fuchsia::HandleDecoder,
4091 {
4092 fn decode(
4093 slot_: ::fidl_next::Slot<'_, Self>,
4094 decoder_: &mut ___D,
4095 _: (),
4096 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4097 ::fidl_next::munge! {
4098 let Self {
4099 mut exposed_dir,
4100
4101 } = slot_;
4102 }
4103
4104 let _field = exposed_dir.as_mut();
4105
4106 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
4107
4108 Ok(())
4109 }
4110 }
4111
4112 impl ::fidl_next::IntoNatural for ControllerOpenExposedDirRequest {
4113 type Natural = crate::natural::ControllerOpenExposedDirRequest;
4114 }
4115
4116 #[repr(C)]
4118 pub struct CreateChildArgs<'de> {
4119 pub(crate) table: ::fidl_next::wire::Table<'de>,
4120 }
4121
4122 impl<'de> Drop for CreateChildArgs<'de> {
4123 fn drop(&mut self) {
4124 let _ =
4125 self.table.get(1).map(|envelope| unsafe {
4126 envelope.read_unchecked::<::fidl_next::wire::Vector<
4127 'de,
4128 ::fidl_next_fuchsia_process::wire::HandleInfo,
4129 >>()
4130 });
4131
4132 let _ = self.table.get(2).map(|envelope| unsafe {
4133 envelope.read_unchecked::<::fidl_next::wire::Vector<
4134 'de,
4135 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4136 >>()
4137 });
4138
4139 let _ =
4140 self.table.get(3).map(|envelope| unsafe {
4141 envelope.read_unchecked::<::fidl_next::ServerEnd<
4142 crate::Controller,
4143 ::fidl_next::wire::fuchsia::Channel,
4144 >>()
4145 });
4146
4147 let _ = self.table.get(4)
4148 .map(|envelope| unsafe {
4149 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
4150 });
4151
4152 let _ = self.table.get(5).map(|envelope| unsafe {
4153 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4154 });
4155 }
4156 }
4157
4158 impl ::fidl_next::Constrained for CreateChildArgs<'_> {
4159 type Constraint = ();
4160
4161 fn validate(
4162 _: ::fidl_next::Slot<'_, Self>,
4163 _: Self::Constraint,
4164 ) -> Result<(), ::fidl_next::ValidationError> {
4165 Ok(())
4166 }
4167 }
4168
4169 unsafe impl ::fidl_next::Wire for CreateChildArgs<'static> {
4170 type Narrowed<'de> = CreateChildArgs<'de>;
4171
4172 #[inline]
4173 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4174 ::fidl_next::munge!(let Self { table } = out);
4175 ::fidl_next::wire::Table::zero_padding(table);
4176 }
4177 }
4178
4179 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CreateChildArgs<'de>
4180 where
4181 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4182 ___D: ::fidl_next::fuchsia::HandleDecoder,
4183 {
4184 fn decode(
4185 slot: ::fidl_next::Slot<'_, Self>,
4186 decoder: &mut ___D,
4187 _: (),
4188 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4189 ::fidl_next::munge!(let Self { table } = slot);
4190
4191 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4192 match ordinal {
4193 0 => unsafe { ::core::hint::unreachable_unchecked() },
4194
4195 1 => {
4196 ::fidl_next::wire::Envelope::decode_as::<
4197 ___D,
4198 ::fidl_next::wire::Vector<
4199 'de,
4200 ::fidl_next_fuchsia_process::wire::HandleInfo,
4201 >,
4202 >(slot.as_mut(), decoder, (128, ()))?;
4203
4204 let value = unsafe {
4205 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4206 '_,
4207 ::fidl_next_fuchsia_process::wire::HandleInfo,
4208 >>()
4209 };
4210
4211 if value.len() > 128 {
4212 return Err(::fidl_next::DecodeError::VectorTooLong {
4213 size: value.len() as u64,
4214 limit: 128,
4215 });
4216 }
4217
4218 Ok(())
4219 }
4220
4221 2 => {
4222 ::fidl_next::wire::Envelope::decode_as::<
4223 ___D,
4224 ::fidl_next::wire::Vector<
4225 'de,
4226 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4227 >,
4228 >(slot.as_mut(), decoder, (128, ()))?;
4229
4230 let value = unsafe {
4231 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4232 '_,
4233 ::fidl_next_fuchsia_component_decl::wire::Offer<'_>,
4234 >>()
4235 };
4236
4237 if value.len() > 128 {
4238 return Err(::fidl_next::DecodeError::VectorTooLong {
4239 size: value.len() as u64,
4240 limit: 128,
4241 });
4242 }
4243
4244 Ok(())
4245 }
4246
4247 3 => {
4248 ::fidl_next::wire::Envelope::decode_as::<
4249 ___D,
4250 ::fidl_next::ServerEnd<
4251 crate::Controller,
4252 ::fidl_next::wire::fuchsia::Channel,
4253 >,
4254 >(slot.as_mut(), decoder, ())?;
4255
4256 Ok(())
4257 }
4258
4259 4 => {
4260 ::fidl_next::wire::Envelope::decode_as::<
4261 ___D,
4262 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
4263 >(slot.as_mut(), decoder, ())?;
4264
4265 Ok(())
4266 }
4267
4268 5 => {
4269 ::fidl_next::wire::Envelope::decode_as::<
4270 ___D,
4271 ::fidl_next::wire::fuchsia::EventPair,
4272 >(slot.as_mut(), decoder, ())?;
4273
4274 Ok(())
4275 }
4276
4277 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4278 }
4279 })
4280 }
4281 }
4282
4283 impl<'de> CreateChildArgs<'de> {
4284 pub fn numbered_handles(
4285 &self,
4286 ) -> ::core::option::Option<
4287 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4288 > {
4289 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4290 }
4291
4292 pub fn dynamic_offers(
4293 &self,
4294 ) -> ::core::option::Option<
4295 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4296 > {
4297 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4298 }
4299
4300 pub fn controller(
4301 &self,
4302 ) -> ::core::option::Option<
4303 &::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4304 > {
4305 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
4306 }
4307
4308 pub fn dictionary(
4309 &self,
4310 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4311 {
4312 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
4313 }
4314
4315 pub fn additional_inputs(
4316 &self,
4317 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4318 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
4319 }
4320 }
4321
4322 impl<'de> ::core::fmt::Debug for CreateChildArgs<'de> {
4323 fn fmt(
4324 &self,
4325 f: &mut ::core::fmt::Formatter<'_>,
4326 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4327 f.debug_struct("CreateChildArgs")
4328 .field("numbered_handles", &self.numbered_handles())
4329 .field("dynamic_offers", &self.dynamic_offers())
4330 .field("controller", &self.controller())
4331 .field("dictionary", &self.dictionary())
4332 .field("additional_inputs", &self.additional_inputs())
4333 .finish()
4334 }
4335 }
4336
4337 impl<'de> ::fidl_next::IntoNatural for CreateChildArgs<'de> {
4338 type Natural = crate::natural::CreateChildArgs;
4339 }
4340
4341 #[repr(C)]
4343 pub struct DebugStartedPayload<'de> {
4344 pub(crate) table: ::fidl_next::wire::Table<'de>,
4345 }
4346
4347 impl<'de> Drop for DebugStartedPayload<'de> {
4348 fn drop(&mut self) {
4349 let _ = self.table.get(1).map(|envelope| unsafe {
4350 envelope.read_unchecked::<::fidl_next::ClientEnd<
4351 ::fidl_next_fuchsia_io::Directory,
4352 ::fidl_next::wire::fuchsia::Channel,
4353 >>()
4354 });
4355
4356 let _ = self.table.get(2).map(|envelope| unsafe {
4357 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4358 });
4359 }
4360 }
4361
4362 impl ::fidl_next::Constrained for DebugStartedPayload<'_> {
4363 type Constraint = ();
4364
4365 fn validate(
4366 _: ::fidl_next::Slot<'_, Self>,
4367 _: Self::Constraint,
4368 ) -> Result<(), ::fidl_next::ValidationError> {
4369 Ok(())
4370 }
4371 }
4372
4373 unsafe impl ::fidl_next::Wire for DebugStartedPayload<'static> {
4374 type Narrowed<'de> = DebugStartedPayload<'de>;
4375
4376 #[inline]
4377 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4378 ::fidl_next::munge!(let Self { table } = out);
4379 ::fidl_next::wire::Table::zero_padding(table);
4380 }
4381 }
4382
4383 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugStartedPayload<'de>
4384 where
4385 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4386 ___D: ::fidl_next::fuchsia::HandleDecoder,
4387 {
4388 fn decode(
4389 slot: ::fidl_next::Slot<'_, Self>,
4390 decoder: &mut ___D,
4391 _: (),
4392 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4393 ::fidl_next::munge!(let Self { table } = slot);
4394
4395 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4396 match ordinal {
4397 0 => unsafe { ::core::hint::unreachable_unchecked() },
4398
4399 1 => {
4400 ::fidl_next::wire::Envelope::decode_as::<
4401 ___D,
4402 ::fidl_next::ClientEnd<
4403 ::fidl_next_fuchsia_io::Directory,
4404 ::fidl_next::wire::fuchsia::Channel,
4405 >,
4406 >(slot.as_mut(), decoder, ())?;
4407
4408 Ok(())
4409 }
4410
4411 2 => {
4412 ::fidl_next::wire::Envelope::decode_as::<
4413 ___D,
4414 ::fidl_next::wire::fuchsia::EventPair,
4415 >(slot.as_mut(), decoder, ())?;
4416
4417 Ok(())
4418 }
4419
4420 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4421 }
4422 })
4423 }
4424 }
4425
4426 impl<'de> DebugStartedPayload<'de> {
4427 pub fn runtime_dir(
4428 &self,
4429 ) -> ::core::option::Option<
4430 &::fidl_next::ClientEnd<
4431 ::fidl_next_fuchsia_io::Directory,
4432 ::fidl_next::wire::fuchsia::Channel,
4433 >,
4434 > {
4435 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4436 }
4437
4438 pub fn break_on_start(
4439 &self,
4440 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4441 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4442 }
4443 }
4444
4445 impl<'de> ::core::fmt::Debug for DebugStartedPayload<'de> {
4446 fn fmt(
4447 &self,
4448 f: &mut ::core::fmt::Formatter<'_>,
4449 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4450 f.debug_struct("DebugStartedPayload")
4451 .field("runtime_dir", &self.runtime_dir())
4452 .field("break_on_start", &self.break_on_start())
4453 .finish()
4454 }
4455 }
4456
4457 impl<'de> ::fidl_next::IntoNatural for DebugStartedPayload<'de> {
4458 type Natural = crate::natural::DebugStartedPayload;
4459 }
4460
4461 #[repr(transparent)]
4463 pub struct EventPayload<'de> {
4464 pub(crate) raw: ::fidl_next::wire::Union,
4465 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4466 }
4467
4468 impl<'de> Drop for EventPayload<'de> {
4469 fn drop(&mut self) {
4470 match self.raw.ordinal() {
4471 1 => {
4472 let _ = unsafe {
4473 self.raw
4474 .get()
4475 .read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4476 };
4477 }
4478
4479 2 => {
4480 let _ = unsafe {
4481 self.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4482 };
4483 }
4484
4485 4 => {
4486 let _ = unsafe {
4487 self.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4488 };
4489 }
4490
4491 5 => {
4492 let _ = unsafe {
4493 self.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4494 };
4495 }
4496
4497 6 => {
4498 let _ = unsafe {
4499 self.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4500 };
4501 }
4502
4503 7 => {
4504 let _ = unsafe {
4505 self.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4506 };
4507 }
4508
4509 8 => {
4510 let _ = unsafe {
4511 self.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4512 };
4513 }
4514
4515 9 => {
4516 let _ = unsafe {
4517 self.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4518 };
4519 }
4520
4521 10 => {
4522 let _ = unsafe {
4523 self.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4524 };
4525 }
4526
4527 _ => (),
4528 }
4529 }
4530 }
4531
4532 impl ::fidl_next::Constrained for EventPayload<'_> {
4533 type Constraint = ();
4534
4535 fn validate(
4536 _: ::fidl_next::Slot<'_, Self>,
4537 _: Self::Constraint,
4538 ) -> Result<(), ::fidl_next::ValidationError> {
4539 Ok(())
4540 }
4541 }
4542
4543 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
4544 type Narrowed<'de> = EventPayload<'de>;
4545
4546 #[inline]
4547 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4548 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4549 ::fidl_next::wire::Union::zero_padding(raw);
4550 }
4551 }
4552
4553 pub mod event_payload {
4554 pub enum Ref<'de> {
4555 CapabilityRequested(&'de crate::wire::CapabilityRequestedPayload<'de>),
4556
4557 Purged(&'de crate::wire::PurgedPayload<'de>),
4558
4559 Discovered(&'de crate::wire::DiscoveredPayload<'de>),
4560
4561 Destroyed(&'de crate::wire::DestroyedPayload<'de>),
4562
4563 Resolved(&'de crate::wire::ResolvedPayload<'de>),
4564
4565 Started(&'de crate::wire::StartedPayload<'de>),
4566
4567 Stopped(&'de crate::wire::StoppedPayload<'de>),
4568
4569 DebugStarted(&'de crate::wire::DebugStartedPayload<'de>),
4570
4571 Unresolved(&'de crate::wire::UnresolvedPayload<'de>),
4572
4573 UnknownOrdinal_(u64),
4574 }
4575 }
4576
4577 impl<'de> EventPayload<'de> {
4578 pub fn as_ref(&self) -> crate::wire::event_payload::Ref<'_> {
4579 match self.raw.ordinal() {
4580 1 => crate::wire::event_payload::Ref::CapabilityRequested(unsafe {
4581 self.raw.get().deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4582 }),
4583
4584 2 => crate::wire::event_payload::Ref::Purged(unsafe {
4585 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>()
4586 }),
4587
4588 4 => crate::wire::event_payload::Ref::Discovered(unsafe {
4589 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>()
4590 }),
4591
4592 5 => crate::wire::event_payload::Ref::Destroyed(unsafe {
4593 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>()
4594 }),
4595
4596 6 => crate::wire::event_payload::Ref::Resolved(unsafe {
4597 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>()
4598 }),
4599
4600 7 => crate::wire::event_payload::Ref::Started(unsafe {
4601 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>()
4602 }),
4603
4604 8 => crate::wire::event_payload::Ref::Stopped(unsafe {
4605 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>()
4606 }),
4607
4608 9 => crate::wire::event_payload::Ref::DebugStarted(unsafe {
4609 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>()
4610 }),
4611
4612 10 => crate::wire::event_payload::Ref::Unresolved(unsafe {
4613 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>()
4614 }),
4615
4616 unknown => crate::wire::event_payload::Ref::UnknownOrdinal_(unknown),
4617 }
4618 }
4619 }
4620
4621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
4622 where
4623 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4624 ___D: ::fidl_next::Decoder<'de>,
4625 ___D: ::fidl_next::fuchsia::HandleDecoder,
4626 {
4627 fn decode(
4628 mut slot: ::fidl_next::Slot<'_, Self>,
4629 decoder: &mut ___D,
4630 _: (),
4631 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4632 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4633 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4634 1 => ::fidl_next::wire::Union::decode_as::<
4635 ___D,
4636 crate::wire::CapabilityRequestedPayload<'de>,
4637 >(raw, decoder, ())?,
4638
4639 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
4640 raw,
4641 decoder,
4642 (),
4643 )?,
4644
4645 4 => ::fidl_next::wire::Union::decode_as::<
4646 ___D,
4647 crate::wire::DiscoveredPayload<'de>,
4648 >(raw, decoder, ())?,
4649
4650 5 => {
4651 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
4652 raw,
4653 decoder,
4654 (),
4655 )?
4656 }
4657
4658 6 => {
4659 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
4660 raw,
4661 decoder,
4662 (),
4663 )?
4664 }
4665
4666 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
4667 raw,
4668 decoder,
4669 (),
4670 )?,
4671
4672 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
4673 raw,
4674 decoder,
4675 (),
4676 )?,
4677
4678 9 => ::fidl_next::wire::Union::decode_as::<
4679 ___D,
4680 crate::wire::DebugStartedPayload<'de>,
4681 >(raw, decoder, ())?,
4682
4683 10 => ::fidl_next::wire::Union::decode_as::<
4684 ___D,
4685 crate::wire::UnresolvedPayload<'de>,
4686 >(raw, decoder, ())?,
4687
4688 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4689 }
4690
4691 Ok(())
4692 }
4693 }
4694
4695 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
4696 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4697 match self.raw.ordinal() {
4698 1 => unsafe {
4699 self.raw
4700 .get()
4701 .deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4702 .fmt(f)
4703 },
4704 2 => unsafe {
4705 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>().fmt(f)
4706 },
4707 4 => unsafe {
4708 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>().fmt(f)
4709 },
4710 5 => unsafe {
4711 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>().fmt(f)
4712 },
4713 6 => unsafe {
4714 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>().fmt(f)
4715 },
4716 7 => unsafe {
4717 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>().fmt(f)
4718 },
4719 8 => unsafe {
4720 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>().fmt(f)
4721 },
4722 9 => unsafe {
4723 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>().fmt(f)
4724 },
4725 10 => unsafe {
4726 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>().fmt(f)
4727 },
4728 _ => unsafe { ::core::hint::unreachable_unchecked() },
4729 }
4730 }
4731 }
4732
4733 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
4734 type Natural = crate::natural::EventPayload;
4735 }
4736
4737 #[repr(C)]
4739 pub struct Event<'de> {
4740 pub(crate) table: ::fidl_next::wire::Table<'de>,
4741 }
4742
4743 impl<'de> Drop for Event<'de> {
4744 fn drop(&mut self) {
4745 let _ = self.table.get(1).map(|envelope| unsafe {
4746 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
4747 });
4748
4749 let _ = self.table.get(2).map(|envelope| unsafe {
4750 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
4751 });
4752 }
4753 }
4754
4755 impl ::fidl_next::Constrained for Event<'_> {
4756 type Constraint = ();
4757
4758 fn validate(
4759 _: ::fidl_next::Slot<'_, Self>,
4760 _: Self::Constraint,
4761 ) -> Result<(), ::fidl_next::ValidationError> {
4762 Ok(())
4763 }
4764 }
4765
4766 unsafe impl ::fidl_next::Wire for Event<'static> {
4767 type Narrowed<'de> = Event<'de>;
4768
4769 #[inline]
4770 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4771 ::fidl_next::munge!(let Self { table } = out);
4772 ::fidl_next::wire::Table::zero_padding(table);
4773 }
4774 }
4775
4776 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Event<'de>
4777 where
4778 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4779 ___D: ::fidl_next::fuchsia::HandleDecoder,
4780 {
4781 fn decode(
4782 slot: ::fidl_next::Slot<'_, Self>,
4783 decoder: &mut ___D,
4784 _: (),
4785 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4786 ::fidl_next::munge!(let Self { table } = slot);
4787
4788 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4789 match ordinal {
4790 0 => unsafe { ::core::hint::unreachable_unchecked() },
4791
4792 1 => {
4793 ::fidl_next::wire::Envelope::decode_as::<
4794 ___D,
4795 crate::wire::EventHeader<'de>,
4796 >(slot.as_mut(), decoder, ())?;
4797
4798 Ok(())
4799 }
4800
4801 2 => {
4802 ::fidl_next::wire::Envelope::decode_as::<
4803 ___D,
4804 crate::wire::EventPayload<'de>,
4805 >(slot.as_mut(), decoder, ())?;
4806
4807 Ok(())
4808 }
4809
4810 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4811 }
4812 })
4813 }
4814 }
4815
4816 impl<'de> Event<'de> {
4817 pub fn header(&self) -> ::core::option::Option<&crate::wire::EventHeader<'de>> {
4818 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4819 }
4820
4821 pub fn payload(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
4822 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4823 }
4824 }
4825
4826 impl<'de> ::core::fmt::Debug for Event<'de> {
4827 fn fmt(
4828 &self,
4829 f: &mut ::core::fmt::Formatter<'_>,
4830 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4831 f.debug_struct("Event")
4832 .field("header", &self.header())
4833 .field("payload", &self.payload())
4834 .finish()
4835 }
4836 }
4837
4838 impl<'de> ::fidl_next::IntoNatural for Event<'de> {
4839 type Natural = crate::natural::Event;
4840 }
4841
4842 #[derive(Debug)]
4844 #[repr(C)]
4845 pub struct EventStreamGetNextResponse<'de> {
4846 pub events: ::fidl_next::wire::Vector<'de, crate::wire::Event<'de>>,
4847 }
4848
4849 static_assertions::const_assert_eq!(std::mem::size_of::<EventStreamGetNextResponse<'_>>(), 16);
4850 static_assertions::const_assert_eq!(std::mem::align_of::<EventStreamGetNextResponse<'_>>(), 8);
4851
4852 static_assertions::const_assert_eq!(
4853 std::mem::offset_of!(EventStreamGetNextResponse<'_>, events),
4854 0
4855 );
4856
4857 impl ::fidl_next::Constrained for EventStreamGetNextResponse<'_> {
4858 type Constraint = ();
4859
4860 fn validate(
4861 _: ::fidl_next::Slot<'_, Self>,
4862 _: Self::Constraint,
4863 ) -> Result<(), ::fidl_next::ValidationError> {
4864 Ok(())
4865 }
4866 }
4867
4868 unsafe impl ::fidl_next::Wire for EventStreamGetNextResponse<'static> {
4869 type Narrowed<'de> = EventStreamGetNextResponse<'de>;
4870
4871 #[inline]
4872 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4873 ::fidl_next::munge! {
4874 let Self {
4875 events,
4876
4877 } = &mut *out_;
4878 }
4879
4880 ::fidl_next::Wire::zero_padding(events);
4881 }
4882 }
4883
4884 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventStreamGetNextResponse<'de>
4885 where
4886 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4887 ___D: ::fidl_next::Decoder<'de>,
4888 ___D: ::fidl_next::fuchsia::HandleDecoder,
4889 {
4890 fn decode(
4891 slot_: ::fidl_next::Slot<'_, Self>,
4892 decoder_: &mut ___D,
4893 _: (),
4894 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4895 ::fidl_next::munge! {
4896 let Self {
4897 mut events,
4898
4899 } = slot_;
4900 }
4901
4902 let _field = events.as_mut();
4903 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
4904 ::fidl_next::Decode::decode(events.as_mut(), decoder_, (4294967295, ()))?;
4905
4906 Ok(())
4907 }
4908 }
4909
4910 impl<'de> ::fidl_next::IntoNatural for EventStreamGetNextResponse<'de> {
4911 type Natural = crate::natural::EventStreamGetNextResponse;
4912 }
4913
4914 #[derive(Debug)]
4916 #[repr(C)]
4917 pub struct IntrospectorGetMonikerRequest {
4918 pub component_instance: ::fidl_next::wire::fuchsia::Event,
4919 }
4920
4921 static_assertions::const_assert_eq!(std::mem::size_of::<IntrospectorGetMonikerRequest>(), 4);
4922 static_assertions::const_assert_eq!(std::mem::align_of::<IntrospectorGetMonikerRequest>(), 4);
4923
4924 static_assertions::const_assert_eq!(
4925 std::mem::offset_of!(IntrospectorGetMonikerRequest, component_instance),
4926 0
4927 );
4928
4929 impl ::fidl_next::Constrained for IntrospectorGetMonikerRequest {
4930 type Constraint = ();
4931
4932 fn validate(
4933 _: ::fidl_next::Slot<'_, Self>,
4934 _: Self::Constraint,
4935 ) -> Result<(), ::fidl_next::ValidationError> {
4936 Ok(())
4937 }
4938 }
4939
4940 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerRequest {
4941 type Narrowed<'de> = IntrospectorGetMonikerRequest;
4942
4943 #[inline]
4944 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4945 ::fidl_next::munge! {
4946 let Self {
4947 component_instance,
4948
4949 } = &mut *out_;
4950 }
4951
4952 ::fidl_next::Wire::zero_padding(component_instance);
4953 }
4954 }
4955
4956 unsafe impl<___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerRequest
4957 where
4958 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4959 ___D: ::fidl_next::fuchsia::HandleDecoder,
4960 {
4961 fn decode(
4962 slot_: ::fidl_next::Slot<'_, Self>,
4963 decoder_: &mut ___D,
4964 _: (),
4965 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4966 ::fidl_next::munge! {
4967 let Self {
4968 mut component_instance,
4969
4970 } = slot_;
4971 }
4972
4973 let _field = component_instance.as_mut();
4974
4975 ::fidl_next::Decode::decode(component_instance.as_mut(), decoder_, ())?;
4976
4977 Ok(())
4978 }
4979 }
4980
4981 impl ::fidl_next::IntoNatural for IntrospectorGetMonikerRequest {
4982 type Natural = crate::natural::IntrospectorGetMonikerRequest;
4983 }
4984
4985 #[derive(Debug)]
4987 #[repr(C)]
4988 pub struct NamespaceInputEntry<'de> {
4989 pub path: ::fidl_next::wire::String<'de>,
4990
4991 pub dictionary: ::fidl_next::ClientEnd<
4992 ::fidl_next_fuchsia_component_sandbox::Dictionary,
4993 ::fidl_next::wire::fuchsia::Channel,
4994 >,
4995 }
4996
4997 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry<'_>>(), 24);
4998 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry<'_>>(), 8);
4999
5000 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry<'_>, path), 0);
5001
5002 static_assertions::const_assert_eq!(
5003 std::mem::offset_of!(NamespaceInputEntry<'_>, dictionary),
5004 16
5005 );
5006
5007 impl ::fidl_next::Constrained for NamespaceInputEntry<'_> {
5008 type Constraint = ();
5009
5010 fn validate(
5011 _: ::fidl_next::Slot<'_, Self>,
5012 _: Self::Constraint,
5013 ) -> Result<(), ::fidl_next::ValidationError> {
5014 Ok(())
5015 }
5016 }
5017
5018 unsafe impl ::fidl_next::Wire for NamespaceInputEntry<'static> {
5019 type Narrowed<'de> = NamespaceInputEntry<'de>;
5020
5021 #[inline]
5022 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5023 ::fidl_next::munge! {
5024 let Self {
5025 path,
5026 dictionary,
5027
5028 } = &mut *out_;
5029 }
5030
5031 ::fidl_next::Wire::zero_padding(path);
5032
5033 ::fidl_next::Wire::zero_padding(dictionary);
5034
5035 unsafe {
5036 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5037 }
5038 }
5039 }
5040
5041 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry<'de>
5042 where
5043 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5044 ___D: ::fidl_next::Decoder<'de>,
5045 ___D: ::fidl_next::fuchsia::HandleDecoder,
5046 {
5047 fn decode(
5048 slot_: ::fidl_next::Slot<'_, Self>,
5049 decoder_: &mut ___D,
5050 _: (),
5051 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5052 if slot_.as_bytes()[20..24] != [0u8; 4] {
5053 return Err(::fidl_next::DecodeError::InvalidPadding);
5054 }
5055
5056 ::fidl_next::munge! {
5057 let Self {
5058 mut path,
5059 mut dictionary,
5060
5061 } = slot_;
5062 }
5063
5064 let _field = path.as_mut();
5065 ::fidl_next::Constrained::validate(_field, 4095)?;
5066 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5067
5068 let path = unsafe { path.deref_unchecked() };
5069
5070 if path.len() > 4095 {
5071 return Err(::fidl_next::DecodeError::VectorTooLong {
5072 size: path.len() as u64,
5073 limit: 4095,
5074 });
5075 }
5076
5077 let _field = dictionary.as_mut();
5078
5079 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5080
5081 Ok(())
5082 }
5083 }
5084
5085 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry<'de> {
5086 type Natural = crate::natural::NamespaceInputEntry;
5087 }
5088
5089 #[derive(Debug)]
5091 #[repr(C)]
5092 pub struct NamespaceCreateRequest<'de> {
5093 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry<'de>>,
5094 }
5095
5096 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateRequest<'_>>(), 16);
5097 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateRequest<'_>>(), 8);
5098
5099 static_assertions::const_assert_eq!(
5100 std::mem::offset_of!(NamespaceCreateRequest<'_>, entries),
5101 0
5102 );
5103
5104 impl ::fidl_next::Constrained for NamespaceCreateRequest<'_> {
5105 type Constraint = ();
5106
5107 fn validate(
5108 _: ::fidl_next::Slot<'_, Self>,
5109 _: Self::Constraint,
5110 ) -> Result<(), ::fidl_next::ValidationError> {
5111 Ok(())
5112 }
5113 }
5114
5115 unsafe impl ::fidl_next::Wire for NamespaceCreateRequest<'static> {
5116 type Narrowed<'de> = NamespaceCreateRequest<'de>;
5117
5118 #[inline]
5119 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5120 ::fidl_next::munge! {
5121 let Self {
5122 entries,
5123
5124 } = &mut *out_;
5125 }
5126
5127 ::fidl_next::Wire::zero_padding(entries);
5128 }
5129 }
5130
5131 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateRequest<'de>
5132 where
5133 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5134 ___D: ::fidl_next::Decoder<'de>,
5135 ___D: ::fidl_next::fuchsia::HandleDecoder,
5136 {
5137 fn decode(
5138 slot_: ::fidl_next::Slot<'_, Self>,
5139 decoder_: &mut ___D,
5140 _: (),
5141 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5142 ::fidl_next::munge! {
5143 let Self {
5144 mut entries,
5145
5146 } = slot_;
5147 }
5148
5149 let _field = entries.as_mut();
5150 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5151 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5152
5153 Ok(())
5154 }
5155 }
5156
5157 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateRequest<'de> {
5158 type Natural = crate::natural::NamespaceCreateRequest;
5159 }
5160
5161 #[derive(Debug)]
5163 #[repr(C)]
5164 pub struct NamespaceInputEntry2<'de> {
5165 pub path: ::fidl_next::wire::String<'de>,
5166
5167 pub capability: ::fidl_next::wire::fuchsia::EventPair,
5168 }
5169
5170 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry2<'_>>(), 24);
5171 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry2<'_>>(), 8);
5172
5173 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry2<'_>, path), 0);
5174
5175 static_assertions::const_assert_eq!(
5176 std::mem::offset_of!(NamespaceInputEntry2<'_>, capability),
5177 16
5178 );
5179
5180 impl ::fidl_next::Constrained for NamespaceInputEntry2<'_> {
5181 type Constraint = ();
5182
5183 fn validate(
5184 _: ::fidl_next::Slot<'_, Self>,
5185 _: Self::Constraint,
5186 ) -> Result<(), ::fidl_next::ValidationError> {
5187 Ok(())
5188 }
5189 }
5190
5191 unsafe impl ::fidl_next::Wire for NamespaceInputEntry2<'static> {
5192 type Narrowed<'de> = NamespaceInputEntry2<'de>;
5193
5194 #[inline]
5195 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5196 ::fidl_next::munge! {
5197 let Self {
5198 path,
5199 capability,
5200
5201 } = &mut *out_;
5202 }
5203
5204 ::fidl_next::Wire::zero_padding(path);
5205
5206 ::fidl_next::Wire::zero_padding(capability);
5207
5208 unsafe {
5209 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5210 }
5211 }
5212 }
5213
5214 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry2<'de>
5215 where
5216 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5217 ___D: ::fidl_next::Decoder<'de>,
5218 ___D: ::fidl_next::fuchsia::HandleDecoder,
5219 {
5220 fn decode(
5221 slot_: ::fidl_next::Slot<'_, Self>,
5222 decoder_: &mut ___D,
5223 _: (),
5224 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5225 if slot_.as_bytes()[20..24] != [0u8; 4] {
5226 return Err(::fidl_next::DecodeError::InvalidPadding);
5227 }
5228
5229 ::fidl_next::munge! {
5230 let Self {
5231 mut path,
5232 mut capability,
5233
5234 } = slot_;
5235 }
5236
5237 let _field = path.as_mut();
5238 ::fidl_next::Constrained::validate(_field, 4095)?;
5239 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5240
5241 let path = unsafe { path.deref_unchecked() };
5242
5243 if path.len() > 4095 {
5244 return Err(::fidl_next::DecodeError::VectorTooLong {
5245 size: path.len() as u64,
5246 limit: 4095,
5247 });
5248 }
5249
5250 let _field = capability.as_mut();
5251
5252 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5253
5254 Ok(())
5255 }
5256 }
5257
5258 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry2<'de> {
5259 type Natural = crate::natural::NamespaceInputEntry2;
5260 }
5261
5262 #[derive(Debug)]
5264 #[repr(C)]
5265 pub struct NamespaceCreate2Request<'de> {
5266 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry2<'de>>,
5267 }
5268
5269 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Request<'_>>(), 16);
5270 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Request<'_>>(), 8);
5271
5272 static_assertions::const_assert_eq!(
5273 std::mem::offset_of!(NamespaceCreate2Request<'_>, entries),
5274 0
5275 );
5276
5277 impl ::fidl_next::Constrained for NamespaceCreate2Request<'_> {
5278 type Constraint = ();
5279
5280 fn validate(
5281 _: ::fidl_next::Slot<'_, Self>,
5282 _: Self::Constraint,
5283 ) -> Result<(), ::fidl_next::ValidationError> {
5284 Ok(())
5285 }
5286 }
5287
5288 unsafe impl ::fidl_next::Wire for NamespaceCreate2Request<'static> {
5289 type Narrowed<'de> = NamespaceCreate2Request<'de>;
5290
5291 #[inline]
5292 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5293 ::fidl_next::munge! {
5294 let Self {
5295 entries,
5296
5297 } = &mut *out_;
5298 }
5299
5300 ::fidl_next::Wire::zero_padding(entries);
5301 }
5302 }
5303
5304 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Request<'de>
5305 where
5306 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5307 ___D: ::fidl_next::Decoder<'de>,
5308 ___D: ::fidl_next::fuchsia::HandleDecoder,
5309 {
5310 fn decode(
5311 slot_: ::fidl_next::Slot<'_, Self>,
5312 decoder_: &mut ___D,
5313 _: (),
5314 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5315 ::fidl_next::munge! {
5316 let Self {
5317 mut entries,
5318
5319 } = slot_;
5320 }
5321
5322 let _field = entries.as_mut();
5323 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5324 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5325
5326 Ok(())
5327 }
5328 }
5329
5330 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Request<'de> {
5331 type Natural = crate::natural::NamespaceCreate2Request;
5332 }
5333
5334 #[derive(Debug)]
5336 #[repr(C)]
5337 pub struct NamespaceCreateResponse<'de> {
5338 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5339 }
5340
5341 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateResponse<'_>>(), 16);
5342 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateResponse<'_>>(), 8);
5343
5344 static_assertions::const_assert_eq!(
5345 std::mem::offset_of!(NamespaceCreateResponse<'_>, entries),
5346 0
5347 );
5348
5349 impl ::fidl_next::Constrained for NamespaceCreateResponse<'_> {
5350 type Constraint = ();
5351
5352 fn validate(
5353 _: ::fidl_next::Slot<'_, Self>,
5354 _: Self::Constraint,
5355 ) -> Result<(), ::fidl_next::ValidationError> {
5356 Ok(())
5357 }
5358 }
5359
5360 unsafe impl ::fidl_next::Wire for NamespaceCreateResponse<'static> {
5361 type Narrowed<'de> = NamespaceCreateResponse<'de>;
5362
5363 #[inline]
5364 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5365 ::fidl_next::munge! {
5366 let Self {
5367 entries,
5368
5369 } = &mut *out_;
5370 }
5371
5372 ::fidl_next::Wire::zero_padding(entries);
5373 }
5374 }
5375
5376 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateResponse<'de>
5377 where
5378 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5379 ___D: ::fidl_next::Decoder<'de>,
5380 ___D: ::fidl_next::fuchsia::HandleDecoder,
5381 {
5382 fn decode(
5383 slot_: ::fidl_next::Slot<'_, Self>,
5384 decoder_: &mut ___D,
5385 _: (),
5386 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5387 ::fidl_next::munge! {
5388 let Self {
5389 mut entries,
5390
5391 } = slot_;
5392 }
5393
5394 let _field = entries.as_mut();
5395 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5396 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5397
5398 Ok(())
5399 }
5400 }
5401
5402 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateResponse<'de> {
5403 type Natural = crate::natural::NamespaceCreateResponse;
5404 }
5405
5406 #[derive(Debug)]
5408 #[repr(C)]
5409 pub struct NamespaceCreate2Response<'de> {
5410 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5411 }
5412
5413 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Response<'_>>(), 16);
5414 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Response<'_>>(), 8);
5415
5416 static_assertions::const_assert_eq!(
5417 std::mem::offset_of!(NamespaceCreate2Response<'_>, entries),
5418 0
5419 );
5420
5421 impl ::fidl_next::Constrained for NamespaceCreate2Response<'_> {
5422 type Constraint = ();
5423
5424 fn validate(
5425 _: ::fidl_next::Slot<'_, Self>,
5426 _: Self::Constraint,
5427 ) -> Result<(), ::fidl_next::ValidationError> {
5428 Ok(())
5429 }
5430 }
5431
5432 unsafe impl ::fidl_next::Wire for NamespaceCreate2Response<'static> {
5433 type Narrowed<'de> = NamespaceCreate2Response<'de>;
5434
5435 #[inline]
5436 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5437 ::fidl_next::munge! {
5438 let Self {
5439 entries,
5440
5441 } = &mut *out_;
5442 }
5443
5444 ::fidl_next::Wire::zero_padding(entries);
5445 }
5446 }
5447
5448 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Response<'de>
5449 where
5450 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5451 ___D: ::fidl_next::Decoder<'de>,
5452 ___D: ::fidl_next::fuchsia::HandleDecoder,
5453 {
5454 fn decode(
5455 slot_: ::fidl_next::Slot<'_, Self>,
5456 decoder_: &mut ___D,
5457 _: (),
5458 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5459 ::fidl_next::munge! {
5460 let Self {
5461 mut entries,
5462
5463 } = slot_;
5464 }
5465
5466 let _field = entries.as_mut();
5467 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5468 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5469
5470 Ok(())
5471 }
5472 }
5473
5474 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Response<'de> {
5475 type Natural = crate::natural::NamespaceCreate2Response;
5476 }
5477
5478 #[derive(Debug)]
5480 #[repr(C)]
5481 pub struct RealmListChildrenRequest<'de> {
5482 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
5483
5484 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
5485 }
5486
5487 static_assertions::const_assert_eq!(std::mem::size_of::<RealmListChildrenRequest<'_>>(), 24);
5488 static_assertions::const_assert_eq!(std::mem::align_of::<RealmListChildrenRequest<'_>>(), 8);
5489
5490 static_assertions::const_assert_eq!(
5491 std::mem::offset_of!(RealmListChildrenRequest<'_>, collection),
5492 0
5493 );
5494
5495 static_assertions::const_assert_eq!(
5496 std::mem::offset_of!(RealmListChildrenRequest<'_>, iter),
5497 16
5498 );
5499
5500 impl ::fidl_next::Constrained for RealmListChildrenRequest<'_> {
5501 type Constraint = ();
5502
5503 fn validate(
5504 _: ::fidl_next::Slot<'_, Self>,
5505 _: Self::Constraint,
5506 ) -> Result<(), ::fidl_next::ValidationError> {
5507 Ok(())
5508 }
5509 }
5510
5511 unsafe impl ::fidl_next::Wire for RealmListChildrenRequest<'static> {
5512 type Narrowed<'de> = RealmListChildrenRequest<'de>;
5513
5514 #[inline]
5515 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5516 ::fidl_next::munge! {
5517 let Self {
5518 collection,
5519 iter,
5520
5521 } = &mut *out_;
5522 }
5523
5524 ::fidl_next::Wire::zero_padding(collection);
5525
5526 ::fidl_next::Wire::zero_padding(iter);
5527
5528 unsafe {
5529 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5530 }
5531 }
5532 }
5533
5534 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmListChildrenRequest<'de>
5535 where
5536 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5537 ___D: ::fidl_next::Decoder<'de>,
5538 ___D: ::fidl_next::fuchsia::HandleDecoder,
5539 {
5540 fn decode(
5541 slot_: ::fidl_next::Slot<'_, Self>,
5542 decoder_: &mut ___D,
5543 _: (),
5544 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5545 if slot_.as_bytes()[20..24] != [0u8; 4] {
5546 return Err(::fidl_next::DecodeError::InvalidPadding);
5547 }
5548
5549 ::fidl_next::munge! {
5550 let Self {
5551 mut collection,
5552 mut iter,
5553
5554 } = slot_;
5555 }
5556
5557 let _field = collection.as_mut();
5558
5559 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
5560
5561 let _field = iter.as_mut();
5562
5563 ::fidl_next::Decode::decode(iter.as_mut(), decoder_, ())?;
5564
5565 Ok(())
5566 }
5567 }
5568
5569 impl<'de> ::fidl_next::IntoNatural for RealmListChildrenRequest<'de> {
5570 type Natural = crate::natural::RealmListChildrenRequest;
5571 }
5572
5573 #[derive(Debug)]
5575 #[repr(C)]
5576 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5577 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5578 }
5579
5580 static_assertions::const_assert_eq!(
5581 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5582 32
5583 );
5584 static_assertions::const_assert_eq!(
5585 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5586 8
5587 );
5588
5589 static_assertions::const_assert_eq!(
5590 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedRequest<'_>, child),
5591 0
5592 );
5593
5594 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedRequest<'_> {
5595 type Constraint = ();
5596
5597 fn validate(
5598 _: ::fidl_next::Slot<'_, Self>,
5599 _: Self::Constraint,
5600 ) -> Result<(), ::fidl_next::ValidationError> {
5601 Ok(())
5602 }
5603 }
5604
5605 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedRequest<'static> {
5606 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedRequest<'de>;
5607
5608 #[inline]
5609 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5610 ::fidl_next::munge! {
5611 let Self {
5612 child,
5613
5614 } = &mut *out_;
5615 }
5616
5617 ::fidl_next::Wire::zero_padding(child);
5618 }
5619 }
5620
5621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5622 for RealmGetChildOutputDictionaryDeprecatedRequest<'de>
5623 where
5624 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5625 ___D: ::fidl_next::Decoder<'de>,
5626 ___D: ::fidl_next::fuchsia::HandleDecoder,
5627 {
5628 fn decode(
5629 slot_: ::fidl_next::Slot<'_, Self>,
5630 decoder_: &mut ___D,
5631 _: (),
5632 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5633 ::fidl_next::munge! {
5634 let Self {
5635 mut child,
5636
5637 } = slot_;
5638 }
5639
5640 let _field = child.as_mut();
5641
5642 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5643
5644 Ok(())
5645 }
5646 }
5647
5648 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5649 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
5650 }
5651
5652 #[derive(Debug)]
5654 #[repr(C)]
5655 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
5656 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
5657 }
5658
5659 static_assertions::const_assert_eq!(
5660 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5661 4
5662 );
5663 static_assertions::const_assert_eq!(
5664 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5665 4
5666 );
5667
5668 static_assertions::const_assert_eq!(
5669 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedResponse, dictionary),
5670 0
5671 );
5672
5673 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedResponse {
5674 type Constraint = ();
5675
5676 fn validate(
5677 _: ::fidl_next::Slot<'_, Self>,
5678 _: Self::Constraint,
5679 ) -> Result<(), ::fidl_next::ValidationError> {
5680 Ok(())
5681 }
5682 }
5683
5684 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedResponse {
5685 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedResponse;
5686
5687 #[inline]
5688 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5689 ::fidl_next::munge! {
5690 let Self {
5691 dictionary,
5692
5693 } = &mut *out_;
5694 }
5695
5696 ::fidl_next::Wire::zero_padding(dictionary);
5697 }
5698 }
5699
5700 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryDeprecatedResponse
5701 where
5702 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5703 ___D: ::fidl_next::fuchsia::HandleDecoder,
5704 {
5705 fn decode(
5706 slot_: ::fidl_next::Slot<'_, Self>,
5707 decoder_: &mut ___D,
5708 _: (),
5709 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5710 ::fidl_next::munge! {
5711 let Self {
5712 mut dictionary,
5713
5714 } = slot_;
5715 }
5716
5717 let _field = dictionary.as_mut();
5718
5719 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5720
5721 Ok(())
5722 }
5723 }
5724
5725 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedResponse {
5726 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
5727 }
5728
5729 #[derive(Debug)]
5731 #[repr(C)]
5732 pub struct RealmGetChildOutputDictionaryRequest<'de> {
5733 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5734 }
5735
5736 static_assertions::const_assert_eq!(
5737 std::mem::size_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5738 32
5739 );
5740 static_assertions::const_assert_eq!(
5741 std::mem::align_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5742 8
5743 );
5744
5745 static_assertions::const_assert_eq!(
5746 std::mem::offset_of!(RealmGetChildOutputDictionaryRequest<'_>, child),
5747 0
5748 );
5749
5750 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryRequest<'_> {
5751 type Constraint = ();
5752
5753 fn validate(
5754 _: ::fidl_next::Slot<'_, Self>,
5755 _: Self::Constraint,
5756 ) -> Result<(), ::fidl_next::ValidationError> {
5757 Ok(())
5758 }
5759 }
5760
5761 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryRequest<'static> {
5762 type Narrowed<'de> = RealmGetChildOutputDictionaryRequest<'de>;
5763
5764 #[inline]
5765 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5766 ::fidl_next::munge! {
5767 let Self {
5768 child,
5769
5770 } = &mut *out_;
5771 }
5772
5773 ::fidl_next::Wire::zero_padding(child);
5774 }
5775 }
5776
5777 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryRequest<'de>
5778 where
5779 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5780 ___D: ::fidl_next::Decoder<'de>,
5781 ___D: ::fidl_next::fuchsia::HandleDecoder,
5782 {
5783 fn decode(
5784 slot_: ::fidl_next::Slot<'_, Self>,
5785 decoder_: &mut ___D,
5786 _: (),
5787 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5788 ::fidl_next::munge! {
5789 let Self {
5790 mut child,
5791
5792 } = slot_;
5793 }
5794
5795 let _field = child.as_mut();
5796
5797 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5798
5799 Ok(())
5800 }
5801 }
5802
5803 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryRequest<'de> {
5804 type Natural = crate::natural::RealmGetChildOutputDictionaryRequest;
5805 }
5806
5807 #[derive(Debug)]
5809 #[repr(C)]
5810 pub struct RealmGetChildOutputDictionaryResponse {
5811 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
5812 }
5813
5814 static_assertions::const_assert_eq!(
5815 std::mem::size_of::<RealmGetChildOutputDictionaryResponse>(),
5816 4
5817 );
5818 static_assertions::const_assert_eq!(
5819 std::mem::align_of::<RealmGetChildOutputDictionaryResponse>(),
5820 4
5821 );
5822
5823 static_assertions::const_assert_eq!(
5824 std::mem::offset_of!(RealmGetChildOutputDictionaryResponse, dictionary),
5825 0
5826 );
5827
5828 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryResponse {
5829 type Constraint = ();
5830
5831 fn validate(
5832 _: ::fidl_next::Slot<'_, Self>,
5833 _: Self::Constraint,
5834 ) -> Result<(), ::fidl_next::ValidationError> {
5835 Ok(())
5836 }
5837 }
5838
5839 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryResponse {
5840 type Narrowed<'de> = RealmGetChildOutputDictionaryResponse;
5841
5842 #[inline]
5843 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5844 ::fidl_next::munge! {
5845 let Self {
5846 dictionary,
5847
5848 } = &mut *out_;
5849 }
5850
5851 ::fidl_next::Wire::zero_padding(dictionary);
5852 }
5853 }
5854
5855 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryResponse
5856 where
5857 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5858 ___D: ::fidl_next::fuchsia::HandleDecoder,
5859 {
5860 fn decode(
5861 slot_: ::fidl_next::Slot<'_, Self>,
5862 decoder_: &mut ___D,
5863 _: (),
5864 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5865 ::fidl_next::munge! {
5866 let Self {
5867 mut dictionary,
5868
5869 } = slot_;
5870 }
5871
5872 let _field = dictionary.as_mut();
5873
5874 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5875
5876 Ok(())
5877 }
5878 }
5879
5880 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryResponse {
5881 type Natural = crate::natural::RealmGetChildOutputDictionaryResponse;
5882 }
5883
5884 #[derive(Debug)]
5886 #[repr(C)]
5887 pub struct RealmOpenControllerRequest<'de> {
5888 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5889
5890 pub controller:
5891 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
5892 }
5893
5894 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenControllerRequest<'_>>(), 40);
5895 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenControllerRequest<'_>>(), 8);
5896
5897 static_assertions::const_assert_eq!(
5898 std::mem::offset_of!(RealmOpenControllerRequest<'_>, child),
5899 0
5900 );
5901
5902 static_assertions::const_assert_eq!(
5903 std::mem::offset_of!(RealmOpenControllerRequest<'_>, controller),
5904 32
5905 );
5906
5907 impl ::fidl_next::Constrained for RealmOpenControllerRequest<'_> {
5908 type Constraint = ();
5909
5910 fn validate(
5911 _: ::fidl_next::Slot<'_, Self>,
5912 _: Self::Constraint,
5913 ) -> Result<(), ::fidl_next::ValidationError> {
5914 Ok(())
5915 }
5916 }
5917
5918 unsafe impl ::fidl_next::Wire for RealmOpenControllerRequest<'static> {
5919 type Narrowed<'de> = RealmOpenControllerRequest<'de>;
5920
5921 #[inline]
5922 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5923 ::fidl_next::munge! {
5924 let Self {
5925 child,
5926 controller,
5927
5928 } = &mut *out_;
5929 }
5930
5931 ::fidl_next::Wire::zero_padding(child);
5932
5933 ::fidl_next::Wire::zero_padding(controller);
5934
5935 unsafe {
5936 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
5937 }
5938 }
5939 }
5940
5941 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenControllerRequest<'de>
5942 where
5943 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5944 ___D: ::fidl_next::Decoder<'de>,
5945 ___D: ::fidl_next::fuchsia::HandleDecoder,
5946 {
5947 fn decode(
5948 slot_: ::fidl_next::Slot<'_, Self>,
5949 decoder_: &mut ___D,
5950 _: (),
5951 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5952 if slot_.as_bytes()[36..40] != [0u8; 4] {
5953 return Err(::fidl_next::DecodeError::InvalidPadding);
5954 }
5955
5956 ::fidl_next::munge! {
5957 let Self {
5958 mut child,
5959 mut controller,
5960
5961 } = slot_;
5962 }
5963
5964 let _field = child.as_mut();
5965
5966 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5967
5968 let _field = controller.as_mut();
5969
5970 ::fidl_next::Decode::decode(controller.as_mut(), decoder_, ())?;
5971
5972 Ok(())
5973 }
5974 }
5975
5976 impl<'de> ::fidl_next::IntoNatural for RealmOpenControllerRequest<'de> {
5977 type Natural = crate::natural::RealmOpenControllerRequest;
5978 }
5979
5980 #[derive(Debug)]
5982 #[repr(C)]
5983 pub struct RealmOpenExposedDirRequest<'de> {
5984 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5985
5986 pub exposed_dir: ::fidl_next::ServerEnd<
5987 ::fidl_next_fuchsia_io::Directory,
5988 ::fidl_next::wire::fuchsia::Channel,
5989 >,
5990 }
5991
5992 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenExposedDirRequest<'_>>(), 40);
5993 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenExposedDirRequest<'_>>(), 8);
5994
5995 static_assertions::const_assert_eq!(
5996 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, child),
5997 0
5998 );
5999
6000 static_assertions::const_assert_eq!(
6001 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, exposed_dir),
6002 32
6003 );
6004
6005 impl ::fidl_next::Constrained for RealmOpenExposedDirRequest<'_> {
6006 type Constraint = ();
6007
6008 fn validate(
6009 _: ::fidl_next::Slot<'_, Self>,
6010 _: Self::Constraint,
6011 ) -> Result<(), ::fidl_next::ValidationError> {
6012 Ok(())
6013 }
6014 }
6015
6016 unsafe impl ::fidl_next::Wire for RealmOpenExposedDirRequest<'static> {
6017 type Narrowed<'de> = RealmOpenExposedDirRequest<'de>;
6018
6019 #[inline]
6020 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6021 ::fidl_next::munge! {
6022 let Self {
6023 child,
6024 exposed_dir,
6025
6026 } = &mut *out_;
6027 }
6028
6029 ::fidl_next::Wire::zero_padding(child);
6030
6031 ::fidl_next::Wire::zero_padding(exposed_dir);
6032
6033 unsafe {
6034 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6035 }
6036 }
6037 }
6038
6039 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenExposedDirRequest<'de>
6040 where
6041 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6042 ___D: ::fidl_next::Decoder<'de>,
6043 ___D: ::fidl_next::fuchsia::HandleDecoder,
6044 {
6045 fn decode(
6046 slot_: ::fidl_next::Slot<'_, Self>,
6047 decoder_: &mut ___D,
6048 _: (),
6049 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6050 if slot_.as_bytes()[36..40] != [0u8; 4] {
6051 return Err(::fidl_next::DecodeError::InvalidPadding);
6052 }
6053
6054 ::fidl_next::munge! {
6055 let Self {
6056 mut child,
6057 mut exposed_dir,
6058
6059 } = slot_;
6060 }
6061
6062 let _field = child.as_mut();
6063
6064 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6065
6066 let _field = exposed_dir.as_mut();
6067
6068 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
6069
6070 Ok(())
6071 }
6072 }
6073
6074 impl<'de> ::fidl_next::IntoNatural for RealmOpenExposedDirRequest<'de> {
6075 type Natural = crate::natural::RealmOpenExposedDirRequest;
6076 }
6077
6078 #[derive(Debug)]
6080 #[repr(C)]
6081 pub struct RealmCreateChildRequest<'de> {
6082 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
6083
6084 pub decl: ::fidl_next_fuchsia_component_decl::wire::Child<'de>,
6085
6086 pub args: crate::wire::CreateChildArgs<'de>,
6087 }
6088
6089 static_assertions::const_assert_eq!(std::mem::size_of::<RealmCreateChildRequest<'_>>(), 48);
6090 static_assertions::const_assert_eq!(std::mem::align_of::<RealmCreateChildRequest<'_>>(), 8);
6091
6092 static_assertions::const_assert_eq!(
6093 std::mem::offset_of!(RealmCreateChildRequest<'_>, collection),
6094 0
6095 );
6096
6097 static_assertions::const_assert_eq!(
6098 std::mem::offset_of!(RealmCreateChildRequest<'_>, decl),
6099 16
6100 );
6101
6102 static_assertions::const_assert_eq!(
6103 std::mem::offset_of!(RealmCreateChildRequest<'_>, args),
6104 32
6105 );
6106
6107 impl ::fidl_next::Constrained for RealmCreateChildRequest<'_> {
6108 type Constraint = ();
6109
6110 fn validate(
6111 _: ::fidl_next::Slot<'_, Self>,
6112 _: Self::Constraint,
6113 ) -> Result<(), ::fidl_next::ValidationError> {
6114 Ok(())
6115 }
6116 }
6117
6118 unsafe impl ::fidl_next::Wire for RealmCreateChildRequest<'static> {
6119 type Narrowed<'de> = RealmCreateChildRequest<'de>;
6120
6121 #[inline]
6122 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6123 ::fidl_next::munge! {
6124 let Self {
6125 collection,
6126 decl,
6127 args,
6128
6129 } = &mut *out_;
6130 }
6131
6132 ::fidl_next::Wire::zero_padding(collection);
6133
6134 ::fidl_next::Wire::zero_padding(decl);
6135
6136 ::fidl_next::Wire::zero_padding(args);
6137 }
6138 }
6139
6140 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmCreateChildRequest<'de>
6141 where
6142 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6143 ___D: ::fidl_next::Decoder<'de>,
6144 ___D: ::fidl_next::fuchsia::HandleDecoder,
6145 {
6146 fn decode(
6147 slot_: ::fidl_next::Slot<'_, Self>,
6148 decoder_: &mut ___D,
6149 _: (),
6150 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6151 ::fidl_next::munge! {
6152 let Self {
6153 mut collection,
6154 mut decl,
6155 mut args,
6156
6157 } = slot_;
6158 }
6159
6160 let _field = collection.as_mut();
6161
6162 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
6163
6164 let _field = decl.as_mut();
6165
6166 ::fidl_next::Decode::decode(decl.as_mut(), decoder_, ())?;
6167
6168 let _field = args.as_mut();
6169
6170 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
6171
6172 Ok(())
6173 }
6174 }
6175
6176 impl<'de> ::fidl_next::IntoNatural for RealmCreateChildRequest<'de> {
6177 type Natural = crate::natural::RealmCreateChildRequest;
6178 }
6179
6180 #[derive(Debug)]
6182 #[repr(C)]
6183 pub struct RealmGetResolvedInfoResponse<'de> {
6184 pub resolved_info: ::fidl_next_fuchsia_component_resolution::wire::Component<'de>,
6185 }
6186
6187 static_assertions::const_assert_eq!(
6188 std::mem::size_of::<RealmGetResolvedInfoResponse<'_>>(),
6189 16
6190 );
6191 static_assertions::const_assert_eq!(
6192 std::mem::align_of::<RealmGetResolvedInfoResponse<'_>>(),
6193 8
6194 );
6195
6196 static_assertions::const_assert_eq!(
6197 std::mem::offset_of!(RealmGetResolvedInfoResponse<'_>, resolved_info),
6198 0
6199 );
6200
6201 impl ::fidl_next::Constrained for RealmGetResolvedInfoResponse<'_> {
6202 type Constraint = ();
6203
6204 fn validate(
6205 _: ::fidl_next::Slot<'_, Self>,
6206 _: Self::Constraint,
6207 ) -> Result<(), ::fidl_next::ValidationError> {
6208 Ok(())
6209 }
6210 }
6211
6212 unsafe impl ::fidl_next::Wire for RealmGetResolvedInfoResponse<'static> {
6213 type Narrowed<'de> = RealmGetResolvedInfoResponse<'de>;
6214
6215 #[inline]
6216 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6217 ::fidl_next::munge! {
6218 let Self {
6219 resolved_info,
6220
6221 } = &mut *out_;
6222 }
6223
6224 ::fidl_next::Wire::zero_padding(resolved_info);
6225 }
6226 }
6227
6228 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetResolvedInfoResponse<'de>
6229 where
6230 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6231 ___D: ::fidl_next::Decoder<'de>,
6232 ___D: ::fidl_next::fuchsia::HandleDecoder,
6233 {
6234 fn decode(
6235 slot_: ::fidl_next::Slot<'_, Self>,
6236 decoder_: &mut ___D,
6237 _: (),
6238 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6239 ::fidl_next::munge! {
6240 let Self {
6241 mut resolved_info,
6242
6243 } = slot_;
6244 }
6245
6246 let _field = resolved_info.as_mut();
6247
6248 ::fidl_next::Decode::decode(resolved_info.as_mut(), decoder_, ())?;
6249
6250 Ok(())
6251 }
6252 }
6253
6254 impl<'de> ::fidl_next::IntoNatural for RealmGetResolvedInfoResponse<'de> {
6255 type Natural = crate::natural::RealmGetResolvedInfoResponse;
6256 }
6257
6258 #[derive(Debug)]
6260 #[repr(C)]
6261 pub struct StorageAdminListStorageInRealmRequest<'de> {
6262 pub relative_moniker: ::fidl_next::wire::String<'de>,
6263
6264 pub iterator:
6265 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
6266 }
6267
6268 static_assertions::const_assert_eq!(
6269 std::mem::size_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6270 24
6271 );
6272 static_assertions::const_assert_eq!(
6273 std::mem::align_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6274 8
6275 );
6276
6277 static_assertions::const_assert_eq!(
6278 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, relative_moniker),
6279 0
6280 );
6281
6282 static_assertions::const_assert_eq!(
6283 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, iterator),
6284 16
6285 );
6286
6287 impl ::fidl_next::Constrained for StorageAdminListStorageInRealmRequest<'_> {
6288 type Constraint = ();
6289
6290 fn validate(
6291 _: ::fidl_next::Slot<'_, Self>,
6292 _: Self::Constraint,
6293 ) -> Result<(), ::fidl_next::ValidationError> {
6294 Ok(())
6295 }
6296 }
6297
6298 unsafe impl ::fidl_next::Wire for StorageAdminListStorageInRealmRequest<'static> {
6299 type Narrowed<'de> = StorageAdminListStorageInRealmRequest<'de>;
6300
6301 #[inline]
6302 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6303 ::fidl_next::munge! {
6304 let Self {
6305 relative_moniker,
6306 iterator,
6307
6308 } = &mut *out_;
6309 }
6310
6311 ::fidl_next::Wire::zero_padding(relative_moniker);
6312
6313 ::fidl_next::Wire::zero_padding(iterator);
6314
6315 unsafe {
6316 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6317 }
6318 }
6319 }
6320
6321 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminListStorageInRealmRequest<'de>
6322 where
6323 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6324 ___D: ::fidl_next::Decoder<'de>,
6325 ___D: ::fidl_next::fuchsia::HandleDecoder,
6326 {
6327 fn decode(
6328 slot_: ::fidl_next::Slot<'_, Self>,
6329 decoder_: &mut ___D,
6330 _: (),
6331 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6332 if slot_.as_bytes()[20..24] != [0u8; 4] {
6333 return Err(::fidl_next::DecodeError::InvalidPadding);
6334 }
6335
6336 ::fidl_next::munge! {
6337 let Self {
6338 mut relative_moniker,
6339 mut iterator,
6340
6341 } = slot_;
6342 }
6343
6344 let _field = relative_moniker.as_mut();
6345 ::fidl_next::Constrained::validate(_field, 4096)?;
6346 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6347
6348 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6349
6350 if relative_moniker.len() > 4096 {
6351 return Err(::fidl_next::DecodeError::VectorTooLong {
6352 size: relative_moniker.len() as u64,
6353 limit: 4096,
6354 });
6355 }
6356
6357 let _field = iterator.as_mut();
6358
6359 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
6360
6361 Ok(())
6362 }
6363 }
6364
6365 impl<'de> ::fidl_next::IntoNatural for StorageAdminListStorageInRealmRequest<'de> {
6366 type Natural = crate::natural::StorageAdminListStorageInRealmRequest;
6367 }
6368
6369 #[derive(Debug)]
6371 #[repr(C)]
6372 pub struct StorageAdminOpenStorageRequest<'de> {
6373 pub relative_moniker: ::fidl_next::wire::String<'de>,
6374
6375 pub object: ::fidl_next::ServerEnd<
6376 ::fidl_next_fuchsia_io::Node,
6377 ::fidl_next::wire::fuchsia::Channel,
6378 >,
6379 }
6380
6381 static_assertions::const_assert_eq!(
6382 std::mem::size_of::<StorageAdminOpenStorageRequest<'_>>(),
6383 24
6384 );
6385 static_assertions::const_assert_eq!(
6386 std::mem::align_of::<StorageAdminOpenStorageRequest<'_>>(),
6387 8
6388 );
6389
6390 static_assertions::const_assert_eq!(
6391 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, relative_moniker),
6392 0
6393 );
6394
6395 static_assertions::const_assert_eq!(
6396 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, object),
6397 16
6398 );
6399
6400 impl ::fidl_next::Constrained for StorageAdminOpenStorageRequest<'_> {
6401 type Constraint = ();
6402
6403 fn validate(
6404 _: ::fidl_next::Slot<'_, Self>,
6405 _: Self::Constraint,
6406 ) -> Result<(), ::fidl_next::ValidationError> {
6407 Ok(())
6408 }
6409 }
6410
6411 unsafe impl ::fidl_next::Wire for StorageAdminOpenStorageRequest<'static> {
6412 type Narrowed<'de> = StorageAdminOpenStorageRequest<'de>;
6413
6414 #[inline]
6415 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6416 ::fidl_next::munge! {
6417 let Self {
6418 relative_moniker,
6419 object,
6420
6421 } = &mut *out_;
6422 }
6423
6424 ::fidl_next::Wire::zero_padding(relative_moniker);
6425
6426 ::fidl_next::Wire::zero_padding(object);
6427
6428 unsafe {
6429 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6430 }
6431 }
6432 }
6433
6434 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminOpenStorageRequest<'de>
6435 where
6436 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6437 ___D: ::fidl_next::Decoder<'de>,
6438 ___D: ::fidl_next::fuchsia::HandleDecoder,
6439 {
6440 fn decode(
6441 slot_: ::fidl_next::Slot<'_, Self>,
6442 decoder_: &mut ___D,
6443 _: (),
6444 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6445 if slot_.as_bytes()[20..24] != [0u8; 4] {
6446 return Err(::fidl_next::DecodeError::InvalidPadding);
6447 }
6448
6449 ::fidl_next::munge! {
6450 let Self {
6451 mut relative_moniker,
6452 mut object,
6453
6454 } = slot_;
6455 }
6456
6457 let _field = relative_moniker.as_mut();
6458 ::fidl_next::Constrained::validate(_field, 4096)?;
6459 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6460
6461 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6462
6463 if relative_moniker.len() > 4096 {
6464 return Err(::fidl_next::DecodeError::VectorTooLong {
6465 size: relative_moniker.len() as u64,
6466 limit: 4096,
6467 });
6468 }
6469
6470 let _field = object.as_mut();
6471
6472 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6473
6474 Ok(())
6475 }
6476 }
6477
6478 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenStorageRequest<'de> {
6479 type Natural = crate::natural::StorageAdminOpenStorageRequest;
6480 }
6481
6482 #[derive(Debug)]
6484 #[repr(C)]
6485 pub struct StorageAdminOpenComponentStorageByIdRequest<'de> {
6486 pub id: ::fidl_next::wire::String<'de>,
6487
6488 pub object: ::fidl_next::ServerEnd<
6489 ::fidl_next_fuchsia_io::Node,
6490 ::fidl_next::wire::fuchsia::Channel,
6491 >,
6492 }
6493
6494 static_assertions::const_assert_eq!(
6495 std::mem::size_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6496 24
6497 );
6498 static_assertions::const_assert_eq!(
6499 std::mem::align_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6500 8
6501 );
6502
6503 static_assertions::const_assert_eq!(
6504 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, id),
6505 0
6506 );
6507
6508 static_assertions::const_assert_eq!(
6509 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, object),
6510 16
6511 );
6512
6513 impl ::fidl_next::Constrained for StorageAdminOpenComponentStorageByIdRequest<'_> {
6514 type Constraint = ();
6515
6516 fn validate(
6517 _: ::fidl_next::Slot<'_, Self>,
6518 _: Self::Constraint,
6519 ) -> Result<(), ::fidl_next::ValidationError> {
6520 Ok(())
6521 }
6522 }
6523
6524 unsafe impl ::fidl_next::Wire for StorageAdminOpenComponentStorageByIdRequest<'static> {
6525 type Narrowed<'de> = StorageAdminOpenComponentStorageByIdRequest<'de>;
6526
6527 #[inline]
6528 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6529 ::fidl_next::munge! {
6530 let Self {
6531 id,
6532 object,
6533
6534 } = &mut *out_;
6535 }
6536
6537 ::fidl_next::Wire::zero_padding(id);
6538
6539 ::fidl_next::Wire::zero_padding(object);
6540
6541 unsafe {
6542 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6543 }
6544 }
6545 }
6546
6547 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
6548 for StorageAdminOpenComponentStorageByIdRequest<'de>
6549 where
6550 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6551 ___D: ::fidl_next::Decoder<'de>,
6552 ___D: ::fidl_next::fuchsia::HandleDecoder,
6553 {
6554 fn decode(
6555 slot_: ::fidl_next::Slot<'_, Self>,
6556 decoder_: &mut ___D,
6557 _: (),
6558 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6559 if slot_.as_bytes()[20..24] != [0u8; 4] {
6560 return Err(::fidl_next::DecodeError::InvalidPadding);
6561 }
6562
6563 ::fidl_next::munge! {
6564 let Self {
6565 mut id,
6566 mut object,
6567
6568 } = slot_;
6569 }
6570
6571 let _field = id.as_mut();
6572 ::fidl_next::Constrained::validate(_field, 64)?;
6573 ::fidl_next::Decode::decode(id.as_mut(), decoder_, 64)?;
6574
6575 let id = unsafe { id.deref_unchecked() };
6576
6577 if id.len() > 64 {
6578 return Err(::fidl_next::DecodeError::VectorTooLong {
6579 size: id.len() as u64,
6580 limit: 64,
6581 });
6582 }
6583
6584 let _field = object.as_mut();
6585
6586 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6587
6588 Ok(())
6589 }
6590 }
6591
6592 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenComponentStorageByIdRequest<'de> {
6593 type Natural = crate::natural::StorageAdminOpenComponentStorageByIdRequest;
6594 }
6595}
6596
6597pub mod wire_optional {
6598
6599 pub use fidl_next_common_fuchsia_component::wire_optional::*;
6600
6601 #[repr(transparent)]
6602 pub struct EventPayload<'de> {
6603 pub(crate) raw: ::fidl_next::wire::Union,
6604 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6605 }
6606
6607 impl ::fidl_next::Constrained for EventPayload<'_> {
6608 type Constraint = ();
6609
6610 fn validate(
6611 _: ::fidl_next::Slot<'_, Self>,
6612 _: Self::Constraint,
6613 ) -> Result<(), ::fidl_next::ValidationError> {
6614 Ok(())
6615 }
6616 }
6617
6618 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
6619 type Narrowed<'de> = EventPayload<'de>;
6620
6621 #[inline]
6622 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6623 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6624 ::fidl_next::wire::Union::zero_padding(raw);
6625 }
6626 }
6627
6628 impl<'de> EventPayload<'de> {
6629 pub fn is_some(&self) -> bool {
6630 self.raw.is_some()
6631 }
6632
6633 pub fn is_none(&self) -> bool {
6634 self.raw.is_none()
6635 }
6636
6637 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
6638 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6639 }
6640
6641 pub fn into_option(self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
6642 if self.is_some() {
6643 Some(crate::wire::EventPayload {
6644 raw: self.raw,
6645 _phantom: ::core::marker::PhantomData,
6646 })
6647 } else {
6648 None
6649 }
6650 }
6651 }
6652
6653 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
6654 where
6655 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6656 ___D: ::fidl_next::Decoder<'de>,
6657 ___D: ::fidl_next::fuchsia::HandleDecoder,
6658 {
6659 fn decode(
6660 mut slot: ::fidl_next::Slot<'_, Self>,
6661 decoder: &mut ___D,
6662 _: (),
6663 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6664 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6665 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6666 1 => ::fidl_next::wire::Union::decode_as::<
6667 ___D,
6668 crate::wire::CapabilityRequestedPayload<'de>,
6669 >(raw, decoder, ())?,
6670
6671 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
6672 raw,
6673 decoder,
6674 (),
6675 )?,
6676
6677 4 => ::fidl_next::wire::Union::decode_as::<
6678 ___D,
6679 crate::wire::DiscoveredPayload<'de>,
6680 >(raw, decoder, ())?,
6681
6682 5 => {
6683 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
6684 raw,
6685 decoder,
6686 (),
6687 )?
6688 }
6689
6690 6 => {
6691 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
6692 raw,
6693 decoder,
6694 (),
6695 )?
6696 }
6697
6698 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
6699 raw,
6700 decoder,
6701 (),
6702 )?,
6703
6704 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
6705 raw,
6706 decoder,
6707 (),
6708 )?,
6709
6710 9 => ::fidl_next::wire::Union::decode_as::<
6711 ___D,
6712 crate::wire::DebugStartedPayload<'de>,
6713 >(raw, decoder, ())?,
6714
6715 10 => ::fidl_next::wire::Union::decode_as::<
6716 ___D,
6717 crate::wire::UnresolvedPayload<'de>,
6718 >(raw, decoder, ())?,
6719
6720 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
6721 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
6722 }
6723
6724 Ok(())
6725 }
6726 }
6727
6728 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
6729 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6730 self.as_ref().fmt(f)
6731 }
6732 }
6733
6734 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
6735 type Natural = ::core::option::Option<crate::natural::EventPayload>;
6736 }
6737}
6738
6739pub mod generic {
6740
6741 pub use fidl_next_common_fuchsia_component::generic::*;
6742
6743 pub struct ControllerIsStartedResponse<T0> {
6745 pub is_started: T0,
6746 }
6747
6748 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
6749 for ControllerIsStartedResponse<T0>
6750 where
6751 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6752 ___E: ::fidl_next::fuchsia::HandleEncoder,
6753 T0: ::fidl_next::Encode<bool, ___E>,
6754 {
6755 #[inline]
6756 fn encode(
6757 self,
6758 encoder_: &mut ___E,
6759 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
6760 _: (),
6761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6762 ::fidl_next::munge! {
6763 let crate::wire::ControllerIsStartedResponse {
6764 is_started,
6765
6766 } = out_;
6767 }
6768
6769 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
6770
6771 Ok(())
6772 }
6773 }
6774
6775 pub struct ControllerGetExposedDictionaryResponse<T0> {
6777 pub dictionary: T0,
6778 }
6779
6780 unsafe impl<___E, T0>
6781 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
6782 for ControllerGetExposedDictionaryResponse<T0>
6783 where
6784 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6785 ___E: ::fidl_next::fuchsia::HandleEncoder,
6786 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
6787 {
6788 #[inline]
6789 fn encode(
6790 self,
6791 encoder_: &mut ___E,
6792 out_: &mut ::core::mem::MaybeUninit<
6793 crate::wire::ControllerGetExposedDictionaryResponse,
6794 >,
6795 _: (),
6796 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6797 ::fidl_next::munge! {
6798 let crate::wire::ControllerGetExposedDictionaryResponse {
6799 dictionary,
6800
6801 } = out_;
6802 }
6803
6804 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6805
6806 Ok(())
6807 }
6808 }
6809
6810 pub struct ControllerGetOutputDictionaryResponse<T0> {
6812 pub dictionary: T0,
6813 }
6814
6815 unsafe impl<___E, T0>
6816 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
6817 for ControllerGetOutputDictionaryResponse<T0>
6818 where
6819 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6820 ___E: ::fidl_next::fuchsia::HandleEncoder,
6821 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
6822 {
6823 #[inline]
6824 fn encode(
6825 self,
6826 encoder_: &mut ___E,
6827 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
6828 _: (),
6829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6830 ::fidl_next::munge! {
6831 let crate::wire::ControllerGetOutputDictionaryResponse {
6832 dictionary,
6833
6834 } = out_;
6835 }
6836
6837 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6838
6839 Ok(())
6840 }
6841 }
6842
6843 pub struct ControllerStartRequest<T0, T1> {
6845 pub args: T0,
6846
6847 pub execution_controller: T1,
6848 }
6849
6850 unsafe impl<___E, T0, T1>
6851 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
6852 for ControllerStartRequest<T0, T1>
6853 where
6854 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6855 ___E: ::fidl_next::Encoder,
6856 ___E: ::fidl_next::fuchsia::HandleEncoder,
6857 T0: ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E>,
6858 T1: ::fidl_next::Encode<
6859 ::fidl_next::ServerEnd<
6860 crate::ExecutionController,
6861 ::fidl_next::wire::fuchsia::Channel,
6862 >,
6863 ___E,
6864 >,
6865 {
6866 #[inline]
6867 fn encode(
6868 self,
6869 encoder_: &mut ___E,
6870 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
6871 _: (),
6872 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6873 ::fidl_next::munge! {
6874 let crate::wire::ControllerStartRequest {
6875 args,
6876 execution_controller,
6877
6878 } = out_;
6879 }
6880
6881 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
6882
6883 ::fidl_next::Encode::encode(
6884 self.execution_controller,
6885 encoder_,
6886 execution_controller,
6887 (),
6888 )?;
6889
6890 Ok(())
6891 }
6892 }
6893
6894 pub struct ControllerOpenExposedDirRequest<T0> {
6896 pub exposed_dir: T0,
6897 }
6898
6899 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
6900 for ControllerOpenExposedDirRequest<T0>
6901 where
6902 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6903 ___E: ::fidl_next::fuchsia::HandleEncoder,
6904 T0: ::fidl_next::Encode<
6905 ::fidl_next::ServerEnd<
6906 ::fidl_next_fuchsia_io::Directory,
6907 ::fidl_next::wire::fuchsia::Channel,
6908 >,
6909 ___E,
6910 >,
6911 {
6912 #[inline]
6913 fn encode(
6914 self,
6915 encoder_: &mut ___E,
6916 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
6917 _: (),
6918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6919 ::fidl_next::munge! {
6920 let crate::wire::ControllerOpenExposedDirRequest {
6921 exposed_dir,
6922
6923 } = out_;
6924 }
6925
6926 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
6927
6928 Ok(())
6929 }
6930 }
6931
6932 pub struct EventStreamGetNextResponse<T0> {
6934 pub events: T0,
6935 }
6936
6937 unsafe impl<___E, T0>
6938 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
6939 for EventStreamGetNextResponse<T0>
6940 where
6941 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6942 ___E: ::fidl_next::Encoder,
6943 ___E: ::fidl_next::fuchsia::HandleEncoder,
6944 T0: ::fidl_next::Encode<
6945 ::fidl_next::wire::Vector<'static, crate::wire::Event<'static>>,
6946 ___E,
6947 >,
6948 {
6949 #[inline]
6950 fn encode(
6951 self,
6952 encoder_: &mut ___E,
6953 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
6954 _: (),
6955 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6956 ::fidl_next::munge! {
6957 let crate::wire::EventStreamGetNextResponse {
6958 events,
6959
6960 } = out_;
6961 }
6962
6963 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
6964
6965 Ok(())
6966 }
6967 }
6968
6969 pub struct IntrospectorGetMonikerRequest<T0> {
6971 pub component_instance: T0,
6972 }
6973
6974 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
6975 for IntrospectorGetMonikerRequest<T0>
6976 where
6977 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6978 ___E: ::fidl_next::fuchsia::HandleEncoder,
6979 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
6980 {
6981 #[inline]
6982 fn encode(
6983 self,
6984 encoder_: &mut ___E,
6985 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
6986 _: (),
6987 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6988 ::fidl_next::munge! {
6989 let crate::wire::IntrospectorGetMonikerRequest {
6990 component_instance,
6991
6992 } = out_;
6993 }
6994
6995 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
6996
6997 Ok(())
6998 }
6999 }
7000
7001 pub struct NamespaceInputEntry<T0, T1> {
7003 pub path: T0,
7004
7005 pub dictionary: T1,
7006 }
7007
7008 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
7009 for NamespaceInputEntry<T0, T1>
7010 where
7011 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7012 ___E: ::fidl_next::Encoder,
7013 ___E: ::fidl_next::fuchsia::HandleEncoder,
7014 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7015 T1: ::fidl_next::Encode<
7016 ::fidl_next::ClientEnd<
7017 ::fidl_next_fuchsia_component_sandbox::Dictionary,
7018 ::fidl_next::wire::fuchsia::Channel,
7019 >,
7020 ___E,
7021 >,
7022 {
7023 #[inline]
7024 fn encode(
7025 self,
7026 encoder_: &mut ___E,
7027 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
7028 _: (),
7029 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7030 ::fidl_next::munge! {
7031 let crate::wire::NamespaceInputEntry {
7032 path,
7033 dictionary,
7034
7035 } = out_;
7036 }
7037
7038 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7039
7040 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7041
7042 Ok(())
7043 }
7044 }
7045
7046 pub struct NamespaceCreateRequest<T0> {
7048 pub entries: T0,
7049 }
7050
7051 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
7052 for NamespaceCreateRequest<T0>
7053 where
7054 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7055 ___E: ::fidl_next::Encoder,
7056 ___E: ::fidl_next::fuchsia::HandleEncoder,
7057 T0: ::fidl_next::Encode<
7058 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
7059 ___E,
7060 >,
7061 {
7062 #[inline]
7063 fn encode(
7064 self,
7065 encoder_: &mut ___E,
7066 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
7067 _: (),
7068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7069 ::fidl_next::munge! {
7070 let crate::wire::NamespaceCreateRequest {
7071 entries,
7072
7073 } = out_;
7074 }
7075
7076 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7077
7078 Ok(())
7079 }
7080 }
7081
7082 pub struct NamespaceInputEntry2<T0, T1> {
7084 pub path: T0,
7085
7086 pub capability: T1,
7087 }
7088
7089 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
7090 for NamespaceInputEntry2<T0, T1>
7091 where
7092 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7093 ___E: ::fidl_next::Encoder,
7094 ___E: ::fidl_next::fuchsia::HandleEncoder,
7095 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7096 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7097 {
7098 #[inline]
7099 fn encode(
7100 self,
7101 encoder_: &mut ___E,
7102 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
7103 _: (),
7104 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7105 ::fidl_next::munge! {
7106 let crate::wire::NamespaceInputEntry2 {
7107 path,
7108 capability,
7109
7110 } = out_;
7111 }
7112
7113 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7114
7115 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7116
7117 Ok(())
7118 }
7119 }
7120
7121 pub struct NamespaceCreate2Request<T0> {
7123 pub entries: T0,
7124 }
7125
7126 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
7127 for NamespaceCreate2Request<T0>
7128 where
7129 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7130 ___E: ::fidl_next::Encoder,
7131 ___E: ::fidl_next::fuchsia::HandleEncoder,
7132 T0: ::fidl_next::Encode<
7133 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
7134 ___E,
7135 >,
7136 {
7137 #[inline]
7138 fn encode(
7139 self,
7140 encoder_: &mut ___E,
7141 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
7142 _: (),
7143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7144 ::fidl_next::munge! {
7145 let crate::wire::NamespaceCreate2Request {
7146 entries,
7147
7148 } = out_;
7149 }
7150
7151 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7152
7153 Ok(())
7154 }
7155 }
7156
7157 pub struct NamespaceCreateResponse<T0> {
7159 pub entries: T0,
7160 }
7161
7162 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
7163 for NamespaceCreateResponse<T0>
7164 where
7165 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7166 ___E: ::fidl_next::Encoder,
7167 ___E: ::fidl_next::fuchsia::HandleEncoder,
7168 T0: ::fidl_next::Encode<
7169 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7170 ___E,
7171 >,
7172 {
7173 #[inline]
7174 fn encode(
7175 self,
7176 encoder_: &mut ___E,
7177 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
7178 _: (),
7179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7180 ::fidl_next::munge! {
7181 let crate::wire::NamespaceCreateResponse {
7182 entries,
7183
7184 } = out_;
7185 }
7186
7187 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7188
7189 Ok(())
7190 }
7191 }
7192
7193 pub struct NamespaceCreate2Response<T0> {
7195 pub entries: T0,
7196 }
7197
7198 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
7199 for NamespaceCreate2Response<T0>
7200 where
7201 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7202 ___E: ::fidl_next::Encoder,
7203 ___E: ::fidl_next::fuchsia::HandleEncoder,
7204 T0: ::fidl_next::Encode<
7205 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7206 ___E,
7207 >,
7208 {
7209 #[inline]
7210 fn encode(
7211 self,
7212 encoder_: &mut ___E,
7213 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
7214 _: (),
7215 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7216 ::fidl_next::munge! {
7217 let crate::wire::NamespaceCreate2Response {
7218 entries,
7219
7220 } = out_;
7221 }
7222
7223 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7224
7225 Ok(())
7226 }
7227 }
7228
7229 pub struct RealmListChildrenRequest<T0, T1> {
7231 pub collection: T0,
7232
7233 pub iter: T1,
7234 }
7235
7236 unsafe impl<___E, T0, T1>
7237 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
7238 for RealmListChildrenRequest<T0, T1>
7239 where
7240 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7241 ___E: ::fidl_next::Encoder,
7242 ___E: ::fidl_next::fuchsia::HandleEncoder,
7243 T0: ::fidl_next::Encode<
7244 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7245 ___E,
7246 >,
7247 T1: ::fidl_next::Encode<
7248 ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
7249 ___E,
7250 >,
7251 {
7252 #[inline]
7253 fn encode(
7254 self,
7255 encoder_: &mut ___E,
7256 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
7257 _: (),
7258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7259 ::fidl_next::munge! {
7260 let crate::wire::RealmListChildrenRequest {
7261 collection,
7262 iter,
7263
7264 } = out_;
7265 }
7266
7267 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7268
7269 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
7270
7271 Ok(())
7272 }
7273 }
7274
7275 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<T0> {
7277 pub child: T0,
7278 }
7279
7280 unsafe impl<___E, T0>
7281 ::fidl_next::Encode<
7282 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7283 ___E,
7284 > for RealmGetChildOutputDictionaryDeprecatedRequest<T0>
7285 where
7286 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7287 ___E: ::fidl_next::Encoder,
7288 ___E: ::fidl_next::fuchsia::HandleEncoder,
7289 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7290 {
7291 #[inline]
7292 fn encode(
7293 self,
7294 encoder_: &mut ___E,
7295 out_: &mut ::core::mem::MaybeUninit<
7296 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7297 >,
7298 _: (),
7299 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7300 ::fidl_next::munge! {
7301 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
7302 child,
7303
7304 } = out_;
7305 }
7306
7307 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7308
7309 Ok(())
7310 }
7311 }
7312
7313 pub struct RealmGetChildOutputDictionaryDeprecatedResponse<T0> {
7315 pub dictionary: T0,
7316 }
7317
7318 unsafe impl<___E, T0>
7319 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
7320 for RealmGetChildOutputDictionaryDeprecatedResponse<T0>
7321 where
7322 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7323 ___E: ::fidl_next::fuchsia::HandleEncoder,
7324 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
7325 {
7326 #[inline]
7327 fn encode(
7328 self,
7329 encoder_: &mut ___E,
7330 out_: &mut ::core::mem::MaybeUninit<
7331 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
7332 >,
7333 _: (),
7334 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7335 ::fidl_next::munge! {
7336 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
7337 dictionary,
7338
7339 } = out_;
7340 }
7341
7342 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7343
7344 Ok(())
7345 }
7346 }
7347
7348 pub struct RealmGetChildOutputDictionaryRequest<T0> {
7350 pub child: T0,
7351 }
7352
7353 unsafe impl<___E, T0>
7354 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
7355 for RealmGetChildOutputDictionaryRequest<T0>
7356 where
7357 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7358 ___E: ::fidl_next::Encoder,
7359 ___E: ::fidl_next::fuchsia::HandleEncoder,
7360 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7361 {
7362 #[inline]
7363 fn encode(
7364 self,
7365 encoder_: &mut ___E,
7366 out_: &mut ::core::mem::MaybeUninit<
7367 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
7368 >,
7369 _: (),
7370 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7371 ::fidl_next::munge! {
7372 let crate::wire::RealmGetChildOutputDictionaryRequest {
7373 child,
7374
7375 } = out_;
7376 }
7377
7378 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7379
7380 Ok(())
7381 }
7382 }
7383
7384 pub struct RealmGetChildOutputDictionaryResponse<T0> {
7386 pub dictionary: T0,
7387 }
7388
7389 unsafe impl<___E, T0>
7390 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
7391 for RealmGetChildOutputDictionaryResponse<T0>
7392 where
7393 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7394 ___E: ::fidl_next::fuchsia::HandleEncoder,
7395 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7396 {
7397 #[inline]
7398 fn encode(
7399 self,
7400 encoder_: &mut ___E,
7401 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
7402 _: (),
7403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7404 ::fidl_next::munge! {
7405 let crate::wire::RealmGetChildOutputDictionaryResponse {
7406 dictionary,
7407
7408 } = out_;
7409 }
7410
7411 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7412
7413 Ok(())
7414 }
7415 }
7416
7417 pub struct RealmOpenControllerRequest<T0, T1> {
7419 pub child: T0,
7420
7421 pub controller: T1,
7422 }
7423
7424 unsafe impl<___E, T0, T1>
7425 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
7426 for RealmOpenControllerRequest<T0, T1>
7427 where
7428 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7429 ___E: ::fidl_next::Encoder,
7430 ___E: ::fidl_next::fuchsia::HandleEncoder,
7431 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7432 T1: ::fidl_next::Encode<
7433 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
7434 ___E,
7435 >,
7436 {
7437 #[inline]
7438 fn encode(
7439 self,
7440 encoder_: &mut ___E,
7441 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
7442 _: (),
7443 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7444 ::fidl_next::munge! {
7445 let crate::wire::RealmOpenControllerRequest {
7446 child,
7447 controller,
7448
7449 } = out_;
7450 }
7451
7452 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7453
7454 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
7455
7456 Ok(())
7457 }
7458 }
7459
7460 pub struct RealmOpenExposedDirRequest<T0, T1> {
7462 pub child: T0,
7463
7464 pub exposed_dir: T1,
7465 }
7466
7467 unsafe impl<___E, T0, T1>
7468 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
7469 for RealmOpenExposedDirRequest<T0, T1>
7470 where
7471 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7472 ___E: ::fidl_next::Encoder,
7473 ___E: ::fidl_next::fuchsia::HandleEncoder,
7474 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7475 T1: ::fidl_next::Encode<
7476 ::fidl_next::ServerEnd<
7477 ::fidl_next_fuchsia_io::Directory,
7478 ::fidl_next::wire::fuchsia::Channel,
7479 >,
7480 ___E,
7481 >,
7482 {
7483 #[inline]
7484 fn encode(
7485 self,
7486 encoder_: &mut ___E,
7487 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
7488 _: (),
7489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7490 ::fidl_next::munge! {
7491 let crate::wire::RealmOpenExposedDirRequest {
7492 child,
7493 exposed_dir,
7494
7495 } = out_;
7496 }
7497
7498 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7499
7500 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
7501
7502 Ok(())
7503 }
7504 }
7505
7506 pub struct RealmCreateChildRequest<T0, T1, T2> {
7508 pub collection: T0,
7509
7510 pub decl: T1,
7511
7512 pub args: T2,
7513 }
7514
7515 unsafe impl<___E, T0, T1, T2>
7516 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
7517 for RealmCreateChildRequest<T0, T1, T2>
7518 where
7519 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7520 ___E: ::fidl_next::Encoder,
7521 ___E: ::fidl_next::fuchsia::HandleEncoder,
7522 T0: ::fidl_next::Encode<
7523 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7524 ___E,
7525 >,
7526 T1: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::Child<'static>, ___E>,
7527 T2: ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>,
7528 {
7529 #[inline]
7530 fn encode(
7531 self,
7532 encoder_: &mut ___E,
7533 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
7534 _: (),
7535 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7536 ::fidl_next::munge! {
7537 let crate::wire::RealmCreateChildRequest {
7538 collection,
7539 decl,
7540 args,
7541
7542 } = out_;
7543 }
7544
7545 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7546
7547 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
7548
7549 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
7550
7551 Ok(())
7552 }
7553 }
7554
7555 pub struct RealmGetResolvedInfoResponse<T0> {
7557 pub resolved_info: T0,
7558 }
7559
7560 unsafe impl<___E, T0>
7561 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
7562 for RealmGetResolvedInfoResponse<T0>
7563 where
7564 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7565 ___E: ::fidl_next::Encoder,
7566 ___E: ::fidl_next::fuchsia::HandleEncoder,
7567 T0: ::fidl_next::Encode<
7568 ::fidl_next_fuchsia_component_resolution::wire::Component<'static>,
7569 ___E,
7570 >,
7571 {
7572 #[inline]
7573 fn encode(
7574 self,
7575 encoder_: &mut ___E,
7576 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
7577 _: (),
7578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7579 ::fidl_next::munge! {
7580 let crate::wire::RealmGetResolvedInfoResponse {
7581 resolved_info,
7582
7583 } = out_;
7584 }
7585
7586 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
7587
7588 Ok(())
7589 }
7590 }
7591
7592 pub struct StorageAdminListStorageInRealmRequest<T0, T1> {
7594 pub relative_moniker: T0,
7595
7596 pub iterator: T1,
7597 }
7598
7599 unsafe impl<___E, T0, T1>
7600 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
7601 for StorageAdminListStorageInRealmRequest<T0, T1>
7602 where
7603 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7604 ___E: ::fidl_next::Encoder,
7605 ___E: ::fidl_next::fuchsia::HandleEncoder,
7606 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7607 T1: ::fidl_next::Encode<
7608 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
7609 ___E,
7610 >,
7611 {
7612 #[inline]
7613 fn encode(
7614 self,
7615 encoder_: &mut ___E,
7616 out_: &mut ::core::mem::MaybeUninit<
7617 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
7618 >,
7619 _: (),
7620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7621 ::fidl_next::munge! {
7622 let crate::wire::StorageAdminListStorageInRealmRequest {
7623 relative_moniker,
7624 iterator,
7625
7626 } = out_;
7627 }
7628
7629 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7630
7631 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7632
7633 Ok(())
7634 }
7635 }
7636
7637 pub struct StorageAdminOpenStorageRequest<T0, T1> {
7639 pub relative_moniker: T0,
7640
7641 pub object: T1,
7642 }
7643
7644 unsafe impl<___E, T0, T1>
7645 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
7646 for StorageAdminOpenStorageRequest<T0, T1>
7647 where
7648 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7649 ___E: ::fidl_next::Encoder,
7650 ___E: ::fidl_next::fuchsia::HandleEncoder,
7651 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7652 T1: ::fidl_next::Encode<
7653 ::fidl_next::ServerEnd<
7654 ::fidl_next_fuchsia_io::Node,
7655 ::fidl_next::wire::fuchsia::Channel,
7656 >,
7657 ___E,
7658 >,
7659 {
7660 #[inline]
7661 fn encode(
7662 self,
7663 encoder_: &mut ___E,
7664 out_: &mut ::core::mem::MaybeUninit<
7665 crate::wire::StorageAdminOpenStorageRequest<'static>,
7666 >,
7667 _: (),
7668 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7669 ::fidl_next::munge! {
7670 let crate::wire::StorageAdminOpenStorageRequest {
7671 relative_moniker,
7672 object,
7673
7674 } = out_;
7675 }
7676
7677 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7678
7679 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7680
7681 Ok(())
7682 }
7683 }
7684
7685 pub struct StorageAdminOpenComponentStorageByIdRequest<T0, T1> {
7687 pub id: T0,
7688
7689 pub object: T1,
7690 }
7691
7692 unsafe impl<___E, T0, T1>
7693 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
7694 for StorageAdminOpenComponentStorageByIdRequest<T0, T1>
7695 where
7696 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7697 ___E: ::fidl_next::Encoder,
7698 ___E: ::fidl_next::fuchsia::HandleEncoder,
7699 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7700 T1: ::fidl_next::Encode<
7701 ::fidl_next::ServerEnd<
7702 ::fidl_next_fuchsia_io::Node,
7703 ::fidl_next::wire::fuchsia::Channel,
7704 >,
7705 ___E,
7706 >,
7707 {
7708 #[inline]
7709 fn encode(
7710 self,
7711 encoder_: &mut ___E,
7712 out_: &mut ::core::mem::MaybeUninit<
7713 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
7714 >,
7715 _: (),
7716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7717 ::fidl_next::munge! {
7718 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
7719 id,
7720 object,
7721
7722 } = out_;
7723 }
7724
7725 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
7726
7727 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7728
7729 Ok(())
7730 }
7731 }
7732}
7733
7734pub use self::natural::*;
7735
7736#[doc = " A protocol used to operate on a component.\n\n One may get access to a `Controller` when creating a component with the\n `Realm.CreateChild` method. You may also obtain a `Controller` for an\n existing child component with the `Realm.OpenController` method.\n"]
7738#[derive(PartialEq, Debug)]
7739pub struct Controller;
7740
7741#[cfg(target_os = "fuchsia")]
7742impl ::fidl_next::HasTransport for Controller {
7743 type Transport = ::fidl_next::fuchsia::zx::Channel;
7744}
7745
7746pub mod controller {
7747 pub mod prelude {
7748 pub use crate::{
7749 Controller, ControllerClientHandler, ControllerLocalClientHandler,
7750 ControllerLocalServerHandler, ControllerServerHandler, controller,
7751 };
7752
7753 pub use crate::natural::ControllerOpenExposedDirRequest;
7754
7755 pub use crate::natural::ControllerStartRequest;
7756
7757 pub use crate::natural::ControllerDestroyResponse;
7758
7759 pub use crate::natural::ControllerGetExposedDictionaryResponse;
7760
7761 pub use crate::natural::ControllerGetOutputDictionaryResponse;
7762
7763 pub use crate::natural::ControllerIsStartedResponse;
7764
7765 pub use crate::natural::ControllerOpenExposedDirResponse;
7766
7767 pub use crate::natural::ControllerStartResponse;
7768
7769 pub use crate::natural::Error;
7770 }
7771
7772 pub struct Start;
7773
7774 impl ::fidl_next::Method for Start {
7775 const ORDINAL: u64 = 7532130149195770565;
7776 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7777 ::fidl_next::protocol::Flexibility::Flexible;
7778
7779 type Protocol = crate::Controller;
7780
7781 type Request = crate::wire::ControllerStartRequest<'static>;
7782 }
7783
7784 impl ::fidl_next::TwoWayMethod for Start {
7785 type Response = ::fidl_next::wire::Result<
7786 'static,
7787 crate::wire::ControllerStartResponse,
7788 crate::wire::Error,
7789 >;
7790 }
7791
7792 impl<___R> ::fidl_next::Respond<___R> for Start {
7793 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7794
7795 fn respond(response: ___R) -> Self::Output {
7796 ::core::result::Result::Ok(response)
7797 }
7798 }
7799
7800 impl<___R> ::fidl_next::RespondErr<___R> for Start {
7801 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7802
7803 fn respond_err(response: ___R) -> Self::Output {
7804 ::core::result::Result::Err(response)
7805 }
7806 }
7807
7808 pub struct IsStarted;
7809
7810 impl ::fidl_next::Method for IsStarted {
7811 const ORDINAL: u64 = 2402079833990398915;
7812 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7813 ::fidl_next::protocol::Flexibility::Flexible;
7814
7815 type Protocol = crate::Controller;
7816
7817 type Request = ::fidl_next::wire::EmptyMessageBody;
7818 }
7819
7820 impl ::fidl_next::TwoWayMethod for IsStarted {
7821 type Response = ::fidl_next::wire::Result<
7822 'static,
7823 crate::wire::ControllerIsStartedResponse,
7824 crate::wire::Error,
7825 >;
7826 }
7827
7828 impl<___R> ::fidl_next::Respond<___R> for IsStarted {
7829 type Output = ::core::result::Result<
7830 crate::generic::ControllerIsStartedResponse<___R>,
7831 ::fidl_next::util::Never,
7832 >;
7833
7834 fn respond(response: ___R) -> Self::Output {
7835 ::core::result::Result::Ok(crate::generic::ControllerIsStartedResponse {
7836 is_started: response,
7837 })
7838 }
7839 }
7840
7841 impl<___R> ::fidl_next::RespondErr<___R> for IsStarted {
7842 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7843
7844 fn respond_err(response: ___R) -> Self::Output {
7845 ::core::result::Result::Err(response)
7846 }
7847 }
7848
7849 pub struct OpenExposedDir;
7850
7851 impl ::fidl_next::Method for OpenExposedDir {
7852 const ORDINAL: u64 = 2683208291886099860;
7853 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7854 ::fidl_next::protocol::Flexibility::Strict;
7855
7856 type Protocol = crate::Controller;
7857
7858 type Request = crate::wire::ControllerOpenExposedDirRequest;
7859 }
7860
7861 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
7862 type Response = ::fidl_next::wire::Result<
7863 'static,
7864 crate::wire::ControllerOpenExposedDirResponse,
7865 crate::wire::Error,
7866 >;
7867 }
7868
7869 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
7870 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7871
7872 fn respond(response: ___R) -> Self::Output {
7873 ::core::result::Result::Ok(response)
7874 }
7875 }
7876
7877 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
7878 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7879
7880 fn respond_err(response: ___R) -> Self::Output {
7881 ::core::result::Result::Err(response)
7882 }
7883 }
7884
7885 pub struct GetExposedDictionary;
7886
7887 impl ::fidl_next::Method for GetExposedDictionary {
7888 const ORDINAL: u64 = 9099583788120940443;
7889 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7890 ::fidl_next::protocol::Flexibility::Flexible;
7891
7892 type Protocol = crate::Controller;
7893
7894 type Request = ::fidl_next::wire::EmptyMessageBody;
7895 }
7896
7897 impl ::fidl_next::TwoWayMethod for GetExposedDictionary {
7898 type Response = ::fidl_next::wire::Result<
7899 'static,
7900 crate::wire::ControllerGetExposedDictionaryResponse,
7901 crate::wire::Error,
7902 >;
7903 }
7904
7905 impl<___R> ::fidl_next::Respond<___R> for GetExposedDictionary {
7906 type Output = ::core::result::Result<
7907 crate::generic::ControllerGetExposedDictionaryResponse<___R>,
7908 ::fidl_next::util::Never,
7909 >;
7910
7911 fn respond(response: ___R) -> Self::Output {
7912 ::core::result::Result::Ok(crate::generic::ControllerGetExposedDictionaryResponse {
7913 dictionary: response,
7914 })
7915 }
7916 }
7917
7918 impl<___R> ::fidl_next::RespondErr<___R> for GetExposedDictionary {
7919 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7920
7921 fn respond_err(response: ___R) -> Self::Output {
7922 ::core::result::Result::Err(response)
7923 }
7924 }
7925
7926 pub struct GetOutputDictionary;
7927
7928 impl ::fidl_next::Method for GetOutputDictionary {
7929 const ORDINAL: u64 = 4182795765624263201;
7930 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7931 ::fidl_next::protocol::Flexibility::Flexible;
7932
7933 type Protocol = crate::Controller;
7934
7935 type Request = ::fidl_next::wire::EmptyMessageBody;
7936 }
7937
7938 impl ::fidl_next::TwoWayMethod for GetOutputDictionary {
7939 type Response = ::fidl_next::wire::Result<
7940 'static,
7941 crate::wire::ControllerGetOutputDictionaryResponse,
7942 crate::wire::Error,
7943 >;
7944 }
7945
7946 impl<___R> ::fidl_next::Respond<___R> for GetOutputDictionary {
7947 type Output = ::core::result::Result<
7948 crate::generic::ControllerGetOutputDictionaryResponse<___R>,
7949 ::fidl_next::util::Never,
7950 >;
7951
7952 fn respond(response: ___R) -> Self::Output {
7953 ::core::result::Result::Ok(crate::generic::ControllerGetOutputDictionaryResponse {
7954 dictionary: response,
7955 })
7956 }
7957 }
7958
7959 impl<___R> ::fidl_next::RespondErr<___R> for GetOutputDictionary {
7960 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7961
7962 fn respond_err(response: ___R) -> Self::Output {
7963 ::core::result::Result::Err(response)
7964 }
7965 }
7966
7967 pub struct Destroy;
7968
7969 impl ::fidl_next::Method for Destroy {
7970 const ORDINAL: u64 = 8381937394141370177;
7971 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7972 ::fidl_next::protocol::Flexibility::Flexible;
7973
7974 type Protocol = crate::Controller;
7975
7976 type Request = ::fidl_next::wire::EmptyMessageBody;
7977 }
7978
7979 impl ::fidl_next::TwoWayMethod for Destroy {
7980 type Response = ::fidl_next::wire::Result<
7981 'static,
7982 crate::wire::ControllerDestroyResponse,
7983 crate::wire::Error,
7984 >;
7985 }
7986
7987 impl<___R> ::fidl_next::Respond<___R> for Destroy {
7988 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7989
7990 fn respond(response: ___R) -> Self::Output {
7991 ::core::result::Result::Ok(response)
7992 }
7993 }
7994
7995 impl<___R> ::fidl_next::RespondErr<___R> for Destroy {
7996 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7997
7998 fn respond_err(response: ___R) -> Self::Output {
7999 ::core::result::Result::Err(response)
8000 }
8001 }
8002
8003 mod ___detail {
8004 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Controller
8005 where
8006 ___T: ::fidl_next::Transport,
8007 {
8008 type Client = ControllerClient<___T>;
8009 type Server = ControllerServer<___T>;
8010 }
8011
8012 #[repr(transparent)]
8014 pub struct ControllerClient<___T: ::fidl_next::Transport> {
8015 #[allow(dead_code)]
8016 client: ::fidl_next::protocol::Client<___T>,
8017 }
8018
8019 impl<___T> ControllerClient<___T>
8020 where
8021 ___T: ::fidl_next::Transport,
8022 {
8023 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
8024 pub fn start(
8025 &self,
8026
8027 args: impl ::fidl_next::Encode<
8028 crate::wire::StartChildArgs<'static>,
8029 <___T as ::fidl_next::Transport>::SendBuffer,
8030 >,
8031
8032 execution_controller: impl ::fidl_next::Encode<
8033 ::fidl_next::ServerEnd<
8034 crate::ExecutionController,
8035 ::fidl_next::wire::fuchsia::Channel,
8036 >,
8037 <___T as ::fidl_next::Transport>::SendBuffer,
8038 >,
8039 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8040 where
8041 <___T as ::fidl_next::Transport>::SendBuffer:
8042 ::fidl_next::encoder::InternalHandleEncoder,
8043 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8044 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8045 {
8046 self.start_with(crate::generic::ControllerStartRequest {
8047 args,
8048
8049 execution_controller,
8050 })
8051 }
8052
8053 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
8054 pub fn start_with<___R>(
8055 &self,
8056 request: ___R,
8057 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8058 where
8059 ___R: ::fidl_next::Encode<
8060 crate::wire::ControllerStartRequest<'static>,
8061 <___T as ::fidl_next::Transport>::SendBuffer,
8062 >,
8063 {
8064 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8065 7532130149195770565,
8066 <super::Start as ::fidl_next::Method>::FLEXIBILITY,
8067 request,
8068 ))
8069 }
8070
8071 #[doc = " Returns true if this instance is currently running.\n"]
8072 pub fn is_started(&self) -> ::fidl_next::TwoWayFuture<'_, super::IsStarted, ___T> {
8073 ::fidl_next::TwoWayFuture::from_untyped(
8074 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8075 2402079833990398915,
8076 <super::IsStarted as ::fidl_next::Method>::FLEXIBILITY,
8077 (),
8078 ),
8079 )
8080 }
8081
8082 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
8083 pub fn open_exposed_dir(
8084 &self,
8085
8086 exposed_dir: impl ::fidl_next::Encode<
8087 ::fidl_next::ServerEnd<
8088 ::fidl_next_fuchsia_io::Directory,
8089 ::fidl_next::wire::fuchsia::Channel,
8090 >,
8091 <___T as ::fidl_next::Transport>::SendBuffer,
8092 >,
8093 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8094 where
8095 <___T as ::fidl_next::Transport>::SendBuffer:
8096 ::fidl_next::encoder::InternalHandleEncoder,
8097 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8098 {
8099 self.open_exposed_dir_with(crate::generic::ControllerOpenExposedDirRequest {
8100 exposed_dir,
8101 })
8102 }
8103
8104 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
8105 pub fn open_exposed_dir_with<___R>(
8106 &self,
8107 request: ___R,
8108 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8109 where
8110 ___R: ::fidl_next::Encode<
8111 crate::wire::ControllerOpenExposedDirRequest,
8112 <___T as ::fidl_next::Transport>::SendBuffer,
8113 >,
8114 {
8115 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8116 2683208291886099860,
8117 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
8118 request,
8119 ))
8120 }
8121
8122 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8123 pub fn get_exposed_dictionary(
8124 &self,
8125 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExposedDictionary, ___T> {
8126 ::fidl_next::TwoWayFuture::from_untyped(
8127 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8128 9099583788120940443,
8129 <super::GetExposedDictionary as ::fidl_next::Method>::FLEXIBILITY,
8130 (),
8131 ),
8132 )
8133 }
8134
8135 #[doc = " Returns a reference to the component\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
8136 pub fn get_output_dictionary(
8137 &self,
8138 ) -> ::fidl_next::TwoWayFuture<'_, super::GetOutputDictionary, ___T> {
8139 ::fidl_next::TwoWayFuture::from_untyped(
8140 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8141 4182795765624263201,
8142 <super::GetOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
8143 (),
8144 ),
8145 )
8146 }
8147
8148 #[doc = " Destroys this component. When this method returns, the component is\n either destroyed or in the case of an error no destruction happened.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n - `INTERNAL`: Something prevented destruction from succeeding -- component\n manager\'s logs will contain more detail.\n"]
8149 pub fn destroy(&self) -> ::fidl_next::TwoWayFuture<'_, super::Destroy, ___T> {
8150 ::fidl_next::TwoWayFuture::from_untyped(
8151 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8152 8381937394141370177,
8153 <super::Destroy as ::fidl_next::Method>::FLEXIBILITY,
8154 (),
8155 ),
8156 )
8157 }
8158 }
8159
8160 #[repr(transparent)]
8162 pub struct ControllerServer<___T: ::fidl_next::Transport> {
8163 server: ::fidl_next::protocol::Server<___T>,
8164 }
8165
8166 impl<___T> ControllerServer<___T> where ___T: ::fidl_next::Transport {}
8167 }
8168}
8169
8170#[diagnostic::on_unimplemented(
8171 note = "If {Self} implements the non-local ControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
8172)]
8173
8174pub trait ControllerLocalClientHandler<
8178 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8179 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8180>
8181{
8182 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8183 ::core::future::ready(())
8184 }
8185}
8186
8187impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Controller
8188where
8189 ___H: ControllerLocalClientHandler<___T>,
8190 ___T: ::fidl_next::Transport,
8191{
8192 async fn on_event(
8193 handler: &mut ___H,
8194 mut message: ::fidl_next::Message<___T>,
8195 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8196 match *message.header().ordinal {
8197 ordinal => {
8198 handler.on_unknown_interaction(ordinal).await;
8199 if ::core::matches!(
8200 message.header().flexibility(),
8201 ::fidl_next::protocol::Flexibility::Strict
8202 ) {
8203 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8204 } else {
8205 Ok(())
8206 }
8207 }
8208 }
8209 }
8210}
8211
8212#[diagnostic::on_unimplemented(
8213 note = "If {Self} implements the non-local ControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
8214)]
8215
8216pub trait ControllerLocalServerHandler<
8220 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8221 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8222>
8223{
8224 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
8225 fn start(
8226 &mut self,
8227
8228 request: ::fidl_next::Request<controller::Start, ___T>,
8229
8230 responder: ::fidl_next::Responder<controller::Start, ___T>,
8231 ) -> impl ::core::future::Future<Output = ()>;
8232
8233 #[doc = " Returns true if this instance is currently running.\n"]
8234 fn is_started(
8235 &mut self,
8236
8237 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8238 ) -> impl ::core::future::Future<Output = ()>;
8239
8240 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
8241 fn open_exposed_dir(
8242 &mut self,
8243
8244 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8245
8246 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8247 ) -> impl ::core::future::Future<Output = ()>;
8248
8249 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8250 fn get_exposed_dictionary(
8251 &mut self,
8252
8253 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8254 ) -> impl ::core::future::Future<Output = ()>;
8255
8256 #[doc = " Returns a reference to the component\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
8257 fn get_output_dictionary(
8258 &mut self,
8259
8260 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8261 ) -> impl ::core::future::Future<Output = ()>;
8262
8263 #[doc = " Destroys this component. When this method returns, the component is\n either destroyed or in the case of an error no destruction happened.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n - `INTERNAL`: Something prevented destruction from succeeding -- component\n manager\'s logs will contain more detail.\n"]
8264 fn destroy(
8265 &mut self,
8266
8267 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8268 ) -> impl ::core::future::Future<Output = ()>;
8269
8270 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8271 ::core::future::ready(())
8272 }
8273}
8274
8275impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Controller
8276where
8277 ___H: ControllerLocalServerHandler<___T>,
8278 ___T: ::fidl_next::Transport,
8279 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8280 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8281 Constraint = (),
8282 >,
8283 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8284 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8285 Constraint = (),
8286 >,
8287{
8288 async fn on_one_way(
8289 handler: &mut ___H,
8290 mut message: ::fidl_next::Message<___T>,
8291 ) -> ::core::result::Result<
8292 (),
8293 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8294 > {
8295 match *message.header().ordinal {
8296 ordinal => {
8297 handler.on_unknown_interaction(ordinal).await;
8298 if ::core::matches!(
8299 message.header().flexibility(),
8300 ::fidl_next::protocol::Flexibility::Strict
8301 ) {
8302 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8303 } else {
8304 Ok(())
8305 }
8306 }
8307 }
8308 }
8309
8310 async fn on_two_way(
8311 handler: &mut ___H,
8312 mut message: ::fidl_next::Message<___T>,
8313 responder: ::fidl_next::protocol::Responder<___T>,
8314 ) -> ::core::result::Result<
8315 (),
8316 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8317 > {
8318 match *message.header().ordinal {
8319 7532130149195770565 => {
8320 let responder = ::fidl_next::Responder::from_untyped(responder);
8321
8322 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8323 Ok(decoded) => {
8324 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8325 Ok(())
8326 }
8327 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8328 ordinal: 7532130149195770565,
8329 error,
8330 }),
8331 }
8332 }
8333
8334 2402079833990398915 => {
8335 let responder = ::fidl_next::Responder::from_untyped(responder);
8336
8337 handler.is_started(responder).await;
8338 Ok(())
8339 }
8340
8341 2683208291886099860 => {
8342 let responder = ::fidl_next::Responder::from_untyped(responder);
8343
8344 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8345 Ok(decoded) => {
8346 handler
8347 .open_exposed_dir(
8348 ::fidl_next::Request::from_decoded(decoded),
8349 responder,
8350 )
8351 .await;
8352 Ok(())
8353 }
8354 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8355 ordinal: 2683208291886099860,
8356 error,
8357 }),
8358 }
8359 }
8360
8361 9099583788120940443 => {
8362 let responder = ::fidl_next::Responder::from_untyped(responder);
8363
8364 handler.get_exposed_dictionary(responder).await;
8365 Ok(())
8366 }
8367
8368 4182795765624263201 => {
8369 let responder = ::fidl_next::Responder::from_untyped(responder);
8370
8371 handler.get_output_dictionary(responder).await;
8372 Ok(())
8373 }
8374
8375 8381937394141370177 => {
8376 let responder = ::fidl_next::Responder::from_untyped(responder);
8377
8378 handler.destroy(responder).await;
8379 Ok(())
8380 }
8381
8382 ordinal => {
8383 handler.on_unknown_interaction(ordinal).await;
8384 if ::core::matches!(
8385 message.header().flexibility(),
8386 ::fidl_next::protocol::Flexibility::Strict
8387 ) {
8388 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8389 } else {
8390 responder
8391 .respond_framework_error(
8392 ordinal,
8393 ::fidl_next::FrameworkError::UnknownMethod,
8394 )
8395 .expect("encoding a framework error should never fail")
8396 .await?;
8397 Ok(())
8398 }
8399 }
8400 }
8401 }
8402}
8403
8404pub trait ControllerClientHandler<
8408 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8409 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8410>
8411{
8412 fn on_unknown_interaction(
8413 &mut self,
8414 ordinal: u64,
8415 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8416 ::core::future::ready(())
8417 }
8418}
8419
8420impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Controller
8421where
8422 ___H: ControllerClientHandler<___T> + ::core::marker::Send,
8423 ___T: ::fidl_next::Transport,
8424{
8425 async fn on_event(
8426 handler: &mut ___H,
8427 mut message: ::fidl_next::Message<___T>,
8428 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8429 match *message.header().ordinal {
8430 ordinal => {
8431 handler.on_unknown_interaction(ordinal).await;
8432 if ::core::matches!(
8433 message.header().flexibility(),
8434 ::fidl_next::protocol::Flexibility::Strict
8435 ) {
8436 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8437 } else {
8438 Ok(())
8439 }
8440 }
8441 }
8442 }
8443}
8444
8445pub trait ControllerServerHandler<
8449 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8450 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8451>
8452{
8453 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
8454 fn start(
8455 &mut self,
8456
8457 request: ::fidl_next::Request<controller::Start, ___T>,
8458
8459 responder: ::fidl_next::Responder<controller::Start, ___T>,
8460 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8461
8462 #[doc = " Returns true if this instance is currently running.\n"]
8463 fn is_started(
8464 &mut self,
8465
8466 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8467 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8468
8469 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
8470 fn open_exposed_dir(
8471 &mut self,
8472
8473 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8474
8475 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8476 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8477
8478 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8479 fn get_exposed_dictionary(
8480 &mut self,
8481
8482 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8483 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8484
8485 #[doc = " Returns a reference to the component\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
8486 fn get_output_dictionary(
8487 &mut self,
8488
8489 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8490 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8491
8492 #[doc = " Destroys this component. When this method returns, the component is\n either destroyed or in the case of an error no destruction happened.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n - `INTERNAL`: Something prevented destruction from succeeding -- component\n manager\'s logs will contain more detail.\n"]
8493 fn destroy(
8494 &mut self,
8495
8496 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8497 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8498
8499 fn on_unknown_interaction(
8500 &mut self,
8501 ordinal: u64,
8502 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8503 ::core::future::ready(())
8504 }
8505}
8506
8507impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Controller
8508where
8509 ___H: ControllerServerHandler<___T> + ::core::marker::Send,
8510 ___T: ::fidl_next::Transport,
8511 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8512 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8513 Constraint = (),
8514 >,
8515 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8516 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8517 Constraint = (),
8518 >,
8519{
8520 async fn on_one_way(
8521 handler: &mut ___H,
8522 mut message: ::fidl_next::Message<___T>,
8523 ) -> ::core::result::Result<
8524 (),
8525 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8526 > {
8527 match *message.header().ordinal {
8528 ordinal => {
8529 handler.on_unknown_interaction(ordinal).await;
8530 if ::core::matches!(
8531 message.header().flexibility(),
8532 ::fidl_next::protocol::Flexibility::Strict
8533 ) {
8534 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8535 } else {
8536 Ok(())
8537 }
8538 }
8539 }
8540 }
8541
8542 async fn on_two_way(
8543 handler: &mut ___H,
8544 mut message: ::fidl_next::Message<___T>,
8545 responder: ::fidl_next::protocol::Responder<___T>,
8546 ) -> ::core::result::Result<
8547 (),
8548 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8549 > {
8550 match *message.header().ordinal {
8551 7532130149195770565 => {
8552 let responder = ::fidl_next::Responder::from_untyped(responder);
8553
8554 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8555 Ok(decoded) => {
8556 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8557 Ok(())
8558 }
8559 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8560 ordinal: 7532130149195770565,
8561 error,
8562 }),
8563 }
8564 }
8565
8566 2402079833990398915 => {
8567 let responder = ::fidl_next::Responder::from_untyped(responder);
8568
8569 handler.is_started(responder).await;
8570 Ok(())
8571 }
8572
8573 2683208291886099860 => {
8574 let responder = ::fidl_next::Responder::from_untyped(responder);
8575
8576 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8577 Ok(decoded) => {
8578 handler
8579 .open_exposed_dir(
8580 ::fidl_next::Request::from_decoded(decoded),
8581 responder,
8582 )
8583 .await;
8584 Ok(())
8585 }
8586 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8587 ordinal: 2683208291886099860,
8588 error,
8589 }),
8590 }
8591 }
8592
8593 9099583788120940443 => {
8594 let responder = ::fidl_next::Responder::from_untyped(responder);
8595
8596 handler.get_exposed_dictionary(responder).await;
8597 Ok(())
8598 }
8599
8600 4182795765624263201 => {
8601 let responder = ::fidl_next::Responder::from_untyped(responder);
8602
8603 handler.get_output_dictionary(responder).await;
8604 Ok(())
8605 }
8606
8607 8381937394141370177 => {
8608 let responder = ::fidl_next::Responder::from_untyped(responder);
8609
8610 handler.destroy(responder).await;
8611 Ok(())
8612 }
8613
8614 ordinal => {
8615 handler.on_unknown_interaction(ordinal).await;
8616 if ::core::matches!(
8617 message.header().flexibility(),
8618 ::fidl_next::protocol::Flexibility::Strict
8619 ) {
8620 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8621 } else {
8622 responder
8623 .respond_framework_error(
8624 ordinal,
8625 ::fidl_next::FrameworkError::UnknownMethod,
8626 )
8627 .expect("encoding a framework error should never fail")
8628 .await?;
8629 Ok(())
8630 }
8631 }
8632 }
8633 }
8634}
8635
8636impl<___T> ControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
8637where
8638 ___T: ::fidl_next::Transport,
8639{
8640 async fn on_unknown_interaction(&mut self, _: u64) {}
8641}
8642
8643impl<___H, ___T> ControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
8644where
8645 ___H: ControllerClientHandler<___T>,
8646 ___T: ::fidl_next::Transport,
8647{
8648 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8649 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8650 }
8651}
8652
8653impl<___H, ___T> ControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
8654where
8655 ___H: ControllerServerHandler<___T>,
8656 ___T: ::fidl_next::Transport,
8657{
8658 async fn start(
8659 &mut self,
8660
8661 request: ::fidl_next::Request<controller::Start, ___T>,
8662
8663 responder: ::fidl_next::Responder<controller::Start, ___T>,
8664 ) {
8665 ___H::start(&mut self.0, request, responder).await
8666 }
8667
8668 async fn is_started(&mut self, responder: ::fidl_next::Responder<controller::IsStarted, ___T>) {
8669 ___H::is_started(&mut self.0, responder).await
8670 }
8671
8672 async fn open_exposed_dir(
8673 &mut self,
8674
8675 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8676
8677 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8678 ) {
8679 ___H::open_exposed_dir(&mut self.0, request, responder).await
8680 }
8681
8682 async fn get_exposed_dictionary(
8683 &mut self,
8684
8685 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8686 ) {
8687 ___H::get_exposed_dictionary(&mut self.0, responder).await
8688 }
8689
8690 async fn get_output_dictionary(
8691 &mut self,
8692
8693 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8694 ) {
8695 ___H::get_output_dictionary(&mut self.0, responder).await
8696 }
8697
8698 async fn destroy(&mut self, responder: ::fidl_next::Responder<controller::Destroy, ___T>) {
8699 ___H::destroy(&mut self.0, responder).await
8700 }
8701
8702 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8703 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8704 }
8705}
8706
8707#[doc = " Listener for events on the component hierarchy.\n Can\'t be used outside of the platform.\n"]
8709#[derive(PartialEq, Debug)]
8710pub struct EventStream;
8711
8712impl ::fidl_next::Discoverable for EventStream {
8713 const PROTOCOL_NAME: &'static str = "fuchsia.component.EventStream";
8714}
8715
8716#[cfg(target_os = "fuchsia")]
8717impl ::fidl_next::HasTransport for EventStream {
8718 type Transport = ::fidl_next::fuchsia::zx::Channel;
8719}
8720
8721pub mod event_stream {
8722 pub mod prelude {
8723 pub use crate::{
8724 EventStream, EventStreamClientHandler, EventStreamLocalClientHandler,
8725 EventStreamLocalServerHandler, EventStreamServerHandler, event_stream,
8726 };
8727
8728 pub use crate::natural::EventStreamGetNextResponse;
8729 }
8730
8731 pub struct GetNext;
8732
8733 impl ::fidl_next::Method for GetNext {
8734 const ORDINAL: u64 = 4549982840421936006;
8735 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8736 ::fidl_next::protocol::Flexibility::Strict;
8737
8738 type Protocol = crate::EventStream;
8739
8740 type Request = ::fidl_next::wire::EmptyMessageBody;
8741 }
8742
8743 impl ::fidl_next::TwoWayMethod for GetNext {
8744 type Response = crate::wire::EventStreamGetNextResponse<'static>;
8745 }
8746
8747 impl<___R> ::fidl_next::Respond<___R> for GetNext {
8748 type Output = crate::generic::EventStreamGetNextResponse<___R>;
8749
8750 fn respond(response: ___R) -> Self::Output {
8751 crate::generic::EventStreamGetNextResponse { events: response }
8752 }
8753 }
8754
8755 pub struct WaitForReady;
8756
8757 impl ::fidl_next::Method for WaitForReady {
8758 const ORDINAL: u64 = 3545212058508387970;
8759 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8760 ::fidl_next::protocol::Flexibility::Strict;
8761
8762 type Protocol = crate::EventStream;
8763
8764 type Request = ::fidl_next::wire::EmptyMessageBody;
8765 }
8766
8767 impl ::fidl_next::TwoWayMethod for WaitForReady {
8768 type Response = ::fidl_next::wire::EmptyMessageBody;
8769 }
8770
8771 impl<___R> ::fidl_next::Respond<___R> for WaitForReady {
8772 type Output = ___R;
8773
8774 fn respond(response: ___R) -> Self::Output {
8775 response
8776 }
8777 }
8778
8779 mod ___detail {
8780 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::EventStream
8781 where
8782 ___T: ::fidl_next::Transport,
8783 {
8784 type Client = EventStreamClient<___T>;
8785 type Server = EventStreamServer<___T>;
8786 }
8787
8788 #[repr(transparent)]
8790 pub struct EventStreamClient<___T: ::fidl_next::Transport> {
8791 #[allow(dead_code)]
8792 client: ::fidl_next::protocol::Client<___T>,
8793 }
8794
8795 impl<___T> EventStreamClient<___T>
8796 where
8797 ___T: ::fidl_next::Transport,
8798 {
8799 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
8800 ::fidl_next::TwoWayFuture::from_untyped(
8801 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8802 4549982840421936006,
8803 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
8804 (),
8805 ),
8806 )
8807 }
8808
8809 #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
8810 pub fn wait_for_ready(
8811 &self,
8812 ) -> ::fidl_next::TwoWayFuture<'_, super::WaitForReady, ___T> {
8813 ::fidl_next::TwoWayFuture::from_untyped(
8814 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8815 3545212058508387970,
8816 <super::WaitForReady as ::fidl_next::Method>::FLEXIBILITY,
8817 (),
8818 ),
8819 )
8820 }
8821 }
8822
8823 #[repr(transparent)]
8825 pub struct EventStreamServer<___T: ::fidl_next::Transport> {
8826 server: ::fidl_next::protocol::Server<___T>,
8827 }
8828
8829 impl<___T> EventStreamServer<___T> where ___T: ::fidl_next::Transport {}
8830 }
8831}
8832
8833#[diagnostic::on_unimplemented(
8834 note = "If {Self} implements the non-local EventStreamClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
8835)]
8836
8837pub trait EventStreamLocalClientHandler<
8841 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8842 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8843>
8844{
8845}
8846
8847impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for EventStream
8848where
8849 ___H: EventStreamLocalClientHandler<___T>,
8850 ___T: ::fidl_next::Transport,
8851{
8852 async fn on_event(
8853 handler: &mut ___H,
8854 mut message: ::fidl_next::Message<___T>,
8855 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8856 match *message.header().ordinal {
8857 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8858 }
8859 }
8860}
8861
8862#[diagnostic::on_unimplemented(
8863 note = "If {Self} implements the non-local EventStreamServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
8864)]
8865
8866pub trait EventStreamLocalServerHandler<
8870 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8871 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8872>
8873{
8874 fn get_next(
8875 &mut self,
8876
8877 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
8878 ) -> impl ::core::future::Future<Output = ()>;
8879
8880 #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
8881 fn wait_for_ready(
8882 &mut self,
8883
8884 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
8885 ) -> impl ::core::future::Future<Output = ()>;
8886}
8887
8888impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for EventStream
8889where
8890 ___H: EventStreamLocalServerHandler<___T>,
8891 ___T: ::fidl_next::Transport,
8892{
8893 async fn on_one_way(
8894 handler: &mut ___H,
8895 mut message: ::fidl_next::Message<___T>,
8896 ) -> ::core::result::Result<
8897 (),
8898 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8899 > {
8900 match *message.header().ordinal {
8901 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8902 }
8903 }
8904
8905 async fn on_two_way(
8906 handler: &mut ___H,
8907 mut message: ::fidl_next::Message<___T>,
8908 responder: ::fidl_next::protocol::Responder<___T>,
8909 ) -> ::core::result::Result<
8910 (),
8911 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8912 > {
8913 match *message.header().ordinal {
8914 4549982840421936006 => {
8915 let responder = ::fidl_next::Responder::from_untyped(responder);
8916
8917 handler.get_next(responder).await;
8918 Ok(())
8919 }
8920
8921 3545212058508387970 => {
8922 let responder = ::fidl_next::Responder::from_untyped(responder);
8923
8924 handler.wait_for_ready(responder).await;
8925 Ok(())
8926 }
8927
8928 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8929 }
8930 }
8931}
8932
8933pub trait EventStreamClientHandler<
8937 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8938 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8939>
8940{
8941}
8942
8943impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for EventStream
8944where
8945 ___H: EventStreamClientHandler<___T> + ::core::marker::Send,
8946 ___T: ::fidl_next::Transport,
8947{
8948 async fn on_event(
8949 handler: &mut ___H,
8950 mut message: ::fidl_next::Message<___T>,
8951 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8952 match *message.header().ordinal {
8953 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8954 }
8955 }
8956}
8957
8958pub trait EventStreamServerHandler<
8962 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8963 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8964>
8965{
8966 fn get_next(
8967 &mut self,
8968
8969 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
8970 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8971
8972 #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
8973 fn wait_for_ready(
8974 &mut self,
8975
8976 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
8977 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8978}
8979
8980impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for EventStream
8981where
8982 ___H: EventStreamServerHandler<___T> + ::core::marker::Send,
8983 ___T: ::fidl_next::Transport,
8984{
8985 async fn on_one_way(
8986 handler: &mut ___H,
8987 mut message: ::fidl_next::Message<___T>,
8988 ) -> ::core::result::Result<
8989 (),
8990 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8991 > {
8992 match *message.header().ordinal {
8993 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8994 }
8995 }
8996
8997 async fn on_two_way(
8998 handler: &mut ___H,
8999 mut message: ::fidl_next::Message<___T>,
9000 responder: ::fidl_next::protocol::Responder<___T>,
9001 ) -> ::core::result::Result<
9002 (),
9003 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9004 > {
9005 match *message.header().ordinal {
9006 4549982840421936006 => {
9007 let responder = ::fidl_next::Responder::from_untyped(responder);
9008
9009 handler.get_next(responder).await;
9010 Ok(())
9011 }
9012
9013 3545212058508387970 => {
9014 let responder = ::fidl_next::Responder::from_untyped(responder);
9015
9016 handler.wait_for_ready(responder).await;
9017 Ok(())
9018 }
9019
9020 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9021 }
9022 }
9023}
9024
9025impl<___T> EventStreamClientHandler<___T> for ::fidl_next::IgnoreEvents where
9026 ___T: ::fidl_next::Transport
9027{
9028}
9029
9030impl<___H, ___T> EventStreamLocalClientHandler<___T> for ::fidl_next::Local<___H>
9031where
9032 ___H: EventStreamClientHandler<___T>,
9033 ___T: ::fidl_next::Transport,
9034{
9035}
9036
9037impl<___H, ___T> EventStreamLocalServerHandler<___T> for ::fidl_next::Local<___H>
9038where
9039 ___H: EventStreamServerHandler<___T>,
9040 ___T: ::fidl_next::Transport,
9041{
9042 async fn get_next(&mut self, responder: ::fidl_next::Responder<event_stream::GetNext, ___T>) {
9043 ___H::get_next(&mut self.0, responder).await
9044 }
9045
9046 async fn wait_for_ready(
9047 &mut self,
9048
9049 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
9050 ) {
9051 ___H::wait_for_ready(&mut self.0, responder).await
9052 }
9053}
9054
9055#[doc = " A protocol used by a component instance to obtain information about\n components in its own realm.\n\n This protocol only supports getting the moniker at the moment but could\n expand to other privileged information such as the URL of a component.\n\n The component framework provides this capability to components that use\n `fuchsia.component.Introspector` from framework.\n"]
9057#[derive(PartialEq, Debug)]
9058pub struct Introspector;
9059
9060impl ::fidl_next::Discoverable for Introspector {
9061 const PROTOCOL_NAME: &'static str = "fuchsia.component.Introspector";
9062}
9063
9064#[cfg(target_os = "fuchsia")]
9065impl ::fidl_next::HasTransport for Introspector {
9066 type Transport = ::fidl_next::fuchsia::zx::Channel;
9067}
9068
9069pub mod introspector {
9070 pub mod prelude {
9071 pub use crate::{
9072 Introspector, IntrospectorClientHandler, IntrospectorLocalClientHandler,
9073 IntrospectorLocalServerHandler, IntrospectorServerHandler, introspector,
9074 };
9075
9076 pub use crate::natural::Error;
9077
9078 pub use crate::natural::IntrospectorGetMonikerRequest;
9079
9080 pub use crate::natural::IntrospectorGetMonikerResponse;
9081 }
9082
9083 pub struct GetMoniker;
9084
9085 impl ::fidl_next::Method for GetMoniker {
9086 const ORDINAL: u64 = 214344082539672664;
9087 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9088 ::fidl_next::protocol::Flexibility::Flexible;
9089
9090 type Protocol = crate::Introspector;
9091
9092 type Request = crate::wire::IntrospectorGetMonikerRequest;
9093 }
9094
9095 impl ::fidl_next::TwoWayMethod for GetMoniker {
9096 type Response = ::fidl_next::wire::Result<
9097 'static,
9098 crate::wire::IntrospectorGetMonikerResponse<'static>,
9099 crate::wire::Error,
9100 >;
9101 }
9102
9103 impl<___R> ::fidl_next::Respond<___R> for GetMoniker {
9104 type Output = ::core::result::Result<
9105 crate::generic::IntrospectorGetMonikerResponse<___R>,
9106 ::fidl_next::util::Never,
9107 >;
9108
9109 fn respond(response: ___R) -> Self::Output {
9110 ::core::result::Result::Ok(crate::generic::IntrospectorGetMonikerResponse {
9111 moniker: response,
9112 })
9113 }
9114 }
9115
9116 impl<___R> ::fidl_next::RespondErr<___R> for GetMoniker {
9117 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9118
9119 fn respond_err(response: ___R) -> Self::Output {
9120 ::core::result::Result::Err(response)
9121 }
9122 }
9123
9124 mod ___detail {
9125 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Introspector
9126 where
9127 ___T: ::fidl_next::Transport,
9128 {
9129 type Client = IntrospectorClient<___T>;
9130 type Server = IntrospectorServer<___T>;
9131 }
9132
9133 #[repr(transparent)]
9135 pub struct IntrospectorClient<___T: ::fidl_next::Transport> {
9136 #[allow(dead_code)]
9137 client: ::fidl_next::protocol::Client<___T>,
9138 }
9139
9140 impl<___T> IntrospectorClient<___T>
9141 where
9142 ___T: ::fidl_next::Transport,
9143 {
9144 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
9145 pub fn get_moniker(
9146 &self,
9147
9148 component_instance: impl ::fidl_next::Encode<
9149 ::fidl_next::wire::fuchsia::Event,
9150 <___T as ::fidl_next::Transport>::SendBuffer,
9151 >,
9152 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
9153 where
9154 <___T as ::fidl_next::Transport>::SendBuffer:
9155 ::fidl_next::encoder::InternalHandleEncoder,
9156 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9157 {
9158 self.get_moniker_with(crate::generic::IntrospectorGetMonikerRequest {
9159 component_instance,
9160 })
9161 }
9162
9163 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
9164 pub fn get_moniker_with<___R>(
9165 &self,
9166 request: ___R,
9167 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
9168 where
9169 ___R: ::fidl_next::Encode<
9170 crate::wire::IntrospectorGetMonikerRequest,
9171 <___T as ::fidl_next::Transport>::SendBuffer,
9172 >,
9173 {
9174 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9175 214344082539672664,
9176 <super::GetMoniker as ::fidl_next::Method>::FLEXIBILITY,
9177 request,
9178 ))
9179 }
9180 }
9181
9182 #[repr(transparent)]
9184 pub struct IntrospectorServer<___T: ::fidl_next::Transport> {
9185 server: ::fidl_next::protocol::Server<___T>,
9186 }
9187
9188 impl<___T> IntrospectorServer<___T> where ___T: ::fidl_next::Transport {}
9189 }
9190}
9191
9192#[diagnostic::on_unimplemented(
9193 note = "If {Self} implements the non-local IntrospectorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9194)]
9195
9196pub trait IntrospectorLocalClientHandler<
9200 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9201 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9202>
9203{
9204 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9205 ::core::future::ready(())
9206 }
9207}
9208
9209impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Introspector
9210where
9211 ___H: IntrospectorLocalClientHandler<___T>,
9212 ___T: ::fidl_next::Transport,
9213{
9214 async fn on_event(
9215 handler: &mut ___H,
9216 mut message: ::fidl_next::Message<___T>,
9217 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9218 match *message.header().ordinal {
9219 ordinal => {
9220 handler.on_unknown_interaction(ordinal).await;
9221 if ::core::matches!(
9222 message.header().flexibility(),
9223 ::fidl_next::protocol::Flexibility::Strict
9224 ) {
9225 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9226 } else {
9227 Ok(())
9228 }
9229 }
9230 }
9231 }
9232}
9233
9234#[diagnostic::on_unimplemented(
9235 note = "If {Self} implements the non-local IntrospectorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9236)]
9237
9238pub trait IntrospectorLocalServerHandler<
9242 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9243 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9244>
9245{
9246 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
9247 fn get_moniker(
9248 &mut self,
9249
9250 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9251
9252 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9253 ) -> impl ::core::future::Future<Output = ()>;
9254
9255 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9256 ::core::future::ready(())
9257 }
9258}
9259
9260impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Introspector
9261where
9262 ___H: IntrospectorLocalServerHandler<___T>,
9263 ___T: ::fidl_next::Transport,
9264 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
9265 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9266 Constraint = (),
9267 >,
9268{
9269 async fn on_one_way(
9270 handler: &mut ___H,
9271 mut message: ::fidl_next::Message<___T>,
9272 ) -> ::core::result::Result<
9273 (),
9274 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9275 > {
9276 match *message.header().ordinal {
9277 ordinal => {
9278 handler.on_unknown_interaction(ordinal).await;
9279 if ::core::matches!(
9280 message.header().flexibility(),
9281 ::fidl_next::protocol::Flexibility::Strict
9282 ) {
9283 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9284 } else {
9285 Ok(())
9286 }
9287 }
9288 }
9289 }
9290
9291 async fn on_two_way(
9292 handler: &mut ___H,
9293 mut message: ::fidl_next::Message<___T>,
9294 responder: ::fidl_next::protocol::Responder<___T>,
9295 ) -> ::core::result::Result<
9296 (),
9297 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9298 > {
9299 match *message.header().ordinal {
9300 214344082539672664 => {
9301 let responder = ::fidl_next::Responder::from_untyped(responder);
9302
9303 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9304 Ok(decoded) => {
9305 handler
9306 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
9307 .await;
9308 Ok(())
9309 }
9310 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9311 ordinal: 214344082539672664,
9312 error,
9313 }),
9314 }
9315 }
9316
9317 ordinal => {
9318 handler.on_unknown_interaction(ordinal).await;
9319 if ::core::matches!(
9320 message.header().flexibility(),
9321 ::fidl_next::protocol::Flexibility::Strict
9322 ) {
9323 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9324 } else {
9325 responder
9326 .respond_framework_error(
9327 ordinal,
9328 ::fidl_next::FrameworkError::UnknownMethod,
9329 )
9330 .expect("encoding a framework error should never fail")
9331 .await?;
9332 Ok(())
9333 }
9334 }
9335 }
9336 }
9337}
9338
9339pub trait IntrospectorClientHandler<
9343 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9344 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9345>
9346{
9347 fn on_unknown_interaction(
9348 &mut self,
9349 ordinal: u64,
9350 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9351 ::core::future::ready(())
9352 }
9353}
9354
9355impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Introspector
9356where
9357 ___H: IntrospectorClientHandler<___T> + ::core::marker::Send,
9358 ___T: ::fidl_next::Transport,
9359{
9360 async fn on_event(
9361 handler: &mut ___H,
9362 mut message: ::fidl_next::Message<___T>,
9363 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9364 match *message.header().ordinal {
9365 ordinal => {
9366 handler.on_unknown_interaction(ordinal).await;
9367 if ::core::matches!(
9368 message.header().flexibility(),
9369 ::fidl_next::protocol::Flexibility::Strict
9370 ) {
9371 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9372 } else {
9373 Ok(())
9374 }
9375 }
9376 }
9377 }
9378}
9379
9380pub trait IntrospectorServerHandler<
9384 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9385 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9386>
9387{
9388 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
9389 fn get_moniker(
9390 &mut self,
9391
9392 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9393
9394 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9395 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9396
9397 fn on_unknown_interaction(
9398 &mut self,
9399 ordinal: u64,
9400 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9401 ::core::future::ready(())
9402 }
9403}
9404
9405impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Introspector
9406where
9407 ___H: IntrospectorServerHandler<___T> + ::core::marker::Send,
9408 ___T: ::fidl_next::Transport,
9409 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
9410 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9411 Constraint = (),
9412 >,
9413{
9414 async fn on_one_way(
9415 handler: &mut ___H,
9416 mut message: ::fidl_next::Message<___T>,
9417 ) -> ::core::result::Result<
9418 (),
9419 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9420 > {
9421 match *message.header().ordinal {
9422 ordinal => {
9423 handler.on_unknown_interaction(ordinal).await;
9424 if ::core::matches!(
9425 message.header().flexibility(),
9426 ::fidl_next::protocol::Flexibility::Strict
9427 ) {
9428 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9429 } else {
9430 Ok(())
9431 }
9432 }
9433 }
9434 }
9435
9436 async fn on_two_way(
9437 handler: &mut ___H,
9438 mut message: ::fidl_next::Message<___T>,
9439 responder: ::fidl_next::protocol::Responder<___T>,
9440 ) -> ::core::result::Result<
9441 (),
9442 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9443 > {
9444 match *message.header().ordinal {
9445 214344082539672664 => {
9446 let responder = ::fidl_next::Responder::from_untyped(responder);
9447
9448 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9449 Ok(decoded) => {
9450 handler
9451 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
9452 .await;
9453 Ok(())
9454 }
9455 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9456 ordinal: 214344082539672664,
9457 error,
9458 }),
9459 }
9460 }
9461
9462 ordinal => {
9463 handler.on_unknown_interaction(ordinal).await;
9464 if ::core::matches!(
9465 message.header().flexibility(),
9466 ::fidl_next::protocol::Flexibility::Strict
9467 ) {
9468 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9469 } else {
9470 responder
9471 .respond_framework_error(
9472 ordinal,
9473 ::fidl_next::FrameworkError::UnknownMethod,
9474 )
9475 .expect("encoding a framework error should never fail")
9476 .await?;
9477 Ok(())
9478 }
9479 }
9480 }
9481 }
9482}
9483
9484impl<___T> IntrospectorClientHandler<___T> for ::fidl_next::IgnoreEvents
9485where
9486 ___T: ::fidl_next::Transport,
9487{
9488 async fn on_unknown_interaction(&mut self, _: u64) {}
9489}
9490
9491impl<___H, ___T> IntrospectorLocalClientHandler<___T> for ::fidl_next::Local<___H>
9492where
9493 ___H: IntrospectorClientHandler<___T>,
9494 ___T: ::fidl_next::Transport,
9495{
9496 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9497 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9498 }
9499}
9500
9501impl<___H, ___T> IntrospectorLocalServerHandler<___T> for ::fidl_next::Local<___H>
9502where
9503 ___H: IntrospectorServerHandler<___T>,
9504 ___T: ::fidl_next::Transport,
9505{
9506 async fn get_moniker(
9507 &mut self,
9508
9509 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9510
9511 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9512 ) {
9513 ___H::get_moniker(&mut self.0, request, responder).await
9514 }
9515
9516 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9517 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9518 }
9519}
9520
9521#[doc = " Protocol for performing namespace operations.\n"]
9523#[derive(PartialEq, Debug)]
9524pub struct Namespace;
9525
9526impl ::fidl_next::Discoverable for Namespace {
9527 const PROTOCOL_NAME: &'static str = "fuchsia.component.Namespace";
9528}
9529
9530#[cfg(target_os = "fuchsia")]
9531impl ::fidl_next::HasTransport for Namespace {
9532 type Transport = ::fidl_next::fuchsia::zx::Channel;
9533}
9534
9535pub mod namespace {
9536 pub mod prelude {
9537 pub use crate::{
9538 Namespace, NamespaceClientHandler, NamespaceLocalClientHandler,
9539 NamespaceLocalServerHandler, NamespaceServerHandler, namespace,
9540 };
9541
9542 pub use crate::natural::NamespaceCreate2Request;
9543
9544 pub use crate::natural::NamespaceCreateRequest;
9545
9546 pub use crate::natural::NamespaceError;
9547
9548 pub use crate::natural::NamespaceCreate2Response;
9549
9550 pub use crate::natural::NamespaceCreateResponse;
9551 }
9552
9553 pub struct Create;
9554
9555 impl ::fidl_next::Method for Create {
9556 const ORDINAL: u64 = 4839678630846501113;
9557 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9558 ::fidl_next::protocol::Flexibility::Flexible;
9559
9560 type Protocol = crate::Namespace;
9561
9562 type Request = crate::wire::NamespaceCreateRequest<'static>;
9563 }
9564
9565 impl ::fidl_next::TwoWayMethod for Create {
9566 type Response = ::fidl_next::wire::Result<
9567 'static,
9568 crate::wire::NamespaceCreateResponse<'static>,
9569 crate::wire::NamespaceError,
9570 >;
9571 }
9572
9573 impl<___R> ::fidl_next::Respond<___R> for Create {
9574 type Output = ::core::result::Result<
9575 crate::generic::NamespaceCreateResponse<___R>,
9576 ::fidl_next::util::Never,
9577 >;
9578
9579 fn respond(response: ___R) -> Self::Output {
9580 ::core::result::Result::Ok(crate::generic::NamespaceCreateResponse {
9581 entries: response,
9582 })
9583 }
9584 }
9585
9586 impl<___R> ::fidl_next::RespondErr<___R> for Create {
9587 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9588
9589 fn respond_err(response: ___R) -> Self::Output {
9590 ::core::result::Result::Err(response)
9591 }
9592 }
9593
9594 pub struct Create2;
9595
9596 impl ::fidl_next::Method for Create2 {
9597 const ORDINAL: u64 = 7375388463768777553;
9598 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9599 ::fidl_next::protocol::Flexibility::Flexible;
9600
9601 type Protocol = crate::Namespace;
9602
9603 type Request = crate::wire::NamespaceCreate2Request<'static>;
9604 }
9605
9606 impl ::fidl_next::TwoWayMethod for Create2 {
9607 type Response = ::fidl_next::wire::Result<
9608 'static,
9609 crate::wire::NamespaceCreate2Response<'static>,
9610 crate::wire::NamespaceError,
9611 >;
9612 }
9613
9614 impl<___R> ::fidl_next::Respond<___R> for Create2 {
9615 type Output = ::core::result::Result<
9616 crate::generic::NamespaceCreate2Response<___R>,
9617 ::fidl_next::util::Never,
9618 >;
9619
9620 fn respond(response: ___R) -> Self::Output {
9621 ::core::result::Result::Ok(crate::generic::NamespaceCreate2Response {
9622 entries: response,
9623 })
9624 }
9625 }
9626
9627 impl<___R> ::fidl_next::RespondErr<___R> for Create2 {
9628 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9629
9630 fn respond_err(response: ___R) -> Self::Output {
9631 ::core::result::Result::Err(response)
9632 }
9633 }
9634
9635 mod ___detail {
9636 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Namespace
9637 where
9638 ___T: ::fidl_next::Transport,
9639 {
9640 type Client = NamespaceClient<___T>;
9641 type Server = NamespaceServer<___T>;
9642 }
9643
9644 #[repr(transparent)]
9646 pub struct NamespaceClient<___T: ::fidl_next::Transport> {
9647 #[allow(dead_code)]
9648 client: ::fidl_next::protocol::Client<___T>,
9649 }
9650
9651 impl<___T> NamespaceClient<___T>
9652 where
9653 ___T: ::fidl_next::Transport,
9654 {
9655 pub fn create(
9656 &self,
9657
9658 entries: impl ::fidl_next::Encode<
9659 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
9660 <___T as ::fidl_next::Transport>::SendBuffer,
9661 >,
9662 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9663 where
9664 <___T as ::fidl_next::Transport>::SendBuffer:
9665 ::fidl_next::encoder::InternalHandleEncoder,
9666 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9667 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9668 {
9669 self.create_with(crate::generic::NamespaceCreateRequest { entries })
9670 }
9671
9672 pub fn create_with<___R>(
9673 &self,
9674 request: ___R,
9675 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9676 where
9677 ___R: ::fidl_next::Encode<
9678 crate::wire::NamespaceCreateRequest<'static>,
9679 <___T as ::fidl_next::Transport>::SendBuffer,
9680 >,
9681 {
9682 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9683 4839678630846501113,
9684 <super::Create as ::fidl_next::Method>::FLEXIBILITY,
9685 request,
9686 ))
9687 }
9688
9689 pub fn create2(
9690 &self,
9691
9692 entries: impl ::fidl_next::Encode<
9693 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
9694 <___T as ::fidl_next::Transport>::SendBuffer,
9695 >,
9696 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9697 where
9698 <___T as ::fidl_next::Transport>::SendBuffer:
9699 ::fidl_next::encoder::InternalHandleEncoder,
9700 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9701 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9702 {
9703 self.create2_with(crate::generic::NamespaceCreate2Request { entries })
9704 }
9705
9706 pub fn create2_with<___R>(
9707 &self,
9708 request: ___R,
9709 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9710 where
9711 ___R: ::fidl_next::Encode<
9712 crate::wire::NamespaceCreate2Request<'static>,
9713 <___T as ::fidl_next::Transport>::SendBuffer,
9714 >,
9715 {
9716 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9717 7375388463768777553,
9718 <super::Create2 as ::fidl_next::Method>::FLEXIBILITY,
9719 request,
9720 ))
9721 }
9722 }
9723
9724 #[repr(transparent)]
9726 pub struct NamespaceServer<___T: ::fidl_next::Transport> {
9727 server: ::fidl_next::protocol::Server<___T>,
9728 }
9729
9730 impl<___T> NamespaceServer<___T> where ___T: ::fidl_next::Transport {}
9731 }
9732}
9733
9734#[diagnostic::on_unimplemented(
9735 note = "If {Self} implements the non-local NamespaceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9736)]
9737
9738pub trait NamespaceLocalClientHandler<
9742 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9743 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9744>
9745{
9746 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9747 ::core::future::ready(())
9748 }
9749}
9750
9751impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Namespace
9752where
9753 ___H: NamespaceLocalClientHandler<___T>,
9754 ___T: ::fidl_next::Transport,
9755{
9756 async fn on_event(
9757 handler: &mut ___H,
9758 mut message: ::fidl_next::Message<___T>,
9759 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9760 match *message.header().ordinal {
9761 ordinal => {
9762 handler.on_unknown_interaction(ordinal).await;
9763 if ::core::matches!(
9764 message.header().flexibility(),
9765 ::fidl_next::protocol::Flexibility::Strict
9766 ) {
9767 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9768 } else {
9769 Ok(())
9770 }
9771 }
9772 }
9773 }
9774}
9775
9776#[diagnostic::on_unimplemented(
9777 note = "If {Self} implements the non-local NamespaceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9778)]
9779
9780pub trait NamespaceLocalServerHandler<
9784 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9785 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9786>
9787{
9788 fn create(
9789 &mut self,
9790
9791 request: ::fidl_next::Request<namespace::Create, ___T>,
9792
9793 responder: ::fidl_next::Responder<namespace::Create, ___T>,
9794 ) -> impl ::core::future::Future<Output = ()>;
9795
9796 fn create2(
9797 &mut self,
9798
9799 request: ::fidl_next::Request<namespace::Create2, ___T>,
9800
9801 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
9802 ) -> impl ::core::future::Future<Output = ()>;
9803
9804 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9805 ::core::future::ready(())
9806 }
9807}
9808
9809impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Namespace
9810where
9811 ___H: NamespaceLocalServerHandler<___T>,
9812 ___T: ::fidl_next::Transport,
9813 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
9814 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9815 Constraint = (),
9816 >,
9817 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
9818 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9819 Constraint = (),
9820 >,
9821{
9822 async fn on_one_way(
9823 handler: &mut ___H,
9824 mut message: ::fidl_next::Message<___T>,
9825 ) -> ::core::result::Result<
9826 (),
9827 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9828 > {
9829 match *message.header().ordinal {
9830 ordinal => {
9831 handler.on_unknown_interaction(ordinal).await;
9832 if ::core::matches!(
9833 message.header().flexibility(),
9834 ::fidl_next::protocol::Flexibility::Strict
9835 ) {
9836 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9837 } else {
9838 Ok(())
9839 }
9840 }
9841 }
9842 }
9843
9844 async fn on_two_way(
9845 handler: &mut ___H,
9846 mut message: ::fidl_next::Message<___T>,
9847 responder: ::fidl_next::protocol::Responder<___T>,
9848 ) -> ::core::result::Result<
9849 (),
9850 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9851 > {
9852 match *message.header().ordinal {
9853 4839678630846501113 => {
9854 let responder = ::fidl_next::Responder::from_untyped(responder);
9855
9856 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9857 Ok(decoded) => {
9858 handler
9859 .create(::fidl_next::Request::from_decoded(decoded), responder)
9860 .await;
9861 Ok(())
9862 }
9863 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9864 ordinal: 4839678630846501113,
9865 error,
9866 }),
9867 }
9868 }
9869
9870 7375388463768777553 => {
9871 let responder = ::fidl_next::Responder::from_untyped(responder);
9872
9873 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9874 Ok(decoded) => {
9875 handler
9876 .create2(::fidl_next::Request::from_decoded(decoded), responder)
9877 .await;
9878 Ok(())
9879 }
9880 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9881 ordinal: 7375388463768777553,
9882 error,
9883 }),
9884 }
9885 }
9886
9887 ordinal => {
9888 handler.on_unknown_interaction(ordinal).await;
9889 if ::core::matches!(
9890 message.header().flexibility(),
9891 ::fidl_next::protocol::Flexibility::Strict
9892 ) {
9893 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9894 } else {
9895 responder
9896 .respond_framework_error(
9897 ordinal,
9898 ::fidl_next::FrameworkError::UnknownMethod,
9899 )
9900 .expect("encoding a framework error should never fail")
9901 .await?;
9902 Ok(())
9903 }
9904 }
9905 }
9906 }
9907}
9908
9909pub trait NamespaceClientHandler<
9913 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9914 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9915>
9916{
9917 fn on_unknown_interaction(
9918 &mut self,
9919 ordinal: u64,
9920 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9921 ::core::future::ready(())
9922 }
9923}
9924
9925impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Namespace
9926where
9927 ___H: NamespaceClientHandler<___T> + ::core::marker::Send,
9928 ___T: ::fidl_next::Transport,
9929{
9930 async fn on_event(
9931 handler: &mut ___H,
9932 mut message: ::fidl_next::Message<___T>,
9933 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9934 match *message.header().ordinal {
9935 ordinal => {
9936 handler.on_unknown_interaction(ordinal).await;
9937 if ::core::matches!(
9938 message.header().flexibility(),
9939 ::fidl_next::protocol::Flexibility::Strict
9940 ) {
9941 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9942 } else {
9943 Ok(())
9944 }
9945 }
9946 }
9947 }
9948}
9949
9950pub trait NamespaceServerHandler<
9954 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9955 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9956>
9957{
9958 fn create(
9959 &mut self,
9960
9961 request: ::fidl_next::Request<namespace::Create, ___T>,
9962
9963 responder: ::fidl_next::Responder<namespace::Create, ___T>,
9964 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9965
9966 fn create2(
9967 &mut self,
9968
9969 request: ::fidl_next::Request<namespace::Create2, ___T>,
9970
9971 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
9972 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9973
9974 fn on_unknown_interaction(
9975 &mut self,
9976 ordinal: u64,
9977 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9978 ::core::future::ready(())
9979 }
9980}
9981
9982impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Namespace
9983where
9984 ___H: NamespaceServerHandler<___T> + ::core::marker::Send,
9985 ___T: ::fidl_next::Transport,
9986 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
9987 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9988 Constraint = (),
9989 >,
9990 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
9991 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9992 Constraint = (),
9993 >,
9994{
9995 async fn on_one_way(
9996 handler: &mut ___H,
9997 mut message: ::fidl_next::Message<___T>,
9998 ) -> ::core::result::Result<
9999 (),
10000 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10001 > {
10002 match *message.header().ordinal {
10003 ordinal => {
10004 handler.on_unknown_interaction(ordinal).await;
10005 if ::core::matches!(
10006 message.header().flexibility(),
10007 ::fidl_next::protocol::Flexibility::Strict
10008 ) {
10009 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10010 } else {
10011 Ok(())
10012 }
10013 }
10014 }
10015 }
10016
10017 async fn on_two_way(
10018 handler: &mut ___H,
10019 mut message: ::fidl_next::Message<___T>,
10020 responder: ::fidl_next::protocol::Responder<___T>,
10021 ) -> ::core::result::Result<
10022 (),
10023 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10024 > {
10025 match *message.header().ordinal {
10026 4839678630846501113 => {
10027 let responder = ::fidl_next::Responder::from_untyped(responder);
10028
10029 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10030 Ok(decoded) => {
10031 handler
10032 .create(::fidl_next::Request::from_decoded(decoded), responder)
10033 .await;
10034 Ok(())
10035 }
10036 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10037 ordinal: 4839678630846501113,
10038 error,
10039 }),
10040 }
10041 }
10042
10043 7375388463768777553 => {
10044 let responder = ::fidl_next::Responder::from_untyped(responder);
10045
10046 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10047 Ok(decoded) => {
10048 handler
10049 .create2(::fidl_next::Request::from_decoded(decoded), responder)
10050 .await;
10051 Ok(())
10052 }
10053 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10054 ordinal: 7375388463768777553,
10055 error,
10056 }),
10057 }
10058 }
10059
10060 ordinal => {
10061 handler.on_unknown_interaction(ordinal).await;
10062 if ::core::matches!(
10063 message.header().flexibility(),
10064 ::fidl_next::protocol::Flexibility::Strict
10065 ) {
10066 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10067 } else {
10068 responder
10069 .respond_framework_error(
10070 ordinal,
10071 ::fidl_next::FrameworkError::UnknownMethod,
10072 )
10073 .expect("encoding a framework error should never fail")
10074 .await?;
10075 Ok(())
10076 }
10077 }
10078 }
10079 }
10080}
10081
10082impl<___T> NamespaceClientHandler<___T> for ::fidl_next::IgnoreEvents
10083where
10084 ___T: ::fidl_next::Transport,
10085{
10086 async fn on_unknown_interaction(&mut self, _: u64) {}
10087}
10088
10089impl<___H, ___T> NamespaceLocalClientHandler<___T> for ::fidl_next::Local<___H>
10090where
10091 ___H: NamespaceClientHandler<___T>,
10092 ___T: ::fidl_next::Transport,
10093{
10094 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10095 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10096 }
10097}
10098
10099impl<___H, ___T> NamespaceLocalServerHandler<___T> for ::fidl_next::Local<___H>
10100where
10101 ___H: NamespaceServerHandler<___T>,
10102 ___T: ::fidl_next::Transport,
10103{
10104 async fn create(
10105 &mut self,
10106
10107 request: ::fidl_next::Request<namespace::Create, ___T>,
10108
10109 responder: ::fidl_next::Responder<namespace::Create, ___T>,
10110 ) {
10111 ___H::create(&mut self.0, request, responder).await
10112 }
10113
10114 async fn create2(
10115 &mut self,
10116
10117 request: ::fidl_next::Request<namespace::Create2, ___T>,
10118
10119 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
10120 ) {
10121 ___H::create2(&mut self.0, request, responder).await
10122 }
10123
10124 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10125 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10126 }
10127}
10128
10129#[doc = " A protocol used by a component instance to manage its own realm, such as for\n binding to its children.\n\n Requests to this protocol are processed in the order they are received.\n Clients that wish to send requests in parallel should open multiple\n connections.\n\n The component framework provides this service to components that use\n `fuchsia.component.Realm`.\n"]
10131#[derive(PartialEq, Debug)]
10132pub struct Realm;
10133
10134impl ::fidl_next::Discoverable for Realm {
10135 const PROTOCOL_NAME: &'static str = "fuchsia.component.Realm";
10136}
10137
10138#[cfg(target_os = "fuchsia")]
10139impl ::fidl_next::HasTransport for Realm {
10140 type Transport = ::fidl_next::fuchsia::zx::Channel;
10141}
10142
10143pub mod realm {
10144 pub mod prelude {
10145 pub use crate::{
10146 Realm, RealmClientHandler, RealmLocalClientHandler, RealmLocalServerHandler,
10147 RealmServerHandler, realm,
10148 };
10149
10150 pub use crate::natural::Error;
10151
10152 pub use crate::natural::RealmCreateChildRequest;
10153
10154 pub use crate::natural::RealmDestroyChildRequest;
10155
10156 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
10157
10158 pub use crate::natural::RealmGetChildOutputDictionaryRequest;
10159
10160 pub use crate::natural::RealmListChildrenRequest;
10161
10162 pub use crate::natural::RealmOpenControllerRequest;
10163
10164 pub use crate::natural::RealmOpenExposedDirRequest;
10165
10166 pub use crate::natural::RealmCreateChildResponse;
10167
10168 pub use crate::natural::RealmDestroyChildResponse;
10169
10170 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
10171
10172 pub use crate::natural::RealmGetChildOutputDictionaryResponse;
10173
10174 pub use crate::natural::RealmGetResolvedInfoResponse;
10175
10176 pub use crate::natural::RealmListChildrenResponse;
10177
10178 pub use crate::natural::RealmOpenControllerResponse;
10179
10180 pub use crate::natural::RealmOpenExposedDirResponse;
10181 }
10182
10183 pub struct OpenController;
10184
10185 impl ::fidl_next::Method for OpenController {
10186 const ORDINAL: u64 = 8165227925828473216;
10187 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10188 ::fidl_next::protocol::Flexibility::Strict;
10189
10190 type Protocol = crate::Realm;
10191
10192 type Request = crate::wire::RealmOpenControllerRequest<'static>;
10193 }
10194
10195 impl ::fidl_next::TwoWayMethod for OpenController {
10196 type Response = ::fidl_next::wire::Result<
10197 'static,
10198 crate::wire::RealmOpenControllerResponse,
10199 crate::wire::Error,
10200 >;
10201 }
10202
10203 impl<___R> ::fidl_next::Respond<___R> for OpenController {
10204 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10205
10206 fn respond(response: ___R) -> Self::Output {
10207 ::core::result::Result::Ok(response)
10208 }
10209 }
10210
10211 impl<___R> ::fidl_next::RespondErr<___R> for OpenController {
10212 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10213
10214 fn respond_err(response: ___R) -> Self::Output {
10215 ::core::result::Result::Err(response)
10216 }
10217 }
10218
10219 pub struct OpenExposedDir;
10220
10221 impl ::fidl_next::Method for OpenExposedDir {
10222 const ORDINAL: u64 = 9194435320863127852;
10223 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10224 ::fidl_next::protocol::Flexibility::Strict;
10225
10226 type Protocol = crate::Realm;
10227
10228 type Request = crate::wire::RealmOpenExposedDirRequest<'static>;
10229 }
10230
10231 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
10232 type Response = ::fidl_next::wire::Result<
10233 'static,
10234 crate::wire::RealmOpenExposedDirResponse,
10235 crate::wire::Error,
10236 >;
10237 }
10238
10239 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
10240 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10241
10242 fn respond(response: ___R) -> Self::Output {
10243 ::core::result::Result::Ok(response)
10244 }
10245 }
10246
10247 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
10248 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10249
10250 fn respond_err(response: ___R) -> Self::Output {
10251 ::core::result::Result::Err(response)
10252 }
10253 }
10254
10255 pub struct CreateChild;
10256
10257 impl ::fidl_next::Method for CreateChild {
10258 const ORDINAL: u64 = 4892190024503489888;
10259 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10260 ::fidl_next::protocol::Flexibility::Strict;
10261
10262 type Protocol = crate::Realm;
10263
10264 type Request = crate::wire::RealmCreateChildRequest<'static>;
10265 }
10266
10267 impl ::fidl_next::TwoWayMethod for CreateChild {
10268 type Response = ::fidl_next::wire::Result<
10269 'static,
10270 crate::wire::RealmCreateChildResponse,
10271 crate::wire::Error,
10272 >;
10273 }
10274
10275 impl<___R> ::fidl_next::Respond<___R> for CreateChild {
10276 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10277
10278 fn respond(response: ___R) -> Self::Output {
10279 ::core::result::Result::Ok(response)
10280 }
10281 }
10282
10283 impl<___R> ::fidl_next::RespondErr<___R> for CreateChild {
10284 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10285
10286 fn respond_err(response: ___R) -> Self::Output {
10287 ::core::result::Result::Err(response)
10288 }
10289 }
10290
10291 pub struct DestroyChild;
10292
10293 impl ::fidl_next::Method for DestroyChild {
10294 const ORDINAL: u64 = 8203529889988252194;
10295 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10296 ::fidl_next::protocol::Flexibility::Strict;
10297
10298 type Protocol = crate::Realm;
10299
10300 type Request = crate::wire::RealmDestroyChildRequest<'static>;
10301 }
10302
10303 impl ::fidl_next::TwoWayMethod for DestroyChild {
10304 type Response = ::fidl_next::wire::Result<
10305 'static,
10306 crate::wire::RealmDestroyChildResponse,
10307 crate::wire::Error,
10308 >;
10309 }
10310
10311 impl<___R> ::fidl_next::Respond<___R> for DestroyChild {
10312 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10313
10314 fn respond(response: ___R) -> Self::Output {
10315 ::core::result::Result::Ok(response)
10316 }
10317 }
10318
10319 impl<___R> ::fidl_next::RespondErr<___R> for DestroyChild {
10320 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10321
10322 fn respond_err(response: ___R) -> Self::Output {
10323 ::core::result::Result::Err(response)
10324 }
10325 }
10326
10327 pub struct ListChildren;
10328
10329 impl ::fidl_next::Method for ListChildren {
10330 const ORDINAL: u64 = 7532454435519185057;
10331 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10332 ::fidl_next::protocol::Flexibility::Strict;
10333
10334 type Protocol = crate::Realm;
10335
10336 type Request = crate::wire::RealmListChildrenRequest<'static>;
10337 }
10338
10339 impl ::fidl_next::TwoWayMethod for ListChildren {
10340 type Response = ::fidl_next::wire::Result<
10341 'static,
10342 crate::wire::RealmListChildrenResponse,
10343 crate::wire::Error,
10344 >;
10345 }
10346
10347 impl<___R> ::fidl_next::Respond<___R> for ListChildren {
10348 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10349
10350 fn respond(response: ___R) -> Self::Output {
10351 ::core::result::Result::Ok(response)
10352 }
10353 }
10354
10355 impl<___R> ::fidl_next::RespondErr<___R> for ListChildren {
10356 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10357
10358 fn respond_err(response: ___R) -> Self::Output {
10359 ::core::result::Result::Err(response)
10360 }
10361 }
10362
10363 pub struct GetResolvedInfo;
10364
10365 impl ::fidl_next::Method for GetResolvedInfo {
10366 const ORDINAL: u64 = 8308987710372188322;
10367 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10368 ::fidl_next::protocol::Flexibility::Strict;
10369
10370 type Protocol = crate::Realm;
10371
10372 type Request = ::fidl_next::wire::EmptyMessageBody;
10373 }
10374
10375 impl ::fidl_next::TwoWayMethod for GetResolvedInfo {
10376 type Response = ::fidl_next::wire::Result<
10377 'static,
10378 crate::wire::RealmGetResolvedInfoResponse<'static>,
10379 crate::wire::Error,
10380 >;
10381 }
10382
10383 impl<___R> ::fidl_next::Respond<___R> for GetResolvedInfo {
10384 type Output = ::core::result::Result<
10385 crate::generic::RealmGetResolvedInfoResponse<___R>,
10386 ::fidl_next::util::Never,
10387 >;
10388
10389 fn respond(response: ___R) -> Self::Output {
10390 ::core::result::Result::Ok(crate::generic::RealmGetResolvedInfoResponse {
10391 resolved_info: response,
10392 })
10393 }
10394 }
10395
10396 impl<___R> ::fidl_next::RespondErr<___R> for GetResolvedInfo {
10397 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10398
10399 fn respond_err(response: ___R) -> Self::Output {
10400 ::core::result::Result::Err(response)
10401 }
10402 }
10403
10404 pub struct GetChildOutputDictionaryDeprecated;
10405
10406 impl ::fidl_next::Method for GetChildOutputDictionaryDeprecated {
10407 const ORDINAL: u64 = 4117516026351534948;
10408 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10409 ::fidl_next::protocol::Flexibility::Strict;
10410
10411 type Protocol = crate::Realm;
10412
10413 type Request = crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>;
10414 }
10415
10416 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionaryDeprecated {
10417 type Response = ::fidl_next::wire::Result<
10418 'static,
10419 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
10420 crate::wire::Error,
10421 >;
10422 }
10423
10424 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionaryDeprecated {
10425 type Output = ::core::result::Result<
10426 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse<___R>,
10427 ::fidl_next::util::Never,
10428 >;
10429
10430 fn respond(response: ___R) -> Self::Output {
10431 ::core::result::Result::Ok(
10432 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse {
10433 dictionary: response,
10434 },
10435 )
10436 }
10437 }
10438
10439 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionaryDeprecated {
10440 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10441
10442 fn respond_err(response: ___R) -> Self::Output {
10443 ::core::result::Result::Err(response)
10444 }
10445 }
10446
10447 pub struct GetChildOutputDictionary;
10448
10449 impl ::fidl_next::Method for GetChildOutputDictionary {
10450 const ORDINAL: u64 = 4781081784078915088;
10451 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10452 ::fidl_next::protocol::Flexibility::Strict;
10453
10454 type Protocol = crate::Realm;
10455
10456 type Request = crate::wire::RealmGetChildOutputDictionaryRequest<'static>;
10457 }
10458
10459 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionary {
10460 type Response = ::fidl_next::wire::Result<
10461 'static,
10462 crate::wire::RealmGetChildOutputDictionaryResponse,
10463 crate::wire::Error,
10464 >;
10465 }
10466
10467 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionary {
10468 type Output = ::core::result::Result<
10469 crate::generic::RealmGetChildOutputDictionaryResponse<___R>,
10470 ::fidl_next::util::Never,
10471 >;
10472
10473 fn respond(response: ___R) -> Self::Output {
10474 ::core::result::Result::Ok(crate::generic::RealmGetChildOutputDictionaryResponse {
10475 dictionary: response,
10476 })
10477 }
10478 }
10479
10480 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionary {
10481 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10482
10483 fn respond_err(response: ___R) -> Self::Output {
10484 ::core::result::Result::Err(response)
10485 }
10486 }
10487
10488 mod ___detail {
10489 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Realm
10490 where
10491 ___T: ::fidl_next::Transport,
10492 {
10493 type Client = RealmClient<___T>;
10494 type Server = RealmServer<___T>;
10495 }
10496
10497 #[repr(transparent)]
10499 pub struct RealmClient<___T: ::fidl_next::Transport> {
10500 #[allow(dead_code)]
10501 client: ::fidl_next::protocol::Client<___T>,
10502 }
10503
10504 impl<___T> RealmClient<___T>
10505 where
10506 ___T: ::fidl_next::Transport,
10507 {
10508 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10509 pub fn open_controller(
10510 &self,
10511
10512 child: impl ::fidl_next::Encode<
10513 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10514 <___T as ::fidl_next::Transport>::SendBuffer,
10515 >,
10516
10517 controller: impl ::fidl_next::Encode<
10518 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
10519 <___T as ::fidl_next::Transport>::SendBuffer,
10520 >,
10521 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
10522 where
10523 <___T as ::fidl_next::Transport>::SendBuffer:
10524 ::fidl_next::encoder::InternalHandleEncoder,
10525 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10526 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10527 {
10528 self.open_controller_with(crate::generic::RealmOpenControllerRequest {
10529 child,
10530
10531 controller,
10532 })
10533 }
10534
10535 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10536 pub fn open_controller_with<___R>(
10537 &self,
10538 request: ___R,
10539 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
10540 where
10541 ___R: ::fidl_next::Encode<
10542 crate::wire::RealmOpenControllerRequest<'static>,
10543 <___T as ::fidl_next::Transport>::SendBuffer,
10544 >,
10545 {
10546 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10547 8165227925828473216,
10548 <super::OpenController as ::fidl_next::Method>::FLEXIBILITY,
10549 request,
10550 ))
10551 }
10552
10553 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10554 pub fn open_exposed_dir(
10555 &self,
10556
10557 child: impl ::fidl_next::Encode<
10558 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10559 <___T as ::fidl_next::Transport>::SendBuffer,
10560 >,
10561
10562 exposed_dir: impl ::fidl_next::Encode<
10563 ::fidl_next::ServerEnd<
10564 ::fidl_next_fuchsia_io::Directory,
10565 ::fidl_next::wire::fuchsia::Channel,
10566 >,
10567 <___T as ::fidl_next::Transport>::SendBuffer,
10568 >,
10569 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
10570 where
10571 <___T as ::fidl_next::Transport>::SendBuffer:
10572 ::fidl_next::encoder::InternalHandleEncoder,
10573 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10574 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10575 {
10576 self.open_exposed_dir_with(crate::generic::RealmOpenExposedDirRequest {
10577 child,
10578
10579 exposed_dir,
10580 })
10581 }
10582
10583 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10584 pub fn open_exposed_dir_with<___R>(
10585 &self,
10586 request: ___R,
10587 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
10588 where
10589 ___R: ::fidl_next::Encode<
10590 crate::wire::RealmOpenExposedDirRequest<'static>,
10591 <___T as ::fidl_next::Transport>::SendBuffer,
10592 >,
10593 {
10594 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10595 9194435320863127852,
10596 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
10597 request,
10598 ))
10599 }
10600
10601 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10602 pub fn create_child(
10603 &self,
10604
10605 collection: impl ::fidl_next::Encode<
10606 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
10607 <___T as ::fidl_next::Transport>::SendBuffer,
10608 >,
10609
10610 decl: impl ::fidl_next::Encode<
10611 ::fidl_next_fuchsia_component_decl::wire::Child<'static>,
10612 <___T as ::fidl_next::Transport>::SendBuffer,
10613 >,
10614
10615 args: impl ::fidl_next::Encode<
10616 crate::wire::CreateChildArgs<'static>,
10617 <___T as ::fidl_next::Transport>::SendBuffer,
10618 >,
10619 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
10620 where
10621 <___T as ::fidl_next::Transport>::SendBuffer:
10622 ::fidl_next::encoder::InternalHandleEncoder,
10623 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10624 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10625 {
10626 self.create_child_with(crate::generic::RealmCreateChildRequest {
10627 collection,
10628
10629 decl,
10630
10631 args,
10632 })
10633 }
10634
10635 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10636 pub fn create_child_with<___R>(
10637 &self,
10638 request: ___R,
10639 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
10640 where
10641 ___R: ::fidl_next::Encode<
10642 crate::wire::RealmCreateChildRequest<'static>,
10643 <___T as ::fidl_next::Transport>::SendBuffer,
10644 >,
10645 {
10646 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10647 4892190024503489888,
10648 <super::CreateChild as ::fidl_next::Method>::FLEXIBILITY,
10649 request,
10650 ))
10651 }
10652
10653 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10654 pub fn destroy_child(
10655 &self,
10656
10657 child: impl ::fidl_next::Encode<
10658 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10659 <___T as ::fidl_next::Transport>::SendBuffer,
10660 >,
10661 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
10662 where
10663 <___T as ::fidl_next::Transport>::SendBuffer:
10664 ::fidl_next::encoder::InternalHandleEncoder,
10665 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10666 {
10667 self.destroy_child_with(crate::generic::RealmDestroyChildRequest { child })
10668 }
10669
10670 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10671 pub fn destroy_child_with<___R>(
10672 &self,
10673 request: ___R,
10674 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
10675 where
10676 ___R: ::fidl_next::Encode<
10677 crate::wire::RealmDestroyChildRequest<'static>,
10678 <___T as ::fidl_next::Transport>::SendBuffer,
10679 >,
10680 {
10681 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10682 8203529889988252194,
10683 <super::DestroyChild as ::fidl_next::Method>::FLEXIBILITY,
10684 request,
10685 ))
10686 }
10687
10688 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
10689 pub fn list_children(
10690 &self,
10691
10692 collection: impl ::fidl_next::Encode<
10693 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
10694 <___T as ::fidl_next::Transport>::SendBuffer,
10695 >,
10696
10697 iter: impl ::fidl_next::Encode<
10698 ::fidl_next::ServerEnd<
10699 crate::ChildIterator,
10700 ::fidl_next::wire::fuchsia::Channel,
10701 >,
10702 <___T as ::fidl_next::Transport>::SendBuffer,
10703 >,
10704 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
10705 where
10706 <___T as ::fidl_next::Transport>::SendBuffer:
10707 ::fidl_next::encoder::InternalHandleEncoder,
10708 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10709 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10710 {
10711 self.list_children_with(crate::generic::RealmListChildrenRequest {
10712 collection,
10713
10714 iter,
10715 })
10716 }
10717
10718 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
10719 pub fn list_children_with<___R>(
10720 &self,
10721 request: ___R,
10722 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
10723 where
10724 ___R: ::fidl_next::Encode<
10725 crate::wire::RealmListChildrenRequest<'static>,
10726 <___T as ::fidl_next::Transport>::SendBuffer,
10727 >,
10728 {
10729 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10730 7532454435519185057,
10731 <super::ListChildren as ::fidl_next::Method>::FLEXIBILITY,
10732 request,
10733 ))
10734 }
10735
10736 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
10737 pub fn get_resolved_info(
10738 &self,
10739 ) -> ::fidl_next::TwoWayFuture<'_, super::GetResolvedInfo, ___T> {
10740 ::fidl_next::TwoWayFuture::from_untyped(
10741 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10742 8308987710372188322,
10743 <super::GetResolvedInfo as ::fidl_next::Method>::FLEXIBILITY,
10744 (),
10745 ),
10746 )
10747 }
10748
10749 pub fn get_child_output_dictionary_deprecated(
10750 &self,
10751
10752 child: impl ::fidl_next::Encode<
10753 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10754 <___T as ::fidl_next::Transport>::SendBuffer,
10755 >,
10756 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
10757 where
10758 <___T as ::fidl_next::Transport>::SendBuffer:
10759 ::fidl_next::encoder::InternalHandleEncoder,
10760 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10761 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10762 {
10763 self.get_child_output_dictionary_deprecated_with(
10764 crate::generic::RealmGetChildOutputDictionaryDeprecatedRequest { child },
10765 )
10766 }
10767
10768 pub fn get_child_output_dictionary_deprecated_with<___R>(
10769 &self,
10770 request: ___R,
10771 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
10772 where
10773 ___R: ::fidl_next::Encode<
10774 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
10775 <___T as ::fidl_next::Transport>::SendBuffer,
10776 >,
10777 {
10778 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10779 4117516026351534948,
10780 <super::GetChildOutputDictionaryDeprecated as ::fidl_next::Method>::FLEXIBILITY,
10781 request,
10782 ))
10783 }
10784
10785 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
10786 pub fn get_child_output_dictionary(
10787 &self,
10788
10789 child: impl ::fidl_next::Encode<
10790 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10791 <___T as ::fidl_next::Transport>::SendBuffer,
10792 >,
10793 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
10794 where
10795 <___T as ::fidl_next::Transport>::SendBuffer:
10796 ::fidl_next::encoder::InternalHandleEncoder,
10797 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10798 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10799 {
10800 self.get_child_output_dictionary_with(
10801 crate::generic::RealmGetChildOutputDictionaryRequest { child },
10802 )
10803 }
10804
10805 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
10806 pub fn get_child_output_dictionary_with<___R>(
10807 &self,
10808 request: ___R,
10809 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
10810 where
10811 ___R: ::fidl_next::Encode<
10812 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
10813 <___T as ::fidl_next::Transport>::SendBuffer,
10814 >,
10815 {
10816 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10817 4781081784078915088,
10818 <super::GetChildOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
10819 request,
10820 ))
10821 }
10822 }
10823
10824 #[repr(transparent)]
10826 pub struct RealmServer<___T: ::fidl_next::Transport> {
10827 server: ::fidl_next::protocol::Server<___T>,
10828 }
10829
10830 impl<___T> RealmServer<___T> where ___T: ::fidl_next::Transport {}
10831 }
10832}
10833
10834#[diagnostic::on_unimplemented(
10835 note = "If {Self} implements the non-local RealmClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
10836)]
10837
10838pub trait RealmLocalClientHandler<
10842 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10843 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10844>
10845{
10846}
10847
10848impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Realm
10849where
10850 ___H: RealmLocalClientHandler<___T>,
10851 ___T: ::fidl_next::Transport,
10852{
10853 async fn on_event(
10854 handler: &mut ___H,
10855 mut message: ::fidl_next::Message<___T>,
10856 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10857 match *message.header().ordinal {
10858 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10859 }
10860 }
10861}
10862
10863#[diagnostic::on_unimplemented(
10864 note = "If {Self} implements the non-local RealmServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
10865)]
10866
10867pub trait RealmLocalServerHandler<
10871 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10872 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10873>
10874{
10875 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10876 fn open_controller(
10877 &mut self,
10878
10879 request: ::fidl_next::Request<realm::OpenController, ___T>,
10880
10881 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
10882 ) -> impl ::core::future::Future<Output = ()>;
10883
10884 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10885 fn open_exposed_dir(
10886 &mut self,
10887
10888 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
10889
10890 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
10891 ) -> impl ::core::future::Future<Output = ()>;
10892
10893 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10894 fn create_child(
10895 &mut self,
10896
10897 request: ::fidl_next::Request<realm::CreateChild, ___T>,
10898
10899 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
10900 ) -> impl ::core::future::Future<Output = ()>;
10901
10902 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
10903 fn destroy_child(
10904 &mut self,
10905
10906 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
10907
10908 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
10909 ) -> impl ::core::future::Future<Output = ()>;
10910
10911 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
10912 fn list_children(
10913 &mut self,
10914
10915 request: ::fidl_next::Request<realm::ListChildren, ___T>,
10916
10917 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
10918 ) -> impl ::core::future::Future<Output = ()>;
10919
10920 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
10921 fn get_resolved_info(
10922 &mut self,
10923
10924 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
10925 ) -> impl ::core::future::Future<Output = ()>;
10926
10927 fn get_child_output_dictionary_deprecated(
10928 &mut self,
10929
10930 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
10931
10932 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
10933 ) -> impl ::core::future::Future<Output = ()>;
10934
10935 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
10936 fn get_child_output_dictionary(
10937 &mut self,
10938
10939 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
10940
10941 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
10942 ) -> impl ::core::future::Future<Output = ()>;
10943}
10944
10945impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Realm
10946where
10947 ___H: RealmLocalServerHandler<___T>,
10948 ___T: ::fidl_next::Transport,
10949 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
10950 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10951 Constraint = (),
10952 >,
10953 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
10954 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10955 Constraint = (),
10956 >,
10957 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
10958 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10959 Constraint = (),
10960 >,
10961 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
10962 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10963 Constraint = (),
10964 >,
10965 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
10966 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10967 Constraint = (),
10968 >,
10969 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
10970 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10971 Constraint = (),
10972 >,
10973 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
10974 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10975 Constraint = (),
10976 >,
10977{
10978 async fn on_one_way(
10979 handler: &mut ___H,
10980 mut message: ::fidl_next::Message<___T>,
10981 ) -> ::core::result::Result<
10982 (),
10983 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10984 > {
10985 match *message.header().ordinal {
10986 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10987 }
10988 }
10989
10990 async fn on_two_way(
10991 handler: &mut ___H,
10992 mut message: ::fidl_next::Message<___T>,
10993 responder: ::fidl_next::protocol::Responder<___T>,
10994 ) -> ::core::result::Result<
10995 (),
10996 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10997 > {
10998 match *message.header().ordinal {
10999 8165227925828473216 => {
11000 let responder = ::fidl_next::Responder::from_untyped(responder);
11001
11002 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11003 Ok(decoded) => {
11004 handler
11005 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
11006 .await;
11007 Ok(())
11008 }
11009 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11010 ordinal: 8165227925828473216,
11011 error,
11012 }),
11013 }
11014 }
11015
11016 9194435320863127852 => {
11017 let responder = ::fidl_next::Responder::from_untyped(responder);
11018
11019 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11020 Ok(decoded) => {
11021 handler
11022 .open_exposed_dir(
11023 ::fidl_next::Request::from_decoded(decoded),
11024 responder,
11025 )
11026 .await;
11027 Ok(())
11028 }
11029 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11030 ordinal: 9194435320863127852,
11031 error,
11032 }),
11033 }
11034 }
11035
11036 4892190024503489888 => {
11037 let responder = ::fidl_next::Responder::from_untyped(responder);
11038
11039 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11040 Ok(decoded) => {
11041 handler
11042 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
11043 .await;
11044 Ok(())
11045 }
11046 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11047 ordinal: 4892190024503489888,
11048 error,
11049 }),
11050 }
11051 }
11052
11053 8203529889988252194 => {
11054 let responder = ::fidl_next::Responder::from_untyped(responder);
11055
11056 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11057 Ok(decoded) => {
11058 handler
11059 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
11060 .await;
11061 Ok(())
11062 }
11063 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11064 ordinal: 8203529889988252194,
11065 error,
11066 }),
11067 }
11068 }
11069
11070 7532454435519185057 => {
11071 let responder = ::fidl_next::Responder::from_untyped(responder);
11072
11073 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11074 Ok(decoded) => {
11075 handler
11076 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
11077 .await;
11078 Ok(())
11079 }
11080 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11081 ordinal: 7532454435519185057,
11082 error,
11083 }),
11084 }
11085 }
11086
11087 8308987710372188322 => {
11088 let responder = ::fidl_next::Responder::from_untyped(responder);
11089
11090 handler.get_resolved_info(responder).await;
11091 Ok(())
11092 }
11093
11094 4117516026351534948 => {
11095 let responder = ::fidl_next::Responder::from_untyped(responder);
11096
11097 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11098 Ok(decoded) => {
11099 handler
11100 .get_child_output_dictionary_deprecated(
11101 ::fidl_next::Request::from_decoded(decoded),
11102 responder,
11103 )
11104 .await;
11105 Ok(())
11106 }
11107 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11108 ordinal: 4117516026351534948,
11109 error,
11110 }),
11111 }
11112 }
11113
11114 4781081784078915088 => {
11115 let responder = ::fidl_next::Responder::from_untyped(responder);
11116
11117 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11118 Ok(decoded) => {
11119 handler
11120 .get_child_output_dictionary(
11121 ::fidl_next::Request::from_decoded(decoded),
11122 responder,
11123 )
11124 .await;
11125 Ok(())
11126 }
11127 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11128 ordinal: 4781081784078915088,
11129 error,
11130 }),
11131 }
11132 }
11133
11134 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11135 }
11136 }
11137}
11138
11139pub trait RealmClientHandler<
11143 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11144 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11145>
11146{
11147}
11148
11149impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Realm
11150where
11151 ___H: RealmClientHandler<___T> + ::core::marker::Send,
11152 ___T: ::fidl_next::Transport,
11153{
11154 async fn on_event(
11155 handler: &mut ___H,
11156 mut message: ::fidl_next::Message<___T>,
11157 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11158 match *message.header().ordinal {
11159 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11160 }
11161 }
11162}
11163
11164pub trait RealmServerHandler<
11168 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11169 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11170>
11171{
11172 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11173 fn open_controller(
11174 &mut self,
11175
11176 request: ::fidl_next::Request<realm::OpenController, ___T>,
11177
11178 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11179 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11180
11181 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11182 fn open_exposed_dir(
11183 &mut self,
11184
11185 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11186
11187 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11188 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11189
11190 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11191 fn create_child(
11192 &mut self,
11193
11194 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11195
11196 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11197 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11198
11199 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11200 fn destroy_child(
11201 &mut self,
11202
11203 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11204
11205 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11206 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11207
11208 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
11209 fn list_children(
11210 &mut self,
11211
11212 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11213
11214 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11215 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11216
11217 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
11218 fn get_resolved_info(
11219 &mut self,
11220
11221 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11222 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11223
11224 fn get_child_output_dictionary_deprecated(
11225 &mut self,
11226
11227 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11228
11229 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11230 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11231
11232 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
11233 fn get_child_output_dictionary(
11234 &mut self,
11235
11236 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11237
11238 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11239 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11240}
11241
11242impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Realm
11243where
11244 ___H: RealmServerHandler<___T> + ::core::marker::Send,
11245 ___T: ::fidl_next::Transport,
11246 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
11247 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11248 Constraint = (),
11249 >,
11250 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
11251 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11252 Constraint = (),
11253 >,
11254 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
11255 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11256 Constraint = (),
11257 >,
11258 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
11259 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11260 Constraint = (),
11261 >,
11262 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
11263 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11264 Constraint = (),
11265 >,
11266 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
11267 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11268 Constraint = (),
11269 >,
11270 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
11271 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11272 Constraint = (),
11273 >,
11274{
11275 async fn on_one_way(
11276 handler: &mut ___H,
11277 mut message: ::fidl_next::Message<___T>,
11278 ) -> ::core::result::Result<
11279 (),
11280 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11281 > {
11282 match *message.header().ordinal {
11283 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11284 }
11285 }
11286
11287 async fn on_two_way(
11288 handler: &mut ___H,
11289 mut message: ::fidl_next::Message<___T>,
11290 responder: ::fidl_next::protocol::Responder<___T>,
11291 ) -> ::core::result::Result<
11292 (),
11293 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11294 > {
11295 match *message.header().ordinal {
11296 8165227925828473216 => {
11297 let responder = ::fidl_next::Responder::from_untyped(responder);
11298
11299 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11300 Ok(decoded) => {
11301 handler
11302 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
11303 .await;
11304 Ok(())
11305 }
11306 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11307 ordinal: 8165227925828473216,
11308 error,
11309 }),
11310 }
11311 }
11312
11313 9194435320863127852 => {
11314 let responder = ::fidl_next::Responder::from_untyped(responder);
11315
11316 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11317 Ok(decoded) => {
11318 handler
11319 .open_exposed_dir(
11320 ::fidl_next::Request::from_decoded(decoded),
11321 responder,
11322 )
11323 .await;
11324 Ok(())
11325 }
11326 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11327 ordinal: 9194435320863127852,
11328 error,
11329 }),
11330 }
11331 }
11332
11333 4892190024503489888 => {
11334 let responder = ::fidl_next::Responder::from_untyped(responder);
11335
11336 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11337 Ok(decoded) => {
11338 handler
11339 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
11340 .await;
11341 Ok(())
11342 }
11343 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11344 ordinal: 4892190024503489888,
11345 error,
11346 }),
11347 }
11348 }
11349
11350 8203529889988252194 => {
11351 let responder = ::fidl_next::Responder::from_untyped(responder);
11352
11353 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11354 Ok(decoded) => {
11355 handler
11356 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
11357 .await;
11358 Ok(())
11359 }
11360 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11361 ordinal: 8203529889988252194,
11362 error,
11363 }),
11364 }
11365 }
11366
11367 7532454435519185057 => {
11368 let responder = ::fidl_next::Responder::from_untyped(responder);
11369
11370 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11371 Ok(decoded) => {
11372 handler
11373 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
11374 .await;
11375 Ok(())
11376 }
11377 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11378 ordinal: 7532454435519185057,
11379 error,
11380 }),
11381 }
11382 }
11383
11384 8308987710372188322 => {
11385 let responder = ::fidl_next::Responder::from_untyped(responder);
11386
11387 handler.get_resolved_info(responder).await;
11388 Ok(())
11389 }
11390
11391 4117516026351534948 => {
11392 let responder = ::fidl_next::Responder::from_untyped(responder);
11393
11394 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11395 Ok(decoded) => {
11396 handler
11397 .get_child_output_dictionary_deprecated(
11398 ::fidl_next::Request::from_decoded(decoded),
11399 responder,
11400 )
11401 .await;
11402 Ok(())
11403 }
11404 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11405 ordinal: 4117516026351534948,
11406 error,
11407 }),
11408 }
11409 }
11410
11411 4781081784078915088 => {
11412 let responder = ::fidl_next::Responder::from_untyped(responder);
11413
11414 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11415 Ok(decoded) => {
11416 handler
11417 .get_child_output_dictionary(
11418 ::fidl_next::Request::from_decoded(decoded),
11419 responder,
11420 )
11421 .await;
11422 Ok(())
11423 }
11424 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11425 ordinal: 4781081784078915088,
11426 error,
11427 }),
11428 }
11429 }
11430
11431 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11432 }
11433 }
11434}
11435
11436impl<___T> RealmClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
11437
11438impl<___H, ___T> RealmLocalClientHandler<___T> for ::fidl_next::Local<___H>
11439where
11440 ___H: RealmClientHandler<___T>,
11441 ___T: ::fidl_next::Transport,
11442{
11443}
11444
11445impl<___H, ___T> RealmLocalServerHandler<___T> for ::fidl_next::Local<___H>
11446where
11447 ___H: RealmServerHandler<___T>,
11448 ___T: ::fidl_next::Transport,
11449{
11450 async fn open_controller(
11451 &mut self,
11452
11453 request: ::fidl_next::Request<realm::OpenController, ___T>,
11454
11455 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11456 ) {
11457 ___H::open_controller(&mut self.0, request, responder).await
11458 }
11459
11460 async fn open_exposed_dir(
11461 &mut self,
11462
11463 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11464
11465 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11466 ) {
11467 ___H::open_exposed_dir(&mut self.0, request, responder).await
11468 }
11469
11470 async fn create_child(
11471 &mut self,
11472
11473 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11474
11475 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11476 ) {
11477 ___H::create_child(&mut self.0, request, responder).await
11478 }
11479
11480 async fn destroy_child(
11481 &mut self,
11482
11483 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11484
11485 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11486 ) {
11487 ___H::destroy_child(&mut self.0, request, responder).await
11488 }
11489
11490 async fn list_children(
11491 &mut self,
11492
11493 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11494
11495 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11496 ) {
11497 ___H::list_children(&mut self.0, request, responder).await
11498 }
11499
11500 async fn get_resolved_info(
11501 &mut self,
11502
11503 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11504 ) {
11505 ___H::get_resolved_info(&mut self.0, responder).await
11506 }
11507
11508 async fn get_child_output_dictionary_deprecated(
11509 &mut self,
11510
11511 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11512
11513 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11514 ) {
11515 ___H::get_child_output_dictionary_deprecated(&mut self.0, request, responder).await
11516 }
11517
11518 async fn get_child_output_dictionary(
11519 &mut self,
11520
11521 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11522
11523 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11524 ) {
11525 ___H::get_child_output_dictionary(&mut self.0, request, responder).await
11526 }
11527}
11528
11529#[derive(PartialEq, Debug)]
11531pub struct StorageAdmin;
11532
11533impl ::fidl_next::Discoverable for StorageAdmin {
11534 const PROTOCOL_NAME: &'static str = "fuchsia.component.StorageAdmin";
11535}
11536
11537#[cfg(target_os = "fuchsia")]
11538impl ::fidl_next::HasTransport for StorageAdmin {
11539 type Transport = ::fidl_next::fuchsia::zx::Channel;
11540}
11541
11542pub mod storage_admin {
11543 pub mod prelude {
11544 pub use crate::{
11545 StorageAdmin, StorageAdminClientHandler, StorageAdminLocalClientHandler,
11546 StorageAdminLocalServerHandler, StorageAdminServerHandler, storage_admin,
11547 };
11548
11549 pub use crate::natural::DeletionError;
11550
11551 pub use crate::natural::Error;
11552
11553 pub use crate::natural::StatusError;
11554
11555 pub use crate::natural::StorageAdminDeleteComponentStorageRequest;
11556
11557 pub use crate::natural::StorageAdminListStorageInRealmRequest;
11558
11559 pub use crate::natural::StorageAdminOpenComponentStorageByIdRequest;
11560
11561 pub use crate::natural::StorageAdminOpenStorageRequest;
11562
11563 pub use crate::natural::StorageAdminDeleteAllStorageContentsResponse;
11564
11565 pub use crate::natural::StorageAdminDeleteComponentStorageResponse;
11566
11567 pub use crate::natural::StorageAdminListStorageInRealmResponse;
11568
11569 pub use crate::natural::StorageAdminOpenComponentStorageByIdResponse;
11570
11571 pub use crate::natural::StorageAdminOpenStorageResponse;
11572
11573 pub use crate::natural::StorageStatus;
11574 }
11575
11576 pub struct OpenStorage;
11577
11578 impl ::fidl_next::Method for OpenStorage {
11579 const ORDINAL: u64 = 7848267339832116087;
11580 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11581 ::fidl_next::protocol::Flexibility::Strict;
11582
11583 type Protocol = crate::StorageAdmin;
11584
11585 type Request = crate::wire::StorageAdminOpenStorageRequest<'static>;
11586 }
11587
11588 impl ::fidl_next::TwoWayMethod for OpenStorage {
11589 type Response = ::fidl_next::wire::Result<
11590 'static,
11591 crate::wire::StorageAdminOpenStorageResponse,
11592 crate::wire::Error,
11593 >;
11594 }
11595
11596 impl<___R> ::fidl_next::Respond<___R> for OpenStorage {
11597 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11598
11599 fn respond(response: ___R) -> Self::Output {
11600 ::core::result::Result::Ok(response)
11601 }
11602 }
11603
11604 impl<___R> ::fidl_next::RespondErr<___R> for OpenStorage {
11605 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11606
11607 fn respond_err(response: ___R) -> Self::Output {
11608 ::core::result::Result::Err(response)
11609 }
11610 }
11611
11612 pub struct ListStorageInRealm;
11613
11614 impl ::fidl_next::Method for ListStorageInRealm {
11615 const ORDINAL: u64 = 8525152599685368827;
11616 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11617 ::fidl_next::protocol::Flexibility::Strict;
11618
11619 type Protocol = crate::StorageAdmin;
11620
11621 type Request = crate::wire::StorageAdminListStorageInRealmRequest<'static>;
11622 }
11623
11624 impl ::fidl_next::TwoWayMethod for ListStorageInRealm {
11625 type Response = ::fidl_next::wire::Result<
11626 'static,
11627 crate::wire::StorageAdminListStorageInRealmResponse,
11628 crate::wire::Error,
11629 >;
11630 }
11631
11632 impl<___R> ::fidl_next::Respond<___R> for ListStorageInRealm {
11633 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11634
11635 fn respond(response: ___R) -> Self::Output {
11636 ::core::result::Result::Ok(response)
11637 }
11638 }
11639
11640 impl<___R> ::fidl_next::RespondErr<___R> for ListStorageInRealm {
11641 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11642
11643 fn respond_err(response: ___R) -> Self::Output {
11644 ::core::result::Result::Err(response)
11645 }
11646 }
11647
11648 pub struct OpenComponentStorageById;
11649
11650 impl ::fidl_next::Method for OpenComponentStorageById {
11651 const ORDINAL: u64 = 5188727505160068593;
11652 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11653 ::fidl_next::protocol::Flexibility::Strict;
11654
11655 type Protocol = crate::StorageAdmin;
11656
11657 type Request = crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>;
11658 }
11659
11660 impl ::fidl_next::TwoWayMethod for OpenComponentStorageById {
11661 type Response = ::fidl_next::wire::Result<
11662 'static,
11663 crate::wire::StorageAdminOpenComponentStorageByIdResponse,
11664 crate::wire::Error,
11665 >;
11666 }
11667
11668 impl<___R> ::fidl_next::Respond<___R> for OpenComponentStorageById {
11669 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11670
11671 fn respond(response: ___R) -> Self::Output {
11672 ::core::result::Result::Ok(response)
11673 }
11674 }
11675
11676 impl<___R> ::fidl_next::RespondErr<___R> for OpenComponentStorageById {
11677 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11678
11679 fn respond_err(response: ___R) -> Self::Output {
11680 ::core::result::Result::Err(response)
11681 }
11682 }
11683
11684 pub struct DeleteComponentStorage;
11685
11686 impl ::fidl_next::Method for DeleteComponentStorage {
11687 const ORDINAL: u64 = 1618975681517712474;
11688 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11689 ::fidl_next::protocol::Flexibility::Strict;
11690
11691 type Protocol = crate::StorageAdmin;
11692
11693 type Request = crate::wire::StorageAdminDeleteComponentStorageRequest<'static>;
11694 }
11695
11696 impl ::fidl_next::TwoWayMethod for DeleteComponentStorage {
11697 type Response = ::fidl_next::wire::Result<
11698 'static,
11699 crate::wire::StorageAdminDeleteComponentStorageResponse,
11700 crate::wire::Error,
11701 >;
11702 }
11703
11704 impl<___R> ::fidl_next::Respond<___R> for DeleteComponentStorage {
11705 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11706
11707 fn respond(response: ___R) -> Self::Output {
11708 ::core::result::Result::Ok(response)
11709 }
11710 }
11711
11712 impl<___R> ::fidl_next::RespondErr<___R> for DeleteComponentStorage {
11713 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11714
11715 fn respond_err(response: ___R) -> Self::Output {
11716 ::core::result::Result::Err(response)
11717 }
11718 }
11719
11720 pub struct GetStatus;
11721
11722 impl ::fidl_next::Method for GetStatus {
11723 const ORDINAL: u64 = 8586643915409794760;
11724 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11725 ::fidl_next::protocol::Flexibility::Strict;
11726
11727 type Protocol = crate::StorageAdmin;
11728
11729 type Request = ::fidl_next::wire::EmptyMessageBody;
11730 }
11731
11732 impl ::fidl_next::TwoWayMethod for GetStatus {
11733 type Response = ::fidl_next::wire::Result<
11734 'static,
11735 crate::wire::StorageStatus<'static>,
11736 crate::wire::StatusError,
11737 >;
11738 }
11739
11740 impl<___R> ::fidl_next::Respond<___R> for GetStatus {
11741 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11742
11743 fn respond(response: ___R) -> Self::Output {
11744 ::core::result::Result::Ok(response)
11745 }
11746 }
11747
11748 impl<___R> ::fidl_next::RespondErr<___R> for GetStatus {
11749 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11750
11751 fn respond_err(response: ___R) -> Self::Output {
11752 ::core::result::Result::Err(response)
11753 }
11754 }
11755
11756 pub struct DeleteAllStorageContents;
11757
11758 impl ::fidl_next::Method for DeleteAllStorageContents {
11759 const ORDINAL: u64 = 3380374508900862683;
11760 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11761 ::fidl_next::protocol::Flexibility::Strict;
11762
11763 type Protocol = crate::StorageAdmin;
11764
11765 type Request = ::fidl_next::wire::EmptyMessageBody;
11766 }
11767
11768 impl ::fidl_next::TwoWayMethod for DeleteAllStorageContents {
11769 type Response = ::fidl_next::wire::Result<
11770 'static,
11771 crate::wire::StorageAdminDeleteAllStorageContentsResponse,
11772 crate::wire::DeletionError,
11773 >;
11774 }
11775
11776 impl<___R> ::fidl_next::Respond<___R> for DeleteAllStorageContents {
11777 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11778
11779 fn respond(response: ___R) -> Self::Output {
11780 ::core::result::Result::Ok(response)
11781 }
11782 }
11783
11784 impl<___R> ::fidl_next::RespondErr<___R> for DeleteAllStorageContents {
11785 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11786
11787 fn respond_err(response: ___R) -> Self::Output {
11788 ::core::result::Result::Err(response)
11789 }
11790 }
11791
11792 mod ___detail {
11793 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageAdmin
11794 where
11795 ___T: ::fidl_next::Transport,
11796 {
11797 type Client = StorageAdminClient<___T>;
11798 type Server = StorageAdminServer<___T>;
11799 }
11800
11801 #[repr(transparent)]
11803 pub struct StorageAdminClient<___T: ::fidl_next::Transport> {
11804 #[allow(dead_code)]
11805 client: ::fidl_next::protocol::Client<___T>,
11806 }
11807
11808 impl<___T> StorageAdminClient<___T>
11809 where
11810 ___T: ::fidl_next::Transport,
11811 {
11812 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
11813 pub fn open_storage(
11814 &self,
11815
11816 relative_moniker: impl ::fidl_next::Encode<
11817 ::fidl_next::wire::String<'static>,
11818 <___T as ::fidl_next::Transport>::SendBuffer,
11819 >,
11820
11821 object: impl ::fidl_next::Encode<
11822 ::fidl_next::ServerEnd<
11823 ::fidl_next_fuchsia_io::Node,
11824 ::fidl_next::wire::fuchsia::Channel,
11825 >,
11826 <___T as ::fidl_next::Transport>::SendBuffer,
11827 >,
11828 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
11829 where
11830 <___T as ::fidl_next::Transport>::SendBuffer:
11831 ::fidl_next::encoder::InternalHandleEncoder,
11832 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11833 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11834 {
11835 self.open_storage_with(crate::generic::StorageAdminOpenStorageRequest {
11836 relative_moniker,
11837
11838 object,
11839 })
11840 }
11841
11842 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
11843 pub fn open_storage_with<___R>(
11844 &self,
11845 request: ___R,
11846 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
11847 where
11848 ___R: ::fidl_next::Encode<
11849 crate::wire::StorageAdminOpenStorageRequest<'static>,
11850 <___T as ::fidl_next::Transport>::SendBuffer,
11851 >,
11852 {
11853 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11854 7848267339832116087,
11855 <super::OpenStorage as ::fidl_next::Method>::FLEXIBILITY,
11856 request,
11857 ))
11858 }
11859
11860 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
11861 pub fn list_storage_in_realm(
11862 &self,
11863
11864 relative_moniker: impl ::fidl_next::Encode<
11865 ::fidl_next::wire::String<'static>,
11866 <___T as ::fidl_next::Transport>::SendBuffer,
11867 >,
11868
11869 iterator: impl ::fidl_next::Encode<
11870 ::fidl_next::ServerEnd<
11871 crate::StorageIterator,
11872 ::fidl_next::wire::fuchsia::Channel,
11873 >,
11874 <___T as ::fidl_next::Transport>::SendBuffer,
11875 >,
11876 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
11877 where
11878 <___T as ::fidl_next::Transport>::SendBuffer:
11879 ::fidl_next::encoder::InternalHandleEncoder,
11880 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11881 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11882 {
11883 self.list_storage_in_realm_with(
11884 crate::generic::StorageAdminListStorageInRealmRequest {
11885 relative_moniker,
11886
11887 iterator,
11888 },
11889 )
11890 }
11891
11892 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
11893 pub fn list_storage_in_realm_with<___R>(
11894 &self,
11895 request: ___R,
11896 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
11897 where
11898 ___R: ::fidl_next::Encode<
11899 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
11900 <___T as ::fidl_next::Transport>::SendBuffer,
11901 >,
11902 {
11903 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11904 8525152599685368827,
11905 <super::ListStorageInRealm as ::fidl_next::Method>::FLEXIBILITY,
11906 request,
11907 ))
11908 }
11909
11910 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
11911 pub fn open_component_storage_by_id(
11912 &self,
11913
11914 id: impl ::fidl_next::Encode<
11915 ::fidl_next::wire::String<'static>,
11916 <___T as ::fidl_next::Transport>::SendBuffer,
11917 >,
11918
11919 object: impl ::fidl_next::Encode<
11920 ::fidl_next::ServerEnd<
11921 ::fidl_next_fuchsia_io::Node,
11922 ::fidl_next::wire::fuchsia::Channel,
11923 >,
11924 <___T as ::fidl_next::Transport>::SendBuffer,
11925 >,
11926 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
11927 where
11928 <___T as ::fidl_next::Transport>::SendBuffer:
11929 ::fidl_next::encoder::InternalHandleEncoder,
11930 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11931 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11932 {
11933 self.open_component_storage_by_id_with(
11934 crate::generic::StorageAdminOpenComponentStorageByIdRequest { id, object },
11935 )
11936 }
11937
11938 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
11939 pub fn open_component_storage_by_id_with<___R>(
11940 &self,
11941 request: ___R,
11942 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
11943 where
11944 ___R: ::fidl_next::Encode<
11945 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
11946 <___T as ::fidl_next::Transport>::SendBuffer,
11947 >,
11948 {
11949 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11950 5188727505160068593,
11951 <super::OpenComponentStorageById as ::fidl_next::Method>::FLEXIBILITY,
11952 request,
11953 ))
11954 }
11955
11956 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
11957 pub fn delete_component_storage(
11958 &self,
11959
11960 relative_moniker: impl ::fidl_next::Encode<
11961 ::fidl_next::wire::String<'static>,
11962 <___T as ::fidl_next::Transport>::SendBuffer,
11963 >,
11964 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
11965 where
11966 <___T as ::fidl_next::Transport>::SendBuffer:
11967 ::fidl_next::encoder::InternalHandleEncoder,
11968 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11969 {
11970 self.delete_component_storage_with(
11971 crate::generic::StorageAdminDeleteComponentStorageRequest { relative_moniker },
11972 )
11973 }
11974
11975 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
11976 pub fn delete_component_storage_with<___R>(
11977 &self,
11978 request: ___R,
11979 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
11980 where
11981 ___R: ::fidl_next::Encode<
11982 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
11983 <___T as ::fidl_next::Transport>::SendBuffer,
11984 >,
11985 {
11986 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11987 1618975681517712474,
11988 <super::DeleteComponentStorage as ::fidl_next::Method>::FLEXIBILITY,
11989 request,
11990 ))
11991 }
11992
11993 #[doc = " Get the current status of the storage.\n"]
11994 pub fn get_status(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetStatus, ___T> {
11995 ::fidl_next::TwoWayFuture::from_untyped(
11996 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11997 8586643915409794760,
11998 <super::GetStatus as ::fidl_next::Method>::FLEXIBILITY,
11999 (),
12000 ),
12001 )
12002 }
12003
12004 #[doc = " Deletes the contents of all the storage. Storage directories are\n retained so any components using storage will be able to continue using\n it to create new files and directories.\n\n Returns Error::INTERNAL only if no storage at all could be cleared.\n Returns successfully even if some errors happen during the deletion\n progress.\n"]
12005 pub fn delete_all_storage_contents(
12006 &self,
12007 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteAllStorageContents, ___T> {
12008 ::fidl_next::TwoWayFuture::from_untyped(
12009 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12010 3380374508900862683,
12011 <super::DeleteAllStorageContents as ::fidl_next::Method>::FLEXIBILITY,
12012 (),
12013 ),
12014 )
12015 }
12016 }
12017
12018 #[repr(transparent)]
12020 pub struct StorageAdminServer<___T: ::fidl_next::Transport> {
12021 server: ::fidl_next::protocol::Server<___T>,
12022 }
12023
12024 impl<___T> StorageAdminServer<___T> where ___T: ::fidl_next::Transport {}
12025 }
12026}
12027
12028#[diagnostic::on_unimplemented(
12029 note = "If {Self} implements the non-local StorageAdminClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12030)]
12031
12032pub trait StorageAdminLocalClientHandler<
12036 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12037 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12038>
12039{
12040}
12041
12042impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageAdmin
12043where
12044 ___H: StorageAdminLocalClientHandler<___T>,
12045 ___T: ::fidl_next::Transport,
12046{
12047 async fn on_event(
12048 handler: &mut ___H,
12049 mut message: ::fidl_next::Message<___T>,
12050 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12051 match *message.header().ordinal {
12052 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12053 }
12054 }
12055}
12056
12057#[diagnostic::on_unimplemented(
12058 note = "If {Self} implements the non-local StorageAdminServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12059)]
12060
12061pub trait StorageAdminLocalServerHandler<
12065 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12066 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12067>
12068{
12069 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
12070 fn open_storage(
12071 &mut self,
12072
12073 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12074
12075 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12076 ) -> impl ::core::future::Future<Output = ()>;
12077
12078 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
12079 fn list_storage_in_realm(
12080 &mut self,
12081
12082 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12083
12084 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12085 ) -> impl ::core::future::Future<Output = ()>;
12086
12087 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
12088 fn open_component_storage_by_id(
12089 &mut self,
12090
12091 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12092
12093 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12094 ) -> impl ::core::future::Future<Output = ()>;
12095
12096 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
12097 fn delete_component_storage(
12098 &mut self,
12099
12100 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12101
12102 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12103 ) -> impl ::core::future::Future<Output = ()>;
12104
12105 #[doc = " Get the current status of the storage.\n"]
12106 fn get_status(
12107 &mut self,
12108
12109 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12110 ) -> impl ::core::future::Future<Output = ()>;
12111
12112 #[doc = " Deletes the contents of all the storage. Storage directories are\n retained so any components using storage will be able to continue using\n it to create new files and directories.\n\n Returns Error::INTERNAL only if no storage at all could be cleared.\n Returns successfully even if some errors happen during the deletion\n progress.\n"]
12113 fn delete_all_storage_contents(
12114 &mut self,
12115
12116 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12117 ) -> impl ::core::future::Future<Output = ()>;
12118}
12119
12120impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageAdmin
12121where
12122 ___H: StorageAdminLocalServerHandler<___T>,
12123 ___T: ::fidl_next::Transport,
12124 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
12125 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12126 Constraint = (),
12127 >,
12128 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
12129 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12130 Constraint = (),
12131 >,
12132 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
12133 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12134 Constraint = (),
12135 >,
12136 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
12137 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12138 Constraint = (),
12139 >,
12140{
12141 async fn on_one_way(
12142 handler: &mut ___H,
12143 mut message: ::fidl_next::Message<___T>,
12144 ) -> ::core::result::Result<
12145 (),
12146 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12147 > {
12148 match *message.header().ordinal {
12149 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12150 }
12151 }
12152
12153 async fn on_two_way(
12154 handler: &mut ___H,
12155 mut message: ::fidl_next::Message<___T>,
12156 responder: ::fidl_next::protocol::Responder<___T>,
12157 ) -> ::core::result::Result<
12158 (),
12159 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12160 > {
12161 match *message.header().ordinal {
12162 7848267339832116087 => {
12163 let responder = ::fidl_next::Responder::from_untyped(responder);
12164
12165 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12166 Ok(decoded) => {
12167 handler
12168 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
12169 .await;
12170 Ok(())
12171 }
12172 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12173 ordinal: 7848267339832116087,
12174 error,
12175 }),
12176 }
12177 }
12178
12179 8525152599685368827 => {
12180 let responder = ::fidl_next::Responder::from_untyped(responder);
12181
12182 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12183 Ok(decoded) => {
12184 handler
12185 .list_storage_in_realm(
12186 ::fidl_next::Request::from_decoded(decoded),
12187 responder,
12188 )
12189 .await;
12190 Ok(())
12191 }
12192 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12193 ordinal: 8525152599685368827,
12194 error,
12195 }),
12196 }
12197 }
12198
12199 5188727505160068593 => {
12200 let responder = ::fidl_next::Responder::from_untyped(responder);
12201
12202 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12203 Ok(decoded) => {
12204 handler
12205 .open_component_storage_by_id(
12206 ::fidl_next::Request::from_decoded(decoded),
12207 responder,
12208 )
12209 .await;
12210 Ok(())
12211 }
12212 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12213 ordinal: 5188727505160068593,
12214 error,
12215 }),
12216 }
12217 }
12218
12219 1618975681517712474 => {
12220 let responder = ::fidl_next::Responder::from_untyped(responder);
12221
12222 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12223 Ok(decoded) => {
12224 handler
12225 .delete_component_storage(
12226 ::fidl_next::Request::from_decoded(decoded),
12227 responder,
12228 )
12229 .await;
12230 Ok(())
12231 }
12232 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12233 ordinal: 1618975681517712474,
12234 error,
12235 }),
12236 }
12237 }
12238
12239 8586643915409794760 => {
12240 let responder = ::fidl_next::Responder::from_untyped(responder);
12241
12242 handler.get_status(responder).await;
12243 Ok(())
12244 }
12245
12246 3380374508900862683 => {
12247 let responder = ::fidl_next::Responder::from_untyped(responder);
12248
12249 handler.delete_all_storage_contents(responder).await;
12250 Ok(())
12251 }
12252
12253 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12254 }
12255 }
12256}
12257
12258pub trait StorageAdminClientHandler<
12262 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12263 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12264>
12265{
12266}
12267
12268impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageAdmin
12269where
12270 ___H: StorageAdminClientHandler<___T> + ::core::marker::Send,
12271 ___T: ::fidl_next::Transport,
12272{
12273 async fn on_event(
12274 handler: &mut ___H,
12275 mut message: ::fidl_next::Message<___T>,
12276 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12277 match *message.header().ordinal {
12278 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12279 }
12280 }
12281}
12282
12283pub trait StorageAdminServerHandler<
12287 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12288 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12289>
12290{
12291 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
12292 fn open_storage(
12293 &mut self,
12294
12295 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12296
12297 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12298 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12299
12300 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
12301 fn list_storage_in_realm(
12302 &mut self,
12303
12304 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12305
12306 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12307 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12308
12309 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
12310 fn open_component_storage_by_id(
12311 &mut self,
12312
12313 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12314
12315 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12316 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12317
12318 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
12319 fn delete_component_storage(
12320 &mut self,
12321
12322 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12323
12324 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12325 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12326
12327 #[doc = " Get the current status of the storage.\n"]
12328 fn get_status(
12329 &mut self,
12330
12331 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12332 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12333
12334 #[doc = " Deletes the contents of all the storage. Storage directories are\n retained so any components using storage will be able to continue using\n it to create new files and directories.\n\n Returns Error::INTERNAL only if no storage at all could be cleared.\n Returns successfully even if some errors happen during the deletion\n progress.\n"]
12335 fn delete_all_storage_contents(
12336 &mut self,
12337
12338 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12339 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12340}
12341
12342impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageAdmin
12343where
12344 ___H: StorageAdminServerHandler<___T> + ::core::marker::Send,
12345 ___T: ::fidl_next::Transport,
12346 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
12347 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12348 Constraint = (),
12349 >,
12350 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
12351 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12352 Constraint = (),
12353 >,
12354 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
12355 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12356 Constraint = (),
12357 >,
12358 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
12359 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12360 Constraint = (),
12361 >,
12362{
12363 async fn on_one_way(
12364 handler: &mut ___H,
12365 mut message: ::fidl_next::Message<___T>,
12366 ) -> ::core::result::Result<
12367 (),
12368 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12369 > {
12370 match *message.header().ordinal {
12371 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12372 }
12373 }
12374
12375 async fn on_two_way(
12376 handler: &mut ___H,
12377 mut message: ::fidl_next::Message<___T>,
12378 responder: ::fidl_next::protocol::Responder<___T>,
12379 ) -> ::core::result::Result<
12380 (),
12381 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12382 > {
12383 match *message.header().ordinal {
12384 7848267339832116087 => {
12385 let responder = ::fidl_next::Responder::from_untyped(responder);
12386
12387 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12388 Ok(decoded) => {
12389 handler
12390 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
12391 .await;
12392 Ok(())
12393 }
12394 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12395 ordinal: 7848267339832116087,
12396 error,
12397 }),
12398 }
12399 }
12400
12401 8525152599685368827 => {
12402 let responder = ::fidl_next::Responder::from_untyped(responder);
12403
12404 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12405 Ok(decoded) => {
12406 handler
12407 .list_storage_in_realm(
12408 ::fidl_next::Request::from_decoded(decoded),
12409 responder,
12410 )
12411 .await;
12412 Ok(())
12413 }
12414 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12415 ordinal: 8525152599685368827,
12416 error,
12417 }),
12418 }
12419 }
12420
12421 5188727505160068593 => {
12422 let responder = ::fidl_next::Responder::from_untyped(responder);
12423
12424 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12425 Ok(decoded) => {
12426 handler
12427 .open_component_storage_by_id(
12428 ::fidl_next::Request::from_decoded(decoded),
12429 responder,
12430 )
12431 .await;
12432 Ok(())
12433 }
12434 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12435 ordinal: 5188727505160068593,
12436 error,
12437 }),
12438 }
12439 }
12440
12441 1618975681517712474 => {
12442 let responder = ::fidl_next::Responder::from_untyped(responder);
12443
12444 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12445 Ok(decoded) => {
12446 handler
12447 .delete_component_storage(
12448 ::fidl_next::Request::from_decoded(decoded),
12449 responder,
12450 )
12451 .await;
12452 Ok(())
12453 }
12454 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12455 ordinal: 1618975681517712474,
12456 error,
12457 }),
12458 }
12459 }
12460
12461 8586643915409794760 => {
12462 let responder = ::fidl_next::Responder::from_untyped(responder);
12463
12464 handler.get_status(responder).await;
12465 Ok(())
12466 }
12467
12468 3380374508900862683 => {
12469 let responder = ::fidl_next::Responder::from_untyped(responder);
12470
12471 handler.delete_all_storage_contents(responder).await;
12472 Ok(())
12473 }
12474
12475 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12476 }
12477 }
12478}
12479
12480impl<___T> StorageAdminClientHandler<___T> for ::fidl_next::IgnoreEvents where
12481 ___T: ::fidl_next::Transport
12482{
12483}
12484
12485impl<___H, ___T> StorageAdminLocalClientHandler<___T> for ::fidl_next::Local<___H>
12486where
12487 ___H: StorageAdminClientHandler<___T>,
12488 ___T: ::fidl_next::Transport,
12489{
12490}
12491
12492impl<___H, ___T> StorageAdminLocalServerHandler<___T> for ::fidl_next::Local<___H>
12493where
12494 ___H: StorageAdminServerHandler<___T>,
12495 ___T: ::fidl_next::Transport,
12496{
12497 async fn open_storage(
12498 &mut self,
12499
12500 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12501
12502 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12503 ) {
12504 ___H::open_storage(&mut self.0, request, responder).await
12505 }
12506
12507 async fn list_storage_in_realm(
12508 &mut self,
12509
12510 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12511
12512 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12513 ) {
12514 ___H::list_storage_in_realm(&mut self.0, request, responder).await
12515 }
12516
12517 async fn open_component_storage_by_id(
12518 &mut self,
12519
12520 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12521
12522 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12523 ) {
12524 ___H::open_component_storage_by_id(&mut self.0, request, responder).await
12525 }
12526
12527 async fn delete_component_storage(
12528 &mut self,
12529
12530 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12531
12532 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12533 ) {
12534 ___H::delete_component_storage(&mut self.0, request, responder).await
12535 }
12536
12537 async fn get_status(
12538 &mut self,
12539
12540 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12541 ) {
12542 ___H::get_status(&mut self.0, responder).await
12543 }
12544
12545 async fn delete_all_storage_contents(
12546 &mut self,
12547
12548 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12549 ) {
12550 ___H::delete_all_storage_contents(&mut self.0, responder).await
12551 }
12552}
12553
12554pub use fidl_next_common_fuchsia_component::*;