1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[doc = " Describes assets which may be updated. Each asset has 3 versions, each tied to a particular\n configuration.\n"]
8 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9 #[repr(u32)]
10 pub enum Asset {
11 Kernel = 1,
12 VerifiedBootMetadata = 2,
13 }
14 impl ::core::convert::TryFrom<u32> for Asset {
15 type Error = ::fidl_next::UnknownStrictEnumMemberError;
16 fn try_from(
17 value: u32,
18 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
19 match value {
20 1 => Ok(Self::Kernel),
21 2 => Ok(Self::VerifiedBootMetadata),
22
23 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
24 }
25 }
26 }
27
28 impl ::std::convert::From<Asset> for u32 {
29 fn from(value: Asset) -> Self {
30 match value {
31 Asset::Kernel => 1,
32 Asset::VerifiedBootMetadata => 2,
33 }
34 }
35 }
36
37 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Asset, ___E> for Asset
38 where
39 ___E: ?Sized,
40 {
41 #[inline]
42 fn encode(
43 self,
44 encoder: &mut ___E,
45 out: &mut ::core::mem::MaybeUninit<crate::wire::Asset>,
46 _: (),
47 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
48 ::fidl_next::Encode::encode(&self, encoder, out, ())
49 }
50 }
51
52 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Asset, ___E> for &'a Asset
53 where
54 ___E: ?Sized,
55 {
56 #[inline]
57 fn encode(
58 self,
59 encoder: &mut ___E,
60 out: &mut ::core::mem::MaybeUninit<crate::wire::Asset>,
61 _: (),
62 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
63 ::fidl_next::munge!(let crate::wire::Asset { value } = out);
64 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
65 Asset::Kernel => 1,
66
67 Asset::VerifiedBootMetadata => 2,
68 }));
69
70 Ok(())
71 }
72 }
73
74 impl ::core::convert::From<crate::wire::Asset> for Asset {
75 fn from(wire: crate::wire::Asset) -> Self {
76 match u32::from(wire.value) {
77 1 => Self::Kernel,
78
79 2 => Self::VerifiedBootMetadata,
80
81 _ => unsafe { ::core::hint::unreachable_unchecked() },
82 }
83 }
84 }
85
86 impl ::fidl_next::FromWire<crate::wire::Asset> for Asset {
87 #[inline]
88 fn from_wire(wire: crate::wire::Asset) -> Self {
89 Self::from(wire)
90 }
91 }
92
93 impl ::fidl_next::FromWireRef<crate::wire::Asset> for Asset {
94 #[inline]
95 fn from_wire_ref(wire: &crate::wire::Asset) -> Self {
96 Self::from(*wire)
97 }
98 }
99
100 #[doc = " Describes the version of an asset.\n"]
101 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
102 #[repr(u32)]
103 pub enum Configuration {
104 A = 1,
105 B = 2,
106 Recovery = 3,
107 }
108 impl ::core::convert::TryFrom<u32> for Configuration {
109 type Error = ::fidl_next::UnknownStrictEnumMemberError;
110 fn try_from(
111 value: u32,
112 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
113 match value {
114 1 => Ok(Self::A),
115 2 => Ok(Self::B),
116 3 => Ok(Self::Recovery),
117
118 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
119 }
120 }
121 }
122
123 impl ::std::convert::From<Configuration> for u32 {
124 fn from(value: Configuration) -> Self {
125 match value {
126 Configuration::A => 1,
127 Configuration::B => 2,
128 Configuration::Recovery => 3,
129 }
130 }
131 }
132
133 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Configuration, ___E> for Configuration
134 where
135 ___E: ?Sized,
136 {
137 #[inline]
138 fn encode(
139 self,
140 encoder: &mut ___E,
141 out: &mut ::core::mem::MaybeUninit<crate::wire::Configuration>,
142 _: (),
143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
144 ::fidl_next::Encode::encode(&self, encoder, out, ())
145 }
146 }
147
148 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Configuration, ___E> for &'a Configuration
149 where
150 ___E: ?Sized,
151 {
152 #[inline]
153 fn encode(
154 self,
155 encoder: &mut ___E,
156 out: &mut ::core::mem::MaybeUninit<crate::wire::Configuration>,
157 _: (),
158 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
159 ::fidl_next::munge!(let crate::wire::Configuration { value } = out);
160 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
161 Configuration::A => 1,
162
163 Configuration::B => 2,
164
165 Configuration::Recovery => 3,
166 }));
167
168 Ok(())
169 }
170 }
171
172 impl ::core::convert::From<crate::wire::Configuration> for Configuration {
173 fn from(wire: crate::wire::Configuration) -> Self {
174 match u32::from(wire.value) {
175 1 => Self::A,
176
177 2 => Self::B,
178
179 3 => Self::Recovery,
180
181 _ => unsafe { ::core::hint::unreachable_unchecked() },
182 }
183 }
184 }
185
186 impl ::fidl_next::FromWire<crate::wire::Configuration> for Configuration {
187 #[inline]
188 fn from_wire(wire: crate::wire::Configuration) -> Self {
189 Self::from(wire)
190 }
191 }
192
193 impl ::fidl_next::FromWireRef<crate::wire::Configuration> for Configuration {
194 #[inline]
195 fn from_wire_ref(wire: &crate::wire::Configuration) -> Self {
196 Self::from(*wire)
197 }
198 }
199
200 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
201 #[repr(C)]
202 pub struct BootManagerQueryCurrentConfigurationResponse {
203 pub configuration: crate::natural::Configuration,
204 }
205
206 unsafe impl<___E>
207 ::fidl_next::Encode<crate::wire::BootManagerQueryCurrentConfigurationResponse, ___E>
208 for BootManagerQueryCurrentConfigurationResponse
209 where
210 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
211 {
212 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
213 Self,
214 crate::wire::BootManagerQueryCurrentConfigurationResponse,
215 > = unsafe {
216 ::fidl_next::CopyOptimization::enable_if(
217 true && <crate::natural::Configuration as ::fidl_next::Encode<
218 crate::wire::Configuration,
219 ___E,
220 >>::COPY_OPTIMIZATION
221 .is_enabled(),
222 )
223 };
224
225 #[inline]
226 fn encode(
227 self,
228 encoder_: &mut ___E,
229 out_: &mut ::core::mem::MaybeUninit<
230 crate::wire::BootManagerQueryCurrentConfigurationResponse,
231 >,
232 _: (),
233 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
234 ::fidl_next::munge! {
235 let crate::wire::BootManagerQueryCurrentConfigurationResponse {
236 configuration,
237
238 } = out_;
239 }
240
241 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
242
243 let mut _field =
244 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
245
246 Ok(())
247 }
248 }
249
250 unsafe impl<'a, ___E>
251 ::fidl_next::Encode<crate::wire::BootManagerQueryCurrentConfigurationResponse, ___E>
252 for &'a BootManagerQueryCurrentConfigurationResponse
253 where
254 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
255 {
256 #[inline]
257 fn encode(
258 self,
259 encoder_: &mut ___E,
260 out_: &mut ::core::mem::MaybeUninit<
261 crate::wire::BootManagerQueryCurrentConfigurationResponse,
262 >,
263 _: (),
264 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
265 ::fidl_next::munge! {
266 let crate::wire::BootManagerQueryCurrentConfigurationResponse {
267 configuration,
268
269 } = out_;
270 }
271
272 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
273
274 let mut _field =
275 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
276
277 Ok(())
278 }
279 }
280
281 unsafe impl<___E>
282 ::fidl_next::EncodeOption<
283 ::fidl_next::wire::Box<
284 'static,
285 crate::wire::BootManagerQueryCurrentConfigurationResponse,
286 >,
287 ___E,
288 > for BootManagerQueryCurrentConfigurationResponse
289 where
290 ___E: ::fidl_next::Encoder + ?Sized,
291 BootManagerQueryCurrentConfigurationResponse:
292 ::fidl_next::Encode<crate::wire::BootManagerQueryCurrentConfigurationResponse, ___E>,
293 {
294 #[inline]
295 fn encode_option(
296 this: ::core::option::Option<Self>,
297 encoder: &mut ___E,
298 out: &mut ::core::mem::MaybeUninit<
299 ::fidl_next::wire::Box<
300 'static,
301 crate::wire::BootManagerQueryCurrentConfigurationResponse,
302 >,
303 >,
304 _: (),
305 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
306 if let Some(inner) = this {
307 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
308 ::fidl_next::wire::Box::encode_present(out);
309 } else {
310 ::fidl_next::wire::Box::encode_absent(out);
311 }
312
313 Ok(())
314 }
315 }
316
317 unsafe impl<'a, ___E>
318 ::fidl_next::EncodeOption<
319 ::fidl_next::wire::Box<
320 'static,
321 crate::wire::BootManagerQueryCurrentConfigurationResponse,
322 >,
323 ___E,
324 > for &'a BootManagerQueryCurrentConfigurationResponse
325 where
326 ___E: ::fidl_next::Encoder + ?Sized,
327 &'a BootManagerQueryCurrentConfigurationResponse:
328 ::fidl_next::Encode<crate::wire::BootManagerQueryCurrentConfigurationResponse, ___E>,
329 {
330 #[inline]
331 fn encode_option(
332 this: ::core::option::Option<Self>,
333 encoder: &mut ___E,
334 out: &mut ::core::mem::MaybeUninit<
335 ::fidl_next::wire::Box<
336 'static,
337 crate::wire::BootManagerQueryCurrentConfigurationResponse,
338 >,
339 >,
340 _: (),
341 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
342 if let Some(inner) = this {
343 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
344 ::fidl_next::wire::Box::encode_present(out);
345 } else {
346 ::fidl_next::wire::Box::encode_absent(out);
347 }
348
349 Ok(())
350 }
351 }
352
353 impl ::fidl_next::FromWire<crate::wire::BootManagerQueryCurrentConfigurationResponse>
354 for BootManagerQueryCurrentConfigurationResponse
355 {
356 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
357 crate::wire::BootManagerQueryCurrentConfigurationResponse,
358 Self,
359 > = unsafe {
360 ::fidl_next::CopyOptimization::enable_if(
361 true && <crate::natural::Configuration as ::fidl_next::FromWire<
362 crate::wire::Configuration,
363 >>::COPY_OPTIMIZATION
364 .is_enabled(),
365 )
366 };
367
368 #[inline]
369 fn from_wire(wire: crate::wire::BootManagerQueryCurrentConfigurationResponse) -> Self {
370 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
371 }
372 }
373
374 impl ::fidl_next::FromWireRef<crate::wire::BootManagerQueryCurrentConfigurationResponse>
375 for BootManagerQueryCurrentConfigurationResponse
376 {
377 #[inline]
378 fn from_wire_ref(wire: &crate::wire::BootManagerQueryCurrentConfigurationResponse) -> Self {
379 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
380 }
381 }
382
383 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
384 #[repr(C)]
385 pub struct BootManagerQueryActiveConfigurationResponse {
386 pub configuration: crate::natural::Configuration,
387 }
388
389 unsafe impl<___E>
390 ::fidl_next::Encode<crate::wire::BootManagerQueryActiveConfigurationResponse, ___E>
391 for BootManagerQueryActiveConfigurationResponse
392 where
393 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
394 {
395 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
396 Self,
397 crate::wire::BootManagerQueryActiveConfigurationResponse,
398 > = unsafe {
399 ::fidl_next::CopyOptimization::enable_if(
400 true && <crate::natural::Configuration as ::fidl_next::Encode<
401 crate::wire::Configuration,
402 ___E,
403 >>::COPY_OPTIMIZATION
404 .is_enabled(),
405 )
406 };
407
408 #[inline]
409 fn encode(
410 self,
411 encoder_: &mut ___E,
412 out_: &mut ::core::mem::MaybeUninit<
413 crate::wire::BootManagerQueryActiveConfigurationResponse,
414 >,
415 _: (),
416 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
417 ::fidl_next::munge! {
418 let crate::wire::BootManagerQueryActiveConfigurationResponse {
419 configuration,
420
421 } = out_;
422 }
423
424 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
425
426 let mut _field =
427 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
428
429 Ok(())
430 }
431 }
432
433 unsafe impl<'a, ___E>
434 ::fidl_next::Encode<crate::wire::BootManagerQueryActiveConfigurationResponse, ___E>
435 for &'a BootManagerQueryActiveConfigurationResponse
436 where
437 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
438 {
439 #[inline]
440 fn encode(
441 self,
442 encoder_: &mut ___E,
443 out_: &mut ::core::mem::MaybeUninit<
444 crate::wire::BootManagerQueryActiveConfigurationResponse,
445 >,
446 _: (),
447 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
448 ::fidl_next::munge! {
449 let crate::wire::BootManagerQueryActiveConfigurationResponse {
450 configuration,
451
452 } = out_;
453 }
454
455 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
456
457 let mut _field =
458 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
459
460 Ok(())
461 }
462 }
463
464 unsafe impl<___E>
465 ::fidl_next::EncodeOption<
466 ::fidl_next::wire::Box<
467 'static,
468 crate::wire::BootManagerQueryActiveConfigurationResponse,
469 >,
470 ___E,
471 > for BootManagerQueryActiveConfigurationResponse
472 where
473 ___E: ::fidl_next::Encoder + ?Sized,
474 BootManagerQueryActiveConfigurationResponse:
475 ::fidl_next::Encode<crate::wire::BootManagerQueryActiveConfigurationResponse, ___E>,
476 {
477 #[inline]
478 fn encode_option(
479 this: ::core::option::Option<Self>,
480 encoder: &mut ___E,
481 out: &mut ::core::mem::MaybeUninit<
482 ::fidl_next::wire::Box<
483 'static,
484 crate::wire::BootManagerQueryActiveConfigurationResponse,
485 >,
486 >,
487 _: (),
488 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
489 if let Some(inner) = this {
490 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
491 ::fidl_next::wire::Box::encode_present(out);
492 } else {
493 ::fidl_next::wire::Box::encode_absent(out);
494 }
495
496 Ok(())
497 }
498 }
499
500 unsafe impl<'a, ___E>
501 ::fidl_next::EncodeOption<
502 ::fidl_next::wire::Box<
503 'static,
504 crate::wire::BootManagerQueryActiveConfigurationResponse,
505 >,
506 ___E,
507 > for &'a BootManagerQueryActiveConfigurationResponse
508 where
509 ___E: ::fidl_next::Encoder + ?Sized,
510 &'a BootManagerQueryActiveConfigurationResponse:
511 ::fidl_next::Encode<crate::wire::BootManagerQueryActiveConfigurationResponse, ___E>,
512 {
513 #[inline]
514 fn encode_option(
515 this: ::core::option::Option<Self>,
516 encoder: &mut ___E,
517 out: &mut ::core::mem::MaybeUninit<
518 ::fidl_next::wire::Box<
519 'static,
520 crate::wire::BootManagerQueryActiveConfigurationResponse,
521 >,
522 >,
523 _: (),
524 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
525 if let Some(inner) = this {
526 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
527 ::fidl_next::wire::Box::encode_present(out);
528 } else {
529 ::fidl_next::wire::Box::encode_absent(out);
530 }
531
532 Ok(())
533 }
534 }
535
536 impl ::fidl_next::FromWire<crate::wire::BootManagerQueryActiveConfigurationResponse>
537 for BootManagerQueryActiveConfigurationResponse
538 {
539 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
540 crate::wire::BootManagerQueryActiveConfigurationResponse,
541 Self,
542 > = unsafe {
543 ::fidl_next::CopyOptimization::enable_if(
544 true && <crate::natural::Configuration as ::fidl_next::FromWire<
545 crate::wire::Configuration,
546 >>::COPY_OPTIMIZATION
547 .is_enabled(),
548 )
549 };
550
551 #[inline]
552 fn from_wire(wire: crate::wire::BootManagerQueryActiveConfigurationResponse) -> Self {
553 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
554 }
555 }
556
557 impl ::fidl_next::FromWireRef<crate::wire::BootManagerQueryActiveConfigurationResponse>
558 for BootManagerQueryActiveConfigurationResponse
559 {
560 #[inline]
561 fn from_wire_ref(wire: &crate::wire::BootManagerQueryActiveConfigurationResponse) -> Self {
562 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
563 }
564 }
565
566 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
567 #[repr(C)]
568 pub struct BootManagerQueryConfigurationLastSetActiveResponse {
569 pub configuration: crate::natural::Configuration,
570 }
571
572 unsafe impl<___E>
573 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationLastSetActiveResponse, ___E>
574 for BootManagerQueryConfigurationLastSetActiveResponse
575 where
576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
577 {
578 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
579 Self,
580 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
581 > = unsafe {
582 ::fidl_next::CopyOptimization::enable_if(
583 true && <crate::natural::Configuration as ::fidl_next::Encode<
584 crate::wire::Configuration,
585 ___E,
586 >>::COPY_OPTIMIZATION
587 .is_enabled(),
588 )
589 };
590
591 #[inline]
592 fn encode(
593 self,
594 encoder_: &mut ___E,
595 out_: &mut ::core::mem::MaybeUninit<
596 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
597 >,
598 _: (),
599 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
600 ::fidl_next::munge! {
601 let crate::wire::BootManagerQueryConfigurationLastSetActiveResponse {
602 configuration,
603
604 } = out_;
605 }
606
607 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
608
609 let mut _field =
610 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
611
612 Ok(())
613 }
614 }
615
616 unsafe impl<'a, ___E>
617 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationLastSetActiveResponse, ___E>
618 for &'a BootManagerQueryConfigurationLastSetActiveResponse
619 where
620 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
621 {
622 #[inline]
623 fn encode(
624 self,
625 encoder_: &mut ___E,
626 out_: &mut ::core::mem::MaybeUninit<
627 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
628 >,
629 _: (),
630 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
631 ::fidl_next::munge! {
632 let crate::wire::BootManagerQueryConfigurationLastSetActiveResponse {
633 configuration,
634
635 } = out_;
636 }
637
638 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
639
640 let mut _field =
641 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
642
643 Ok(())
644 }
645 }
646
647 unsafe impl<___E>
648 ::fidl_next::EncodeOption<
649 ::fidl_next::wire::Box<
650 'static,
651 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
652 >,
653 ___E,
654 > for BootManagerQueryConfigurationLastSetActiveResponse
655 where
656 ___E: ::fidl_next::Encoder + ?Sized,
657 BootManagerQueryConfigurationLastSetActiveResponse: ::fidl_next::Encode<
658 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
659 ___E,
660 >,
661 {
662 #[inline]
663 fn encode_option(
664 this: ::core::option::Option<Self>,
665 encoder: &mut ___E,
666 out: &mut ::core::mem::MaybeUninit<
667 ::fidl_next::wire::Box<
668 'static,
669 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
670 >,
671 >,
672 _: (),
673 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
674 if let Some(inner) = this {
675 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
676 ::fidl_next::wire::Box::encode_present(out);
677 } else {
678 ::fidl_next::wire::Box::encode_absent(out);
679 }
680
681 Ok(())
682 }
683 }
684
685 unsafe impl<'a, ___E>
686 ::fidl_next::EncodeOption<
687 ::fidl_next::wire::Box<
688 'static,
689 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
690 >,
691 ___E,
692 > for &'a BootManagerQueryConfigurationLastSetActiveResponse
693 where
694 ___E: ::fidl_next::Encoder + ?Sized,
695 &'a BootManagerQueryConfigurationLastSetActiveResponse: ::fidl_next::Encode<
696 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
697 ___E,
698 >,
699 {
700 #[inline]
701 fn encode_option(
702 this: ::core::option::Option<Self>,
703 encoder: &mut ___E,
704 out: &mut ::core::mem::MaybeUninit<
705 ::fidl_next::wire::Box<
706 'static,
707 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
708 >,
709 >,
710 _: (),
711 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
712 if let Some(inner) = this {
713 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
714 ::fidl_next::wire::Box::encode_present(out);
715 } else {
716 ::fidl_next::wire::Box::encode_absent(out);
717 }
718
719 Ok(())
720 }
721 }
722
723 impl ::fidl_next::FromWire<crate::wire::BootManagerQueryConfigurationLastSetActiveResponse>
724 for BootManagerQueryConfigurationLastSetActiveResponse
725 {
726 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
727 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
728 Self,
729 > = unsafe {
730 ::fidl_next::CopyOptimization::enable_if(
731 true && <crate::natural::Configuration as ::fidl_next::FromWire<
732 crate::wire::Configuration,
733 >>::COPY_OPTIMIZATION
734 .is_enabled(),
735 )
736 };
737
738 #[inline]
739 fn from_wire(
740 wire: crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
741 ) -> Self {
742 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
743 }
744 }
745
746 impl ::fidl_next::FromWireRef<crate::wire::BootManagerQueryConfigurationLastSetActiveResponse>
747 for BootManagerQueryConfigurationLastSetActiveResponse
748 {
749 #[inline]
750 fn from_wire_ref(
751 wire: &crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
752 ) -> Self {
753 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
754 }
755 }
756
757 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
758 #[repr(C)]
759 pub struct BootManagerQueryConfigurationStatusRequest {
760 pub configuration: crate::natural::Configuration,
761 }
762
763 unsafe impl<___E>
764 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusRequest, ___E>
765 for BootManagerQueryConfigurationStatusRequest
766 where
767 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
768 {
769 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
770 Self,
771 crate::wire::BootManagerQueryConfigurationStatusRequest,
772 > = unsafe {
773 ::fidl_next::CopyOptimization::enable_if(
774 true && <crate::natural::Configuration as ::fidl_next::Encode<
775 crate::wire::Configuration,
776 ___E,
777 >>::COPY_OPTIMIZATION
778 .is_enabled(),
779 )
780 };
781
782 #[inline]
783 fn encode(
784 self,
785 encoder_: &mut ___E,
786 out_: &mut ::core::mem::MaybeUninit<
787 crate::wire::BootManagerQueryConfigurationStatusRequest,
788 >,
789 _: (),
790 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
791 ::fidl_next::munge! {
792 let crate::wire::BootManagerQueryConfigurationStatusRequest {
793 configuration,
794
795 } = out_;
796 }
797
798 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
799
800 let mut _field =
801 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
802
803 Ok(())
804 }
805 }
806
807 unsafe impl<'a, ___E>
808 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusRequest, ___E>
809 for &'a BootManagerQueryConfigurationStatusRequest
810 where
811 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
812 {
813 #[inline]
814 fn encode(
815 self,
816 encoder_: &mut ___E,
817 out_: &mut ::core::mem::MaybeUninit<
818 crate::wire::BootManagerQueryConfigurationStatusRequest,
819 >,
820 _: (),
821 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
822 ::fidl_next::munge! {
823 let crate::wire::BootManagerQueryConfigurationStatusRequest {
824 configuration,
825
826 } = out_;
827 }
828
829 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
830
831 let mut _field =
832 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
833
834 Ok(())
835 }
836 }
837
838 unsafe impl<___E>
839 ::fidl_next::EncodeOption<
840 ::fidl_next::wire::Box<
841 'static,
842 crate::wire::BootManagerQueryConfigurationStatusRequest,
843 >,
844 ___E,
845 > for BootManagerQueryConfigurationStatusRequest
846 where
847 ___E: ::fidl_next::Encoder + ?Sized,
848 BootManagerQueryConfigurationStatusRequest:
849 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusRequest, ___E>,
850 {
851 #[inline]
852 fn encode_option(
853 this: ::core::option::Option<Self>,
854 encoder: &mut ___E,
855 out: &mut ::core::mem::MaybeUninit<
856 ::fidl_next::wire::Box<
857 'static,
858 crate::wire::BootManagerQueryConfigurationStatusRequest,
859 >,
860 >,
861 _: (),
862 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
863 if let Some(inner) = this {
864 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
865 ::fidl_next::wire::Box::encode_present(out);
866 } else {
867 ::fidl_next::wire::Box::encode_absent(out);
868 }
869
870 Ok(())
871 }
872 }
873
874 unsafe impl<'a, ___E>
875 ::fidl_next::EncodeOption<
876 ::fidl_next::wire::Box<
877 'static,
878 crate::wire::BootManagerQueryConfigurationStatusRequest,
879 >,
880 ___E,
881 > for &'a BootManagerQueryConfigurationStatusRequest
882 where
883 ___E: ::fidl_next::Encoder + ?Sized,
884 &'a BootManagerQueryConfigurationStatusRequest:
885 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusRequest, ___E>,
886 {
887 #[inline]
888 fn encode_option(
889 this: ::core::option::Option<Self>,
890 encoder: &mut ___E,
891 out: &mut ::core::mem::MaybeUninit<
892 ::fidl_next::wire::Box<
893 'static,
894 crate::wire::BootManagerQueryConfigurationStatusRequest,
895 >,
896 >,
897 _: (),
898 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
899 if let Some(inner) = this {
900 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
901 ::fidl_next::wire::Box::encode_present(out);
902 } else {
903 ::fidl_next::wire::Box::encode_absent(out);
904 }
905
906 Ok(())
907 }
908 }
909
910 impl ::fidl_next::FromWire<crate::wire::BootManagerQueryConfigurationStatusRequest>
911 for BootManagerQueryConfigurationStatusRequest
912 {
913 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
914 crate::wire::BootManagerQueryConfigurationStatusRequest,
915 Self,
916 > = unsafe {
917 ::fidl_next::CopyOptimization::enable_if(
918 true && <crate::natural::Configuration as ::fidl_next::FromWire<
919 crate::wire::Configuration,
920 >>::COPY_OPTIMIZATION
921 .is_enabled(),
922 )
923 };
924
925 #[inline]
926 fn from_wire(wire: crate::wire::BootManagerQueryConfigurationStatusRequest) -> Self {
927 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
928 }
929 }
930
931 impl ::fidl_next::FromWireRef<crate::wire::BootManagerQueryConfigurationStatusRequest>
932 for BootManagerQueryConfigurationStatusRequest
933 {
934 #[inline]
935 fn from_wire_ref(wire: &crate::wire::BootManagerQueryConfigurationStatusRequest) -> Self {
936 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
937 }
938 }
939
940 #[doc = " Set of states configuration may be in.\n"]
941 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
942 #[repr(u32)]
943 pub enum ConfigurationStatus {
944 Healthy = 1,
945 Pending = 2,
946 Unbootable = 3,
947 }
948 impl ::core::convert::TryFrom<u32> for ConfigurationStatus {
949 type Error = ::fidl_next::UnknownStrictEnumMemberError;
950 fn try_from(
951 value: u32,
952 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
953 match value {
954 1 => Ok(Self::Healthy),
955 2 => Ok(Self::Pending),
956 3 => Ok(Self::Unbootable),
957
958 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
959 }
960 }
961 }
962
963 impl ::std::convert::From<ConfigurationStatus> for u32 {
964 fn from(value: ConfigurationStatus) -> Self {
965 match value {
966 ConfigurationStatus::Healthy => 1,
967 ConfigurationStatus::Pending => 2,
968 ConfigurationStatus::Unbootable => 3,
969 }
970 }
971 }
972
973 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigurationStatus, ___E>
974 for ConfigurationStatus
975 where
976 ___E: ?Sized,
977 {
978 #[inline]
979 fn encode(
980 self,
981 encoder: &mut ___E,
982 out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigurationStatus>,
983 _: (),
984 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
985 ::fidl_next::Encode::encode(&self, encoder, out, ())
986 }
987 }
988
989 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigurationStatus, ___E>
990 for &'a ConfigurationStatus
991 where
992 ___E: ?Sized,
993 {
994 #[inline]
995 fn encode(
996 self,
997 encoder: &mut ___E,
998 out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigurationStatus>,
999 _: (),
1000 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1001 ::fidl_next::munge!(let crate::wire::ConfigurationStatus { value } = out);
1002 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
1003 ConfigurationStatus::Healthy => 1,
1004
1005 ConfigurationStatus::Pending => 2,
1006
1007 ConfigurationStatus::Unbootable => 3,
1008 }));
1009
1010 Ok(())
1011 }
1012 }
1013
1014 impl ::core::convert::From<crate::wire::ConfigurationStatus> for ConfigurationStatus {
1015 fn from(wire: crate::wire::ConfigurationStatus) -> Self {
1016 match u32::from(wire.value) {
1017 1 => Self::Healthy,
1018
1019 2 => Self::Pending,
1020
1021 3 => Self::Unbootable,
1022
1023 _ => unsafe { ::core::hint::unreachable_unchecked() },
1024 }
1025 }
1026 }
1027
1028 impl ::fidl_next::FromWire<crate::wire::ConfigurationStatus> for ConfigurationStatus {
1029 #[inline]
1030 fn from_wire(wire: crate::wire::ConfigurationStatus) -> Self {
1031 Self::from(wire)
1032 }
1033 }
1034
1035 impl ::fidl_next::FromWireRef<crate::wire::ConfigurationStatus> for ConfigurationStatus {
1036 #[inline]
1037 fn from_wire_ref(wire: &crate::wire::ConfigurationStatus) -> Self {
1038 Self::from(*wire)
1039 }
1040 }
1041
1042 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1043 #[repr(C)]
1044 pub struct BootManagerQueryConfigurationStatusResponse {
1045 pub status: crate::natural::ConfigurationStatus,
1046 }
1047
1048 unsafe impl<___E>
1049 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusResponse, ___E>
1050 for BootManagerQueryConfigurationStatusResponse
1051 where
1052 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1053 {
1054 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1055 Self,
1056 crate::wire::BootManagerQueryConfigurationStatusResponse,
1057 > = unsafe {
1058 ::fidl_next::CopyOptimization::enable_if(
1059 true && <crate::natural::ConfigurationStatus as ::fidl_next::Encode<
1060 crate::wire::ConfigurationStatus,
1061 ___E,
1062 >>::COPY_OPTIMIZATION
1063 .is_enabled(),
1064 )
1065 };
1066
1067 #[inline]
1068 fn encode(
1069 self,
1070 encoder_: &mut ___E,
1071 out_: &mut ::core::mem::MaybeUninit<
1072 crate::wire::BootManagerQueryConfigurationStatusResponse,
1073 >,
1074 _: (),
1075 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1076 ::fidl_next::munge! {
1077 let crate::wire::BootManagerQueryConfigurationStatusResponse {
1078 status,
1079
1080 } = out_;
1081 }
1082
1083 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
1084
1085 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
1086
1087 Ok(())
1088 }
1089 }
1090
1091 unsafe impl<'a, ___E>
1092 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusResponse, ___E>
1093 for &'a BootManagerQueryConfigurationStatusResponse
1094 where
1095 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1096 {
1097 #[inline]
1098 fn encode(
1099 self,
1100 encoder_: &mut ___E,
1101 out_: &mut ::core::mem::MaybeUninit<
1102 crate::wire::BootManagerQueryConfigurationStatusResponse,
1103 >,
1104 _: (),
1105 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1106 ::fidl_next::munge! {
1107 let crate::wire::BootManagerQueryConfigurationStatusResponse {
1108 status,
1109
1110 } = out_;
1111 }
1112
1113 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
1114
1115 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
1116
1117 Ok(())
1118 }
1119 }
1120
1121 unsafe impl<___E>
1122 ::fidl_next::EncodeOption<
1123 ::fidl_next::wire::Box<
1124 'static,
1125 crate::wire::BootManagerQueryConfigurationStatusResponse,
1126 >,
1127 ___E,
1128 > for BootManagerQueryConfigurationStatusResponse
1129 where
1130 ___E: ::fidl_next::Encoder + ?Sized,
1131 BootManagerQueryConfigurationStatusResponse:
1132 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusResponse, ___E>,
1133 {
1134 #[inline]
1135 fn encode_option(
1136 this: ::core::option::Option<Self>,
1137 encoder: &mut ___E,
1138 out: &mut ::core::mem::MaybeUninit<
1139 ::fidl_next::wire::Box<
1140 'static,
1141 crate::wire::BootManagerQueryConfigurationStatusResponse,
1142 >,
1143 >,
1144 _: (),
1145 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1146 if let Some(inner) = this {
1147 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1148 ::fidl_next::wire::Box::encode_present(out);
1149 } else {
1150 ::fidl_next::wire::Box::encode_absent(out);
1151 }
1152
1153 Ok(())
1154 }
1155 }
1156
1157 unsafe impl<'a, ___E>
1158 ::fidl_next::EncodeOption<
1159 ::fidl_next::wire::Box<
1160 'static,
1161 crate::wire::BootManagerQueryConfigurationStatusResponse,
1162 >,
1163 ___E,
1164 > for &'a BootManagerQueryConfigurationStatusResponse
1165 where
1166 ___E: ::fidl_next::Encoder + ?Sized,
1167 &'a BootManagerQueryConfigurationStatusResponse:
1168 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusResponse, ___E>,
1169 {
1170 #[inline]
1171 fn encode_option(
1172 this: ::core::option::Option<Self>,
1173 encoder: &mut ___E,
1174 out: &mut ::core::mem::MaybeUninit<
1175 ::fidl_next::wire::Box<
1176 'static,
1177 crate::wire::BootManagerQueryConfigurationStatusResponse,
1178 >,
1179 >,
1180 _: (),
1181 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1182 if let Some(inner) = this {
1183 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1184 ::fidl_next::wire::Box::encode_present(out);
1185 } else {
1186 ::fidl_next::wire::Box::encode_absent(out);
1187 }
1188
1189 Ok(())
1190 }
1191 }
1192
1193 impl ::fidl_next::FromWire<crate::wire::BootManagerQueryConfigurationStatusResponse>
1194 for BootManagerQueryConfigurationStatusResponse
1195 {
1196 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1197 crate::wire::BootManagerQueryConfigurationStatusResponse,
1198 Self,
1199 > = unsafe {
1200 ::fidl_next::CopyOptimization::enable_if(
1201 true && <crate::natural::ConfigurationStatus as ::fidl_next::FromWire<
1202 crate::wire::ConfigurationStatus,
1203 >>::COPY_OPTIMIZATION
1204 .is_enabled(),
1205 )
1206 };
1207
1208 #[inline]
1209 fn from_wire(wire: crate::wire::BootManagerQueryConfigurationStatusResponse) -> Self {
1210 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
1211 }
1212 }
1213
1214 impl ::fidl_next::FromWireRef<crate::wire::BootManagerQueryConfigurationStatusResponse>
1215 for BootManagerQueryConfigurationStatusResponse
1216 {
1217 #[inline]
1218 fn from_wire_ref(wire: &crate::wire::BootManagerQueryConfigurationStatusResponse) -> Self {
1219 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
1220 }
1221 }
1222
1223 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1224 #[repr(C)]
1225 pub struct BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
1226 pub configuration: crate::natural::Configuration,
1227 }
1228
1229 unsafe impl<___E>
1230 ::fidl_next::Encode<
1231 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1232 ___E,
1233 > for BootManagerQueryConfigurationStatusAndBootAttemptsRequest
1234 where
1235 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1236 {
1237 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1238 Self,
1239 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1240 > = unsafe {
1241 ::fidl_next::CopyOptimization::enable_if(
1242 true && <crate::natural::Configuration as ::fidl_next::Encode<
1243 crate::wire::Configuration,
1244 ___E,
1245 >>::COPY_OPTIMIZATION
1246 .is_enabled(),
1247 )
1248 };
1249
1250 #[inline]
1251 fn encode(
1252 self,
1253 encoder_: &mut ___E,
1254 out_: &mut ::core::mem::MaybeUninit<
1255 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1256 >,
1257 _: (),
1258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1259 ::fidl_next::munge! {
1260 let crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
1261 configuration,
1262
1263 } = out_;
1264 }
1265
1266 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
1267
1268 let mut _field =
1269 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
1270
1271 Ok(())
1272 }
1273 }
1274
1275 unsafe impl<'a, ___E>
1276 ::fidl_next::Encode<
1277 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1278 ___E,
1279 > for &'a BootManagerQueryConfigurationStatusAndBootAttemptsRequest
1280 where
1281 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1282 {
1283 #[inline]
1284 fn encode(
1285 self,
1286 encoder_: &mut ___E,
1287 out_: &mut ::core::mem::MaybeUninit<
1288 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1289 >,
1290 _: (),
1291 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1292 ::fidl_next::munge! {
1293 let crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
1294 configuration,
1295
1296 } = out_;
1297 }
1298
1299 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
1300
1301 let mut _field =
1302 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
1303
1304 Ok(())
1305 }
1306 }
1307
1308 unsafe impl<___E>
1309 ::fidl_next::EncodeOption<
1310 ::fidl_next::wire::Box<
1311 'static,
1312 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1313 >,
1314 ___E,
1315 > for BootManagerQueryConfigurationStatusAndBootAttemptsRequest
1316 where
1317 ___E: ::fidl_next::Encoder + ?Sized,
1318 BootManagerQueryConfigurationStatusAndBootAttemptsRequest: ::fidl_next::Encode<
1319 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1320 ___E,
1321 >,
1322 {
1323 #[inline]
1324 fn encode_option(
1325 this: ::core::option::Option<Self>,
1326 encoder: &mut ___E,
1327 out: &mut ::core::mem::MaybeUninit<
1328 ::fidl_next::wire::Box<
1329 'static,
1330 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1331 >,
1332 >,
1333 _: (),
1334 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1335 if let Some(inner) = this {
1336 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1337 ::fidl_next::wire::Box::encode_present(out);
1338 } else {
1339 ::fidl_next::wire::Box::encode_absent(out);
1340 }
1341
1342 Ok(())
1343 }
1344 }
1345
1346 unsafe impl<'a, ___E>
1347 ::fidl_next::EncodeOption<
1348 ::fidl_next::wire::Box<
1349 'static,
1350 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1351 >,
1352 ___E,
1353 > for &'a BootManagerQueryConfigurationStatusAndBootAttemptsRequest
1354 where
1355 ___E: ::fidl_next::Encoder + ?Sized,
1356 &'a BootManagerQueryConfigurationStatusAndBootAttemptsRequest: ::fidl_next::Encode<
1357 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1358 ___E,
1359 >,
1360 {
1361 #[inline]
1362 fn encode_option(
1363 this: ::core::option::Option<Self>,
1364 encoder: &mut ___E,
1365 out: &mut ::core::mem::MaybeUninit<
1366 ::fidl_next::wire::Box<
1367 'static,
1368 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1369 >,
1370 >,
1371 _: (),
1372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1373 if let Some(inner) = this {
1374 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1375 ::fidl_next::wire::Box::encode_present(out);
1376 } else {
1377 ::fidl_next::wire::Box::encode_absent(out);
1378 }
1379
1380 Ok(())
1381 }
1382 }
1383
1384 impl
1385 ::fidl_next::FromWire<
1386 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1387 > for BootManagerQueryConfigurationStatusAndBootAttemptsRequest
1388 {
1389 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1390 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1391 Self,
1392 > = unsafe {
1393 ::fidl_next::CopyOptimization::enable_if(
1394 true && <crate::natural::Configuration as ::fidl_next::FromWire<
1395 crate::wire::Configuration,
1396 >>::COPY_OPTIMIZATION
1397 .is_enabled(),
1398 )
1399 };
1400
1401 #[inline]
1402 fn from_wire(
1403 wire: crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1404 ) -> Self {
1405 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
1406 }
1407 }
1408
1409 impl
1410 ::fidl_next::FromWireRef<
1411 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1412 > for BootManagerQueryConfigurationStatusAndBootAttemptsRequest
1413 {
1414 #[inline]
1415 fn from_wire_ref(
1416 wire: &crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
1417 ) -> Self {
1418 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
1419 }
1420 }
1421
1422 #[doc = " Reasons why a configuration may be marked unbootable.\n"]
1423 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1424 #[repr(u32)]
1425 pub enum UnbootableReason {
1426 None = 0,
1427 NoMoreTries = 1,
1428 OsRequested = 2,
1429 VerificationFailure = 3,
1430 UnknownOrdinal_(u32) = 4,
1431 }
1432 impl ::std::convert::From<u32> for UnbootableReason {
1433 fn from(value: u32) -> Self {
1434 match value {
1435 0 => Self::None,
1436 1 => Self::NoMoreTries,
1437 2 => Self::OsRequested,
1438 3 => Self::VerificationFailure,
1439
1440 _ => Self::UnknownOrdinal_(value),
1441 }
1442 }
1443 }
1444
1445 impl ::std::convert::From<UnbootableReason> for u32 {
1446 fn from(value: UnbootableReason) -> Self {
1447 match value {
1448 UnbootableReason::None => 0,
1449 UnbootableReason::NoMoreTries => 1,
1450 UnbootableReason::OsRequested => 2,
1451 UnbootableReason::VerificationFailure => 3,
1452
1453 UnbootableReason::UnknownOrdinal_(value) => value,
1454 }
1455 }
1456 }
1457
1458 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnbootableReason, ___E> for UnbootableReason
1459 where
1460 ___E: ?Sized,
1461 {
1462 #[inline]
1463 fn encode(
1464 self,
1465 encoder: &mut ___E,
1466 out: &mut ::core::mem::MaybeUninit<crate::wire::UnbootableReason>,
1467 _: (),
1468 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1469 ::fidl_next::Encode::encode(&self, encoder, out, ())
1470 }
1471 }
1472
1473 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnbootableReason, ___E>
1474 for &'a UnbootableReason
1475 where
1476 ___E: ?Sized,
1477 {
1478 #[inline]
1479 fn encode(
1480 self,
1481 encoder: &mut ___E,
1482 out: &mut ::core::mem::MaybeUninit<crate::wire::UnbootableReason>,
1483 _: (),
1484 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1485 ::fidl_next::munge!(let crate::wire::UnbootableReason { value } = out);
1486 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
1487 UnbootableReason::None => 0,
1488
1489 UnbootableReason::NoMoreTries => 1,
1490
1491 UnbootableReason::OsRequested => 2,
1492
1493 UnbootableReason::VerificationFailure => 3,
1494
1495 UnbootableReason::UnknownOrdinal_(value) => value,
1496 }));
1497
1498 Ok(())
1499 }
1500 }
1501
1502 impl ::core::convert::From<crate::wire::UnbootableReason> for UnbootableReason {
1503 fn from(wire: crate::wire::UnbootableReason) -> Self {
1504 match u32::from(wire.value) {
1505 0 => Self::None,
1506
1507 1 => Self::NoMoreTries,
1508
1509 2 => Self::OsRequested,
1510
1511 3 => Self::VerificationFailure,
1512
1513 value => Self::UnknownOrdinal_(value),
1514 }
1515 }
1516 }
1517
1518 impl ::fidl_next::FromWire<crate::wire::UnbootableReason> for UnbootableReason {
1519 #[inline]
1520 fn from_wire(wire: crate::wire::UnbootableReason) -> Self {
1521 Self::from(wire)
1522 }
1523 }
1524
1525 impl ::fidl_next::FromWireRef<crate::wire::UnbootableReason> for UnbootableReason {
1526 #[inline]
1527 fn from_wire_ref(wire: &crate::wire::UnbootableReason) -> Self {
1528 Self::from(*wire)
1529 }
1530 }
1531
1532 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1533 pub struct BootManagerQueryConfigurationStatusAndBootAttemptsResponse {
1534 pub status: ::core::option::Option<crate::natural::ConfigurationStatus>,
1535
1536 pub boot_attempts: ::core::option::Option<u8>,
1537
1538 pub unbootable_reason: ::core::option::Option<crate::natural::UnbootableReason>,
1539 }
1540
1541 impl BootManagerQueryConfigurationStatusAndBootAttemptsResponse {
1542 fn __max_ordinal(&self) -> usize {
1543 if self.unbootable_reason.is_some() {
1544 return 3;
1545 }
1546
1547 if self.boot_attempts.is_some() {
1548 return 2;
1549 }
1550
1551 if self.status.is_some() {
1552 return 1;
1553 }
1554
1555 0
1556 }
1557 }
1558
1559 unsafe impl<___E>
1560 ::fidl_next::Encode<
1561 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'static>,
1562 ___E,
1563 > for BootManagerQueryConfigurationStatusAndBootAttemptsResponse
1564 where
1565 ___E: ::fidl_next::Encoder + ?Sized,
1566 {
1567 #[inline]
1568 fn encode(
1569 mut self,
1570 encoder: &mut ___E,
1571 out: &mut ::core::mem::MaybeUninit<
1572 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'static>,
1573 >,
1574 _: (),
1575 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1576 ::fidl_next::munge!(let crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse { table } = out);
1577
1578 let max_ord = self.__max_ordinal();
1579
1580 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1581 ::fidl_next::Wire::zero_padding(&mut out);
1582
1583 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1584 ::fidl_next::wire::Envelope,
1585 >(encoder, max_ord);
1586
1587 for i in 1..=max_ord {
1588 match i {
1589 3 => {
1590 if let Some(value) = self.unbootable_reason.take() {
1591 ::fidl_next::wire::Envelope::encode_value::<
1592 crate::wire::UnbootableReason,
1593 ___E,
1594 >(
1595 value, preallocated.encoder, &mut out, ()
1596 )?;
1597 } else {
1598 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1599 }
1600 }
1601
1602 2 => {
1603 if let Some(value) = self.boot_attempts.take() {
1604 ::fidl_next::wire::Envelope::encode_value::<u8, ___E>(
1605 value,
1606 preallocated.encoder,
1607 &mut out,
1608 (),
1609 )?;
1610 } else {
1611 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1612 }
1613 }
1614
1615 1 => {
1616 if let Some(value) = self.status.take() {
1617 ::fidl_next::wire::Envelope::encode_value::<
1618 crate::wire::ConfigurationStatus,
1619 ___E,
1620 >(
1621 value, preallocated.encoder, &mut out, ()
1622 )?;
1623 } else {
1624 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1625 }
1626 }
1627
1628 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1629 }
1630 unsafe {
1631 preallocated.write_next(out.assume_init_ref());
1632 }
1633 }
1634
1635 ::fidl_next::wire::Table::encode_len(table, max_ord);
1636
1637 Ok(())
1638 }
1639 }
1640
1641 unsafe impl<'a, ___E>
1642 ::fidl_next::Encode<
1643 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'static>,
1644 ___E,
1645 > for &'a BootManagerQueryConfigurationStatusAndBootAttemptsResponse
1646 where
1647 ___E: ::fidl_next::Encoder + ?Sized,
1648 {
1649 #[inline]
1650 fn encode(
1651 self,
1652 encoder: &mut ___E,
1653 out: &mut ::core::mem::MaybeUninit<
1654 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'static>,
1655 >,
1656 _: (),
1657 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1658 ::fidl_next::munge!(let crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse { table } = out);
1659
1660 let max_ord = self.__max_ordinal();
1661
1662 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1663 ::fidl_next::Wire::zero_padding(&mut out);
1664
1665 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1666 ::fidl_next::wire::Envelope,
1667 >(encoder, max_ord);
1668
1669 for i in 1..=max_ord {
1670 match i {
1671 3 => {
1672 if let Some(value) = &self.unbootable_reason {
1673 ::fidl_next::wire::Envelope::encode_value::<
1674 crate::wire::UnbootableReason,
1675 ___E,
1676 >(
1677 value, preallocated.encoder, &mut out, ()
1678 )?;
1679 } else {
1680 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1681 }
1682 }
1683
1684 2 => {
1685 if let Some(value) = &self.boot_attempts {
1686 ::fidl_next::wire::Envelope::encode_value::<u8, ___E>(
1687 value,
1688 preallocated.encoder,
1689 &mut out,
1690 (),
1691 )?;
1692 } else {
1693 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1694 }
1695 }
1696
1697 1 => {
1698 if let Some(value) = &self.status {
1699 ::fidl_next::wire::Envelope::encode_value::<
1700 crate::wire::ConfigurationStatus,
1701 ___E,
1702 >(
1703 value, preallocated.encoder, &mut out, ()
1704 )?;
1705 } else {
1706 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1707 }
1708 }
1709
1710 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1711 }
1712 unsafe {
1713 preallocated.write_next(out.assume_init_ref());
1714 }
1715 }
1716
1717 ::fidl_next::wire::Table::encode_len(table, max_ord);
1718
1719 Ok(())
1720 }
1721 }
1722
1723 impl<'de>
1724 ::fidl_next::FromWire<
1725 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>,
1726 > for BootManagerQueryConfigurationStatusAndBootAttemptsResponse
1727 {
1728 #[inline]
1729 fn from_wire(
1730 wire_: crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>,
1731 ) -> Self {
1732 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1733
1734 let status = wire_.table.get(1);
1735
1736 let boot_attempts = wire_.table.get(2);
1737
1738 let unbootable_reason = wire_.table.get(3);
1739
1740 Self {
1741 status: status.map(|envelope| {
1742 ::fidl_next::FromWire::from_wire(unsafe {
1743 envelope.read_unchecked::<crate::wire::ConfigurationStatus>()
1744 })
1745 }),
1746
1747 boot_attempts: boot_attempts.map(|envelope| {
1748 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<u8>() })
1749 }),
1750
1751 unbootable_reason: unbootable_reason.map(|envelope| {
1752 ::fidl_next::FromWire::from_wire(unsafe {
1753 envelope.read_unchecked::<crate::wire::UnbootableReason>()
1754 })
1755 }),
1756 }
1757 }
1758 }
1759
1760 impl<'de>
1761 ::fidl_next::FromWireRef<
1762 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>,
1763 > for BootManagerQueryConfigurationStatusAndBootAttemptsResponse
1764 {
1765 #[inline]
1766 fn from_wire_ref(
1767 wire: &crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>,
1768 ) -> Self {
1769 Self {
1770 status: wire.table.get(1).map(|envelope| {
1771 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1772 envelope.deref_unchecked::<crate::wire::ConfigurationStatus>()
1773 })
1774 }),
1775
1776 boot_attempts: wire.table.get(2).map(|envelope| {
1777 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1778 envelope.deref_unchecked::<u8>()
1779 })
1780 }),
1781
1782 unbootable_reason: wire.table.get(3).map(|envelope| {
1783 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1784 envelope.deref_unchecked::<crate::wire::UnbootableReason>()
1785 })
1786 }),
1787 }
1788 }
1789 }
1790
1791 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1792 #[repr(C)]
1793 pub struct BootManagerSetConfigurationActiveRequest {
1794 pub configuration: crate::natural::Configuration,
1795 }
1796
1797 unsafe impl<___E>
1798 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveRequest, ___E>
1799 for BootManagerSetConfigurationActiveRequest
1800 where
1801 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1802 {
1803 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1804 Self,
1805 crate::wire::BootManagerSetConfigurationActiveRequest,
1806 > = unsafe {
1807 ::fidl_next::CopyOptimization::enable_if(
1808 true && <crate::natural::Configuration as ::fidl_next::Encode<
1809 crate::wire::Configuration,
1810 ___E,
1811 >>::COPY_OPTIMIZATION
1812 .is_enabled(),
1813 )
1814 };
1815
1816 #[inline]
1817 fn encode(
1818 self,
1819 encoder_: &mut ___E,
1820 out_: &mut ::core::mem::MaybeUninit<
1821 crate::wire::BootManagerSetConfigurationActiveRequest,
1822 >,
1823 _: (),
1824 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1825 ::fidl_next::munge! {
1826 let crate::wire::BootManagerSetConfigurationActiveRequest {
1827 configuration,
1828
1829 } = out_;
1830 }
1831
1832 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
1833
1834 let mut _field =
1835 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
1836
1837 Ok(())
1838 }
1839 }
1840
1841 unsafe impl<'a, ___E>
1842 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveRequest, ___E>
1843 for &'a BootManagerSetConfigurationActiveRequest
1844 where
1845 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1846 {
1847 #[inline]
1848 fn encode(
1849 self,
1850 encoder_: &mut ___E,
1851 out_: &mut ::core::mem::MaybeUninit<
1852 crate::wire::BootManagerSetConfigurationActiveRequest,
1853 >,
1854 _: (),
1855 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1856 ::fidl_next::munge! {
1857 let crate::wire::BootManagerSetConfigurationActiveRequest {
1858 configuration,
1859
1860 } = out_;
1861 }
1862
1863 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
1864
1865 let mut _field =
1866 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
1867
1868 Ok(())
1869 }
1870 }
1871
1872 unsafe impl<___E>
1873 ::fidl_next::EncodeOption<
1874 ::fidl_next::wire::Box<'static, crate::wire::BootManagerSetConfigurationActiveRequest>,
1875 ___E,
1876 > for BootManagerSetConfigurationActiveRequest
1877 where
1878 ___E: ::fidl_next::Encoder + ?Sized,
1879 BootManagerSetConfigurationActiveRequest:
1880 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveRequest, ___E>,
1881 {
1882 #[inline]
1883 fn encode_option(
1884 this: ::core::option::Option<Self>,
1885 encoder: &mut ___E,
1886 out: &mut ::core::mem::MaybeUninit<
1887 ::fidl_next::wire::Box<
1888 'static,
1889 crate::wire::BootManagerSetConfigurationActiveRequest,
1890 >,
1891 >,
1892 _: (),
1893 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1894 if let Some(inner) = this {
1895 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1896 ::fidl_next::wire::Box::encode_present(out);
1897 } else {
1898 ::fidl_next::wire::Box::encode_absent(out);
1899 }
1900
1901 Ok(())
1902 }
1903 }
1904
1905 unsafe impl<'a, ___E>
1906 ::fidl_next::EncodeOption<
1907 ::fidl_next::wire::Box<'static, crate::wire::BootManagerSetConfigurationActiveRequest>,
1908 ___E,
1909 > for &'a BootManagerSetConfigurationActiveRequest
1910 where
1911 ___E: ::fidl_next::Encoder + ?Sized,
1912 &'a BootManagerSetConfigurationActiveRequest:
1913 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveRequest, ___E>,
1914 {
1915 #[inline]
1916 fn encode_option(
1917 this: ::core::option::Option<Self>,
1918 encoder: &mut ___E,
1919 out: &mut ::core::mem::MaybeUninit<
1920 ::fidl_next::wire::Box<
1921 'static,
1922 crate::wire::BootManagerSetConfigurationActiveRequest,
1923 >,
1924 >,
1925 _: (),
1926 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1927 if let Some(inner) = this {
1928 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1929 ::fidl_next::wire::Box::encode_present(out);
1930 } else {
1931 ::fidl_next::wire::Box::encode_absent(out);
1932 }
1933
1934 Ok(())
1935 }
1936 }
1937
1938 impl ::fidl_next::FromWire<crate::wire::BootManagerSetConfigurationActiveRequest>
1939 for BootManagerSetConfigurationActiveRequest
1940 {
1941 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1942 crate::wire::BootManagerSetConfigurationActiveRequest,
1943 Self,
1944 > = unsafe {
1945 ::fidl_next::CopyOptimization::enable_if(
1946 true && <crate::natural::Configuration as ::fidl_next::FromWire<
1947 crate::wire::Configuration,
1948 >>::COPY_OPTIMIZATION
1949 .is_enabled(),
1950 )
1951 };
1952
1953 #[inline]
1954 fn from_wire(wire: crate::wire::BootManagerSetConfigurationActiveRequest) -> Self {
1955 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
1956 }
1957 }
1958
1959 impl ::fidl_next::FromWireRef<crate::wire::BootManagerSetConfigurationActiveRequest>
1960 for BootManagerSetConfigurationActiveRequest
1961 {
1962 #[inline]
1963 fn from_wire_ref(wire: &crate::wire::BootManagerSetConfigurationActiveRequest) -> Self {
1964 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
1965 }
1966 }
1967
1968 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1969 #[repr(C)]
1970 pub struct BootManagerSetConfigurationActiveResponse {
1971 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
1972 }
1973
1974 unsafe impl<___E>
1975 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveResponse, ___E>
1976 for BootManagerSetConfigurationActiveResponse
1977 where
1978 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1979 {
1980 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1981 Self,
1982 crate::wire::BootManagerSetConfigurationActiveResponse,
1983 > = unsafe {
1984 ::fidl_next::CopyOptimization::enable_if(
1985 true
1986
1987 && <
1988 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
1989 >::COPY_OPTIMIZATION.is_enabled()
1990
1991 )
1992 };
1993
1994 #[inline]
1995 fn encode(
1996 self,
1997 encoder_: &mut ___E,
1998 out_: &mut ::core::mem::MaybeUninit<
1999 crate::wire::BootManagerSetConfigurationActiveResponse,
2000 >,
2001 _: (),
2002 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2003 ::fidl_next::munge! {
2004 let crate::wire::BootManagerSetConfigurationActiveResponse {
2005 status,
2006
2007 } = out_;
2008 }
2009
2010 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2011
2012 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2013
2014 Ok(())
2015 }
2016 }
2017
2018 unsafe impl<'a, ___E>
2019 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveResponse, ___E>
2020 for &'a BootManagerSetConfigurationActiveResponse
2021 where
2022 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2023 {
2024 #[inline]
2025 fn encode(
2026 self,
2027 encoder_: &mut ___E,
2028 out_: &mut ::core::mem::MaybeUninit<
2029 crate::wire::BootManagerSetConfigurationActiveResponse,
2030 >,
2031 _: (),
2032 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2033 ::fidl_next::munge! {
2034 let crate::wire::BootManagerSetConfigurationActiveResponse {
2035 status,
2036
2037 } = out_;
2038 }
2039
2040 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
2041
2042 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2043
2044 Ok(())
2045 }
2046 }
2047
2048 unsafe impl<___E>
2049 ::fidl_next::EncodeOption<
2050 ::fidl_next::wire::Box<'static, crate::wire::BootManagerSetConfigurationActiveResponse>,
2051 ___E,
2052 > for BootManagerSetConfigurationActiveResponse
2053 where
2054 ___E: ::fidl_next::Encoder + ?Sized,
2055 BootManagerSetConfigurationActiveResponse:
2056 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveResponse, ___E>,
2057 {
2058 #[inline]
2059 fn encode_option(
2060 this: ::core::option::Option<Self>,
2061 encoder: &mut ___E,
2062 out: &mut ::core::mem::MaybeUninit<
2063 ::fidl_next::wire::Box<
2064 'static,
2065 crate::wire::BootManagerSetConfigurationActiveResponse,
2066 >,
2067 >,
2068 _: (),
2069 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2070 if let Some(inner) = this {
2071 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2072 ::fidl_next::wire::Box::encode_present(out);
2073 } else {
2074 ::fidl_next::wire::Box::encode_absent(out);
2075 }
2076
2077 Ok(())
2078 }
2079 }
2080
2081 unsafe impl<'a, ___E>
2082 ::fidl_next::EncodeOption<
2083 ::fidl_next::wire::Box<'static, crate::wire::BootManagerSetConfigurationActiveResponse>,
2084 ___E,
2085 > for &'a BootManagerSetConfigurationActiveResponse
2086 where
2087 ___E: ::fidl_next::Encoder + ?Sized,
2088 &'a BootManagerSetConfigurationActiveResponse:
2089 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveResponse, ___E>,
2090 {
2091 #[inline]
2092 fn encode_option(
2093 this: ::core::option::Option<Self>,
2094 encoder: &mut ___E,
2095 out: &mut ::core::mem::MaybeUninit<
2096 ::fidl_next::wire::Box<
2097 'static,
2098 crate::wire::BootManagerSetConfigurationActiveResponse,
2099 >,
2100 >,
2101 _: (),
2102 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2103 if let Some(inner) = this {
2104 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2105 ::fidl_next::wire::Box::encode_present(out);
2106 } else {
2107 ::fidl_next::wire::Box::encode_absent(out);
2108 }
2109
2110 Ok(())
2111 }
2112 }
2113
2114 impl ::fidl_next::FromWire<crate::wire::BootManagerSetConfigurationActiveResponse>
2115 for BootManagerSetConfigurationActiveResponse
2116 {
2117 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2118 crate::wire::BootManagerSetConfigurationActiveResponse,
2119 Self,
2120 > = unsafe {
2121 ::fidl_next::CopyOptimization::enable_if(
2122 true
2123
2124 && <
2125 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
2126 >::COPY_OPTIMIZATION.is_enabled()
2127
2128 )
2129 };
2130
2131 #[inline]
2132 fn from_wire(wire: crate::wire::BootManagerSetConfigurationActiveResponse) -> Self {
2133 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
2134 }
2135 }
2136
2137 impl ::fidl_next::FromWireRef<crate::wire::BootManagerSetConfigurationActiveResponse>
2138 for BootManagerSetConfigurationActiveResponse
2139 {
2140 #[inline]
2141 fn from_wire_ref(wire: &crate::wire::BootManagerSetConfigurationActiveResponse) -> Self {
2142 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
2143 }
2144 }
2145
2146 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2147 #[repr(C)]
2148 pub struct BootManagerSetConfigurationUnbootableRequest {
2149 pub configuration: crate::natural::Configuration,
2150 }
2151
2152 unsafe impl<___E>
2153 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableRequest, ___E>
2154 for BootManagerSetConfigurationUnbootableRequest
2155 where
2156 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2157 {
2158 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2159 Self,
2160 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2161 > = unsafe {
2162 ::fidl_next::CopyOptimization::enable_if(
2163 true && <crate::natural::Configuration as ::fidl_next::Encode<
2164 crate::wire::Configuration,
2165 ___E,
2166 >>::COPY_OPTIMIZATION
2167 .is_enabled(),
2168 )
2169 };
2170
2171 #[inline]
2172 fn encode(
2173 self,
2174 encoder_: &mut ___E,
2175 out_: &mut ::core::mem::MaybeUninit<
2176 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2177 >,
2178 _: (),
2179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2180 ::fidl_next::munge! {
2181 let crate::wire::BootManagerSetConfigurationUnbootableRequest {
2182 configuration,
2183
2184 } = out_;
2185 }
2186
2187 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
2188
2189 let mut _field =
2190 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
2191
2192 Ok(())
2193 }
2194 }
2195
2196 unsafe impl<'a, ___E>
2197 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableRequest, ___E>
2198 for &'a BootManagerSetConfigurationUnbootableRequest
2199 where
2200 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2201 {
2202 #[inline]
2203 fn encode(
2204 self,
2205 encoder_: &mut ___E,
2206 out_: &mut ::core::mem::MaybeUninit<
2207 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2208 >,
2209 _: (),
2210 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2211 ::fidl_next::munge! {
2212 let crate::wire::BootManagerSetConfigurationUnbootableRequest {
2213 configuration,
2214
2215 } = out_;
2216 }
2217
2218 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
2219
2220 let mut _field =
2221 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
2222
2223 Ok(())
2224 }
2225 }
2226
2227 unsafe impl<___E>
2228 ::fidl_next::EncodeOption<
2229 ::fidl_next::wire::Box<
2230 'static,
2231 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2232 >,
2233 ___E,
2234 > for BootManagerSetConfigurationUnbootableRequest
2235 where
2236 ___E: ::fidl_next::Encoder + ?Sized,
2237 BootManagerSetConfigurationUnbootableRequest:
2238 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableRequest, ___E>,
2239 {
2240 #[inline]
2241 fn encode_option(
2242 this: ::core::option::Option<Self>,
2243 encoder: &mut ___E,
2244 out: &mut ::core::mem::MaybeUninit<
2245 ::fidl_next::wire::Box<
2246 'static,
2247 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2248 >,
2249 >,
2250 _: (),
2251 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2252 if let Some(inner) = this {
2253 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2254 ::fidl_next::wire::Box::encode_present(out);
2255 } else {
2256 ::fidl_next::wire::Box::encode_absent(out);
2257 }
2258
2259 Ok(())
2260 }
2261 }
2262
2263 unsafe impl<'a, ___E>
2264 ::fidl_next::EncodeOption<
2265 ::fidl_next::wire::Box<
2266 'static,
2267 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2268 >,
2269 ___E,
2270 > for &'a BootManagerSetConfigurationUnbootableRequest
2271 where
2272 ___E: ::fidl_next::Encoder + ?Sized,
2273 &'a BootManagerSetConfigurationUnbootableRequest:
2274 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableRequest, ___E>,
2275 {
2276 #[inline]
2277 fn encode_option(
2278 this: ::core::option::Option<Self>,
2279 encoder: &mut ___E,
2280 out: &mut ::core::mem::MaybeUninit<
2281 ::fidl_next::wire::Box<
2282 'static,
2283 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2284 >,
2285 >,
2286 _: (),
2287 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2288 if let Some(inner) = this {
2289 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2290 ::fidl_next::wire::Box::encode_present(out);
2291 } else {
2292 ::fidl_next::wire::Box::encode_absent(out);
2293 }
2294
2295 Ok(())
2296 }
2297 }
2298
2299 impl ::fidl_next::FromWire<crate::wire::BootManagerSetConfigurationUnbootableRequest>
2300 for BootManagerSetConfigurationUnbootableRequest
2301 {
2302 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2303 crate::wire::BootManagerSetConfigurationUnbootableRequest,
2304 Self,
2305 > = unsafe {
2306 ::fidl_next::CopyOptimization::enable_if(
2307 true && <crate::natural::Configuration as ::fidl_next::FromWire<
2308 crate::wire::Configuration,
2309 >>::COPY_OPTIMIZATION
2310 .is_enabled(),
2311 )
2312 };
2313
2314 #[inline]
2315 fn from_wire(wire: crate::wire::BootManagerSetConfigurationUnbootableRequest) -> Self {
2316 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
2317 }
2318 }
2319
2320 impl ::fidl_next::FromWireRef<crate::wire::BootManagerSetConfigurationUnbootableRequest>
2321 for BootManagerSetConfigurationUnbootableRequest
2322 {
2323 #[inline]
2324 fn from_wire_ref(wire: &crate::wire::BootManagerSetConfigurationUnbootableRequest) -> Self {
2325 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
2326 }
2327 }
2328
2329 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2330 #[repr(C)]
2331 pub struct BootManagerSetConfigurationUnbootableResponse {
2332 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
2333 }
2334
2335 unsafe impl<___E>
2336 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableResponse, ___E>
2337 for BootManagerSetConfigurationUnbootableResponse
2338 where
2339 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2340 {
2341 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2342 Self,
2343 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2344 > = unsafe {
2345 ::fidl_next::CopyOptimization::enable_if(
2346 true
2347
2348 && <
2349 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
2350 >::COPY_OPTIMIZATION.is_enabled()
2351
2352 )
2353 };
2354
2355 #[inline]
2356 fn encode(
2357 self,
2358 encoder_: &mut ___E,
2359 out_: &mut ::core::mem::MaybeUninit<
2360 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2361 >,
2362 _: (),
2363 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2364 ::fidl_next::munge! {
2365 let crate::wire::BootManagerSetConfigurationUnbootableResponse {
2366 status,
2367
2368 } = out_;
2369 }
2370
2371 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2372
2373 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2374
2375 Ok(())
2376 }
2377 }
2378
2379 unsafe impl<'a, ___E>
2380 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableResponse, ___E>
2381 for &'a BootManagerSetConfigurationUnbootableResponse
2382 where
2383 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2384 {
2385 #[inline]
2386 fn encode(
2387 self,
2388 encoder_: &mut ___E,
2389 out_: &mut ::core::mem::MaybeUninit<
2390 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2391 >,
2392 _: (),
2393 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2394 ::fidl_next::munge! {
2395 let crate::wire::BootManagerSetConfigurationUnbootableResponse {
2396 status,
2397
2398 } = out_;
2399 }
2400
2401 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
2402
2403 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2404
2405 Ok(())
2406 }
2407 }
2408
2409 unsafe impl<___E>
2410 ::fidl_next::EncodeOption<
2411 ::fidl_next::wire::Box<
2412 'static,
2413 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2414 >,
2415 ___E,
2416 > for BootManagerSetConfigurationUnbootableResponse
2417 where
2418 ___E: ::fidl_next::Encoder + ?Sized,
2419 BootManagerSetConfigurationUnbootableResponse:
2420 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableResponse, ___E>,
2421 {
2422 #[inline]
2423 fn encode_option(
2424 this: ::core::option::Option<Self>,
2425 encoder: &mut ___E,
2426 out: &mut ::core::mem::MaybeUninit<
2427 ::fidl_next::wire::Box<
2428 'static,
2429 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2430 >,
2431 >,
2432 _: (),
2433 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2434 if let Some(inner) = this {
2435 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2436 ::fidl_next::wire::Box::encode_present(out);
2437 } else {
2438 ::fidl_next::wire::Box::encode_absent(out);
2439 }
2440
2441 Ok(())
2442 }
2443 }
2444
2445 unsafe impl<'a, ___E>
2446 ::fidl_next::EncodeOption<
2447 ::fidl_next::wire::Box<
2448 'static,
2449 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2450 >,
2451 ___E,
2452 > for &'a BootManagerSetConfigurationUnbootableResponse
2453 where
2454 ___E: ::fidl_next::Encoder + ?Sized,
2455 &'a BootManagerSetConfigurationUnbootableResponse:
2456 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableResponse, ___E>,
2457 {
2458 #[inline]
2459 fn encode_option(
2460 this: ::core::option::Option<Self>,
2461 encoder: &mut ___E,
2462 out: &mut ::core::mem::MaybeUninit<
2463 ::fidl_next::wire::Box<
2464 'static,
2465 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2466 >,
2467 >,
2468 _: (),
2469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2470 if let Some(inner) = this {
2471 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2472 ::fidl_next::wire::Box::encode_present(out);
2473 } else {
2474 ::fidl_next::wire::Box::encode_absent(out);
2475 }
2476
2477 Ok(())
2478 }
2479 }
2480
2481 impl ::fidl_next::FromWire<crate::wire::BootManagerSetConfigurationUnbootableResponse>
2482 for BootManagerSetConfigurationUnbootableResponse
2483 {
2484 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2485 crate::wire::BootManagerSetConfigurationUnbootableResponse,
2486 Self,
2487 > = unsafe {
2488 ::fidl_next::CopyOptimization::enable_if(
2489 true
2490
2491 && <
2492 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
2493 >::COPY_OPTIMIZATION.is_enabled()
2494
2495 )
2496 };
2497
2498 #[inline]
2499 fn from_wire(wire: crate::wire::BootManagerSetConfigurationUnbootableResponse) -> Self {
2500 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
2501 }
2502 }
2503
2504 impl ::fidl_next::FromWireRef<crate::wire::BootManagerSetConfigurationUnbootableResponse>
2505 for BootManagerSetConfigurationUnbootableResponse
2506 {
2507 #[inline]
2508 fn from_wire_ref(
2509 wire: &crate::wire::BootManagerSetConfigurationUnbootableResponse,
2510 ) -> Self {
2511 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
2512 }
2513 }
2514
2515 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2516 #[repr(C)]
2517 pub struct BootManagerSetConfigurationHealthyRequest {
2518 pub configuration: crate::natural::Configuration,
2519 }
2520
2521 unsafe impl<___E>
2522 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyRequest, ___E>
2523 for BootManagerSetConfigurationHealthyRequest
2524 where
2525 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2526 {
2527 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2528 Self,
2529 crate::wire::BootManagerSetConfigurationHealthyRequest,
2530 > = unsafe {
2531 ::fidl_next::CopyOptimization::enable_if(
2532 true && <crate::natural::Configuration as ::fidl_next::Encode<
2533 crate::wire::Configuration,
2534 ___E,
2535 >>::COPY_OPTIMIZATION
2536 .is_enabled(),
2537 )
2538 };
2539
2540 #[inline]
2541 fn encode(
2542 self,
2543 encoder_: &mut ___E,
2544 out_: &mut ::core::mem::MaybeUninit<
2545 crate::wire::BootManagerSetConfigurationHealthyRequest,
2546 >,
2547 _: (),
2548 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2549 ::fidl_next::munge! {
2550 let crate::wire::BootManagerSetConfigurationHealthyRequest {
2551 configuration,
2552
2553 } = out_;
2554 }
2555
2556 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
2557
2558 let mut _field =
2559 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
2560
2561 Ok(())
2562 }
2563 }
2564
2565 unsafe impl<'a, ___E>
2566 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyRequest, ___E>
2567 for &'a BootManagerSetConfigurationHealthyRequest
2568 where
2569 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2570 {
2571 #[inline]
2572 fn encode(
2573 self,
2574 encoder_: &mut ___E,
2575 out_: &mut ::core::mem::MaybeUninit<
2576 crate::wire::BootManagerSetConfigurationHealthyRequest,
2577 >,
2578 _: (),
2579 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2580 ::fidl_next::munge! {
2581 let crate::wire::BootManagerSetConfigurationHealthyRequest {
2582 configuration,
2583
2584 } = out_;
2585 }
2586
2587 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
2588
2589 let mut _field =
2590 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
2591
2592 Ok(())
2593 }
2594 }
2595
2596 unsafe impl<___E>
2597 ::fidl_next::EncodeOption<
2598 ::fidl_next::wire::Box<'static, crate::wire::BootManagerSetConfigurationHealthyRequest>,
2599 ___E,
2600 > for BootManagerSetConfigurationHealthyRequest
2601 where
2602 ___E: ::fidl_next::Encoder + ?Sized,
2603 BootManagerSetConfigurationHealthyRequest:
2604 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyRequest, ___E>,
2605 {
2606 #[inline]
2607 fn encode_option(
2608 this: ::core::option::Option<Self>,
2609 encoder: &mut ___E,
2610 out: &mut ::core::mem::MaybeUninit<
2611 ::fidl_next::wire::Box<
2612 'static,
2613 crate::wire::BootManagerSetConfigurationHealthyRequest,
2614 >,
2615 >,
2616 _: (),
2617 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2618 if let Some(inner) = this {
2619 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2620 ::fidl_next::wire::Box::encode_present(out);
2621 } else {
2622 ::fidl_next::wire::Box::encode_absent(out);
2623 }
2624
2625 Ok(())
2626 }
2627 }
2628
2629 unsafe impl<'a, ___E>
2630 ::fidl_next::EncodeOption<
2631 ::fidl_next::wire::Box<'static, crate::wire::BootManagerSetConfigurationHealthyRequest>,
2632 ___E,
2633 > for &'a BootManagerSetConfigurationHealthyRequest
2634 where
2635 ___E: ::fidl_next::Encoder + ?Sized,
2636 &'a BootManagerSetConfigurationHealthyRequest:
2637 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyRequest, ___E>,
2638 {
2639 #[inline]
2640 fn encode_option(
2641 this: ::core::option::Option<Self>,
2642 encoder: &mut ___E,
2643 out: &mut ::core::mem::MaybeUninit<
2644 ::fidl_next::wire::Box<
2645 'static,
2646 crate::wire::BootManagerSetConfigurationHealthyRequest,
2647 >,
2648 >,
2649 _: (),
2650 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2651 if let Some(inner) = this {
2652 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2653 ::fidl_next::wire::Box::encode_present(out);
2654 } else {
2655 ::fidl_next::wire::Box::encode_absent(out);
2656 }
2657
2658 Ok(())
2659 }
2660 }
2661
2662 impl ::fidl_next::FromWire<crate::wire::BootManagerSetConfigurationHealthyRequest>
2663 for BootManagerSetConfigurationHealthyRequest
2664 {
2665 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2666 crate::wire::BootManagerSetConfigurationHealthyRequest,
2667 Self,
2668 > = unsafe {
2669 ::fidl_next::CopyOptimization::enable_if(
2670 true && <crate::natural::Configuration as ::fidl_next::FromWire<
2671 crate::wire::Configuration,
2672 >>::COPY_OPTIMIZATION
2673 .is_enabled(),
2674 )
2675 };
2676
2677 #[inline]
2678 fn from_wire(wire: crate::wire::BootManagerSetConfigurationHealthyRequest) -> Self {
2679 Self { configuration: ::fidl_next::FromWire::from_wire(wire.configuration) }
2680 }
2681 }
2682
2683 impl ::fidl_next::FromWireRef<crate::wire::BootManagerSetConfigurationHealthyRequest>
2684 for BootManagerSetConfigurationHealthyRequest
2685 {
2686 #[inline]
2687 fn from_wire_ref(wire: &crate::wire::BootManagerSetConfigurationHealthyRequest) -> Self {
2688 Self { configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration) }
2689 }
2690 }
2691
2692 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2693 #[repr(C)]
2694 pub struct BootManagerSetConfigurationHealthyResponse {
2695 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
2696 }
2697
2698 unsafe impl<___E>
2699 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyResponse, ___E>
2700 for BootManagerSetConfigurationHealthyResponse
2701 where
2702 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2703 {
2704 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2705 Self,
2706 crate::wire::BootManagerSetConfigurationHealthyResponse,
2707 > = unsafe {
2708 ::fidl_next::CopyOptimization::enable_if(
2709 true
2710
2711 && <
2712 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
2713 >::COPY_OPTIMIZATION.is_enabled()
2714
2715 )
2716 };
2717
2718 #[inline]
2719 fn encode(
2720 self,
2721 encoder_: &mut ___E,
2722 out_: &mut ::core::mem::MaybeUninit<
2723 crate::wire::BootManagerSetConfigurationHealthyResponse,
2724 >,
2725 _: (),
2726 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2727 ::fidl_next::munge! {
2728 let crate::wire::BootManagerSetConfigurationHealthyResponse {
2729 status,
2730
2731 } = out_;
2732 }
2733
2734 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2735
2736 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2737
2738 Ok(())
2739 }
2740 }
2741
2742 unsafe impl<'a, ___E>
2743 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyResponse, ___E>
2744 for &'a BootManagerSetConfigurationHealthyResponse
2745 where
2746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2747 {
2748 #[inline]
2749 fn encode(
2750 self,
2751 encoder_: &mut ___E,
2752 out_: &mut ::core::mem::MaybeUninit<
2753 crate::wire::BootManagerSetConfigurationHealthyResponse,
2754 >,
2755 _: (),
2756 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2757 ::fidl_next::munge! {
2758 let crate::wire::BootManagerSetConfigurationHealthyResponse {
2759 status,
2760
2761 } = out_;
2762 }
2763
2764 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
2765
2766 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2767
2768 Ok(())
2769 }
2770 }
2771
2772 unsafe impl<___E>
2773 ::fidl_next::EncodeOption<
2774 ::fidl_next::wire::Box<
2775 'static,
2776 crate::wire::BootManagerSetConfigurationHealthyResponse,
2777 >,
2778 ___E,
2779 > for BootManagerSetConfigurationHealthyResponse
2780 where
2781 ___E: ::fidl_next::Encoder + ?Sized,
2782 BootManagerSetConfigurationHealthyResponse:
2783 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyResponse, ___E>,
2784 {
2785 #[inline]
2786 fn encode_option(
2787 this: ::core::option::Option<Self>,
2788 encoder: &mut ___E,
2789 out: &mut ::core::mem::MaybeUninit<
2790 ::fidl_next::wire::Box<
2791 'static,
2792 crate::wire::BootManagerSetConfigurationHealthyResponse,
2793 >,
2794 >,
2795 _: (),
2796 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2797 if let Some(inner) = this {
2798 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2799 ::fidl_next::wire::Box::encode_present(out);
2800 } else {
2801 ::fidl_next::wire::Box::encode_absent(out);
2802 }
2803
2804 Ok(())
2805 }
2806 }
2807
2808 unsafe impl<'a, ___E>
2809 ::fidl_next::EncodeOption<
2810 ::fidl_next::wire::Box<
2811 'static,
2812 crate::wire::BootManagerSetConfigurationHealthyResponse,
2813 >,
2814 ___E,
2815 > for &'a BootManagerSetConfigurationHealthyResponse
2816 where
2817 ___E: ::fidl_next::Encoder + ?Sized,
2818 &'a BootManagerSetConfigurationHealthyResponse:
2819 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyResponse, ___E>,
2820 {
2821 #[inline]
2822 fn encode_option(
2823 this: ::core::option::Option<Self>,
2824 encoder: &mut ___E,
2825 out: &mut ::core::mem::MaybeUninit<
2826 ::fidl_next::wire::Box<
2827 'static,
2828 crate::wire::BootManagerSetConfigurationHealthyResponse,
2829 >,
2830 >,
2831 _: (),
2832 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2833 if let Some(inner) = this {
2834 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2835 ::fidl_next::wire::Box::encode_present(out);
2836 } else {
2837 ::fidl_next::wire::Box::encode_absent(out);
2838 }
2839
2840 Ok(())
2841 }
2842 }
2843
2844 impl ::fidl_next::FromWire<crate::wire::BootManagerSetConfigurationHealthyResponse>
2845 for BootManagerSetConfigurationHealthyResponse
2846 {
2847 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2848 crate::wire::BootManagerSetConfigurationHealthyResponse,
2849 Self,
2850 > = unsafe {
2851 ::fidl_next::CopyOptimization::enable_if(
2852 true
2853
2854 && <
2855 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
2856 >::COPY_OPTIMIZATION.is_enabled()
2857
2858 )
2859 };
2860
2861 #[inline]
2862 fn from_wire(wire: crate::wire::BootManagerSetConfigurationHealthyResponse) -> Self {
2863 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
2864 }
2865 }
2866
2867 impl ::fidl_next::FromWireRef<crate::wire::BootManagerSetConfigurationHealthyResponse>
2868 for BootManagerSetConfigurationHealthyResponse
2869 {
2870 #[inline]
2871 fn from_wire_ref(wire: &crate::wire::BootManagerSetConfigurationHealthyResponse) -> Self {
2872 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
2873 }
2874 }
2875
2876 pub type BootManagerSetOneShotRecoveryResponse = ();
2877
2878 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2879 #[repr(C)]
2880 pub struct BootManagerFlushResponse {
2881 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
2882 }
2883
2884 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BootManagerFlushResponse, ___E>
2885 for BootManagerFlushResponse
2886 where
2887 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2888 {
2889 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2890 Self,
2891 crate::wire::BootManagerFlushResponse,
2892 > = unsafe {
2893 ::fidl_next::CopyOptimization::enable_if(
2894 true
2895
2896 && <
2897 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
2898 >::COPY_OPTIMIZATION.is_enabled()
2899
2900 )
2901 };
2902
2903 #[inline]
2904 fn encode(
2905 self,
2906 encoder_: &mut ___E,
2907 out_: &mut ::core::mem::MaybeUninit<crate::wire::BootManagerFlushResponse>,
2908 _: (),
2909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2910 ::fidl_next::munge! {
2911 let crate::wire::BootManagerFlushResponse {
2912 status,
2913
2914 } = out_;
2915 }
2916
2917 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
2918
2919 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2920
2921 Ok(())
2922 }
2923 }
2924
2925 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BootManagerFlushResponse, ___E>
2926 for &'a BootManagerFlushResponse
2927 where
2928 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2929 {
2930 #[inline]
2931 fn encode(
2932 self,
2933 encoder_: &mut ___E,
2934 out_: &mut ::core::mem::MaybeUninit<crate::wire::BootManagerFlushResponse>,
2935 _: (),
2936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2937 ::fidl_next::munge! {
2938 let crate::wire::BootManagerFlushResponse {
2939 status,
2940
2941 } = out_;
2942 }
2943
2944 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
2945
2946 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
2947
2948 Ok(())
2949 }
2950 }
2951
2952 unsafe impl<___E>
2953 ::fidl_next::EncodeOption<
2954 ::fidl_next::wire::Box<'static, crate::wire::BootManagerFlushResponse>,
2955 ___E,
2956 > for BootManagerFlushResponse
2957 where
2958 ___E: ::fidl_next::Encoder + ?Sized,
2959 BootManagerFlushResponse: ::fidl_next::Encode<crate::wire::BootManagerFlushResponse, ___E>,
2960 {
2961 #[inline]
2962 fn encode_option(
2963 this: ::core::option::Option<Self>,
2964 encoder: &mut ___E,
2965 out: &mut ::core::mem::MaybeUninit<
2966 ::fidl_next::wire::Box<'static, crate::wire::BootManagerFlushResponse>,
2967 >,
2968 _: (),
2969 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2970 if let Some(inner) = this {
2971 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2972 ::fidl_next::wire::Box::encode_present(out);
2973 } else {
2974 ::fidl_next::wire::Box::encode_absent(out);
2975 }
2976
2977 Ok(())
2978 }
2979 }
2980
2981 unsafe impl<'a, ___E>
2982 ::fidl_next::EncodeOption<
2983 ::fidl_next::wire::Box<'static, crate::wire::BootManagerFlushResponse>,
2984 ___E,
2985 > for &'a BootManagerFlushResponse
2986 where
2987 ___E: ::fidl_next::Encoder + ?Sized,
2988 &'a BootManagerFlushResponse:
2989 ::fidl_next::Encode<crate::wire::BootManagerFlushResponse, ___E>,
2990 {
2991 #[inline]
2992 fn encode_option(
2993 this: ::core::option::Option<Self>,
2994 encoder: &mut ___E,
2995 out: &mut ::core::mem::MaybeUninit<
2996 ::fidl_next::wire::Box<'static, crate::wire::BootManagerFlushResponse>,
2997 >,
2998 _: (),
2999 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3000 if let Some(inner) = this {
3001 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3002 ::fidl_next::wire::Box::encode_present(out);
3003 } else {
3004 ::fidl_next::wire::Box::encode_absent(out);
3005 }
3006
3007 Ok(())
3008 }
3009 }
3010
3011 impl ::fidl_next::FromWire<crate::wire::BootManagerFlushResponse> for BootManagerFlushResponse {
3012 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3013 crate::wire::BootManagerFlushResponse,
3014 Self,
3015 > = unsafe {
3016 ::fidl_next::CopyOptimization::enable_if(
3017 true
3018
3019 && <
3020 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
3021 >::COPY_OPTIMIZATION.is_enabled()
3022
3023 )
3024 };
3025
3026 #[inline]
3027 fn from_wire(wire: crate::wire::BootManagerFlushResponse) -> Self {
3028 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
3029 }
3030 }
3031
3032 impl ::fidl_next::FromWireRef<crate::wire::BootManagerFlushResponse> for BootManagerFlushResponse {
3033 #[inline]
3034 fn from_wire_ref(wire: &crate::wire::BootManagerFlushResponse) -> Self {
3035 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
3036 }
3037 }
3038
3039 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3040 #[repr(C)]
3041 pub struct DataSinkReadAssetRequest {
3042 pub configuration: crate::natural::Configuration,
3043
3044 pub asset: crate::natural::Asset,
3045 }
3046
3047 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataSinkReadAssetRequest, ___E>
3048 for DataSinkReadAssetRequest
3049 where
3050 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3051 {
3052 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3053 Self,
3054 crate::wire::DataSinkReadAssetRequest,
3055 > = unsafe {
3056 ::fidl_next::CopyOptimization::enable_if(
3057 true
3058
3059 && <
3060 crate::natural::Configuration as ::fidl_next::Encode<crate::wire::Configuration, ___E>
3061 >::COPY_OPTIMIZATION.is_enabled()
3062
3063 && <
3064 crate::natural::Asset as ::fidl_next::Encode<crate::wire::Asset, ___E>
3065 >::COPY_OPTIMIZATION.is_enabled()
3066
3067 )
3068 };
3069
3070 #[inline]
3071 fn encode(
3072 self,
3073 encoder_: &mut ___E,
3074 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkReadAssetRequest>,
3075 _: (),
3076 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3077 ::fidl_next::munge! {
3078 let crate::wire::DataSinkReadAssetRequest {
3079 configuration,
3080 asset,
3081
3082 } = out_;
3083 }
3084
3085 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
3086
3087 let mut _field =
3088 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
3089
3090 ::fidl_next::Encode::encode(self.asset, encoder_, asset, ())?;
3091
3092 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(asset.as_mut_ptr()) };
3093
3094 Ok(())
3095 }
3096 }
3097
3098 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DataSinkReadAssetRequest, ___E>
3099 for &'a DataSinkReadAssetRequest
3100 where
3101 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3102 {
3103 #[inline]
3104 fn encode(
3105 self,
3106 encoder_: &mut ___E,
3107 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkReadAssetRequest>,
3108 _: (),
3109 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3110 ::fidl_next::munge! {
3111 let crate::wire::DataSinkReadAssetRequest {
3112 configuration,
3113 asset,
3114
3115 } = out_;
3116 }
3117
3118 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
3119
3120 let mut _field =
3121 unsafe { ::fidl_next::Slot::new_unchecked(configuration.as_mut_ptr()) };
3122
3123 ::fidl_next::Encode::encode(&self.asset, encoder_, asset, ())?;
3124
3125 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(asset.as_mut_ptr()) };
3126
3127 Ok(())
3128 }
3129 }
3130
3131 unsafe impl<___E>
3132 ::fidl_next::EncodeOption<
3133 ::fidl_next::wire::Box<'static, crate::wire::DataSinkReadAssetRequest>,
3134 ___E,
3135 > for DataSinkReadAssetRequest
3136 where
3137 ___E: ::fidl_next::Encoder + ?Sized,
3138 DataSinkReadAssetRequest: ::fidl_next::Encode<crate::wire::DataSinkReadAssetRequest, ___E>,
3139 {
3140 #[inline]
3141 fn encode_option(
3142 this: ::core::option::Option<Self>,
3143 encoder: &mut ___E,
3144 out: &mut ::core::mem::MaybeUninit<
3145 ::fidl_next::wire::Box<'static, crate::wire::DataSinkReadAssetRequest>,
3146 >,
3147 _: (),
3148 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3149 if let Some(inner) = this {
3150 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3151 ::fidl_next::wire::Box::encode_present(out);
3152 } else {
3153 ::fidl_next::wire::Box::encode_absent(out);
3154 }
3155
3156 Ok(())
3157 }
3158 }
3159
3160 unsafe impl<'a, ___E>
3161 ::fidl_next::EncodeOption<
3162 ::fidl_next::wire::Box<'static, crate::wire::DataSinkReadAssetRequest>,
3163 ___E,
3164 > for &'a DataSinkReadAssetRequest
3165 where
3166 ___E: ::fidl_next::Encoder + ?Sized,
3167 &'a DataSinkReadAssetRequest:
3168 ::fidl_next::Encode<crate::wire::DataSinkReadAssetRequest, ___E>,
3169 {
3170 #[inline]
3171 fn encode_option(
3172 this: ::core::option::Option<Self>,
3173 encoder: &mut ___E,
3174 out: &mut ::core::mem::MaybeUninit<
3175 ::fidl_next::wire::Box<'static, crate::wire::DataSinkReadAssetRequest>,
3176 >,
3177 _: (),
3178 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3179 if let Some(inner) = this {
3180 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3181 ::fidl_next::wire::Box::encode_present(out);
3182 } else {
3183 ::fidl_next::wire::Box::encode_absent(out);
3184 }
3185
3186 Ok(())
3187 }
3188 }
3189
3190 impl ::fidl_next::FromWire<crate::wire::DataSinkReadAssetRequest> for DataSinkReadAssetRequest {
3191 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3192 crate::wire::DataSinkReadAssetRequest,
3193 Self,
3194 > = unsafe {
3195 ::fidl_next::CopyOptimization::enable_if(
3196 true
3197
3198 && <
3199 crate::natural::Configuration as ::fidl_next::FromWire<crate::wire::Configuration>
3200 >::COPY_OPTIMIZATION.is_enabled()
3201
3202 && <
3203 crate::natural::Asset as ::fidl_next::FromWire<crate::wire::Asset>
3204 >::COPY_OPTIMIZATION.is_enabled()
3205
3206 )
3207 };
3208
3209 #[inline]
3210 fn from_wire(wire: crate::wire::DataSinkReadAssetRequest) -> Self {
3211 Self {
3212 configuration: ::fidl_next::FromWire::from_wire(wire.configuration),
3213
3214 asset: ::fidl_next::FromWire::from_wire(wire.asset),
3215 }
3216 }
3217 }
3218
3219 impl ::fidl_next::FromWireRef<crate::wire::DataSinkReadAssetRequest> for DataSinkReadAssetRequest {
3220 #[inline]
3221 fn from_wire_ref(wire: &crate::wire::DataSinkReadAssetRequest) -> Self {
3222 Self {
3223 configuration: ::fidl_next::FromWireRef::from_wire_ref(&wire.configuration),
3224
3225 asset: ::fidl_next::FromWireRef::from_wire_ref(&wire.asset),
3226 }
3227 }
3228 }
3229
3230 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3231 #[repr(C)]
3232 pub struct DataSinkWriteAssetResponse {
3233 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
3234 }
3235
3236 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataSinkWriteAssetResponse, ___E>
3237 for DataSinkWriteAssetResponse
3238 where
3239 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3240 {
3241 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3242 Self,
3243 crate::wire::DataSinkWriteAssetResponse,
3244 > = unsafe {
3245 ::fidl_next::CopyOptimization::enable_if(
3246 true
3247
3248 && <
3249 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
3250 >::COPY_OPTIMIZATION.is_enabled()
3251
3252 )
3253 };
3254
3255 #[inline]
3256 fn encode(
3257 self,
3258 encoder_: &mut ___E,
3259 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteAssetResponse>,
3260 _: (),
3261 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3262 ::fidl_next::munge! {
3263 let crate::wire::DataSinkWriteAssetResponse {
3264 status,
3265
3266 } = out_;
3267 }
3268
3269 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
3270
3271 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
3272
3273 Ok(())
3274 }
3275 }
3276
3277 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DataSinkWriteAssetResponse, ___E>
3278 for &'a DataSinkWriteAssetResponse
3279 where
3280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3281 {
3282 #[inline]
3283 fn encode(
3284 self,
3285 encoder_: &mut ___E,
3286 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteAssetResponse>,
3287 _: (),
3288 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3289 ::fidl_next::munge! {
3290 let crate::wire::DataSinkWriteAssetResponse {
3291 status,
3292
3293 } = out_;
3294 }
3295
3296 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
3297
3298 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
3299
3300 Ok(())
3301 }
3302 }
3303
3304 unsafe impl<___E>
3305 ::fidl_next::EncodeOption<
3306 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteAssetResponse>,
3307 ___E,
3308 > for DataSinkWriteAssetResponse
3309 where
3310 ___E: ::fidl_next::Encoder + ?Sized,
3311 DataSinkWriteAssetResponse:
3312 ::fidl_next::Encode<crate::wire::DataSinkWriteAssetResponse, ___E>,
3313 {
3314 #[inline]
3315 fn encode_option(
3316 this: ::core::option::Option<Self>,
3317 encoder: &mut ___E,
3318 out: &mut ::core::mem::MaybeUninit<
3319 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteAssetResponse>,
3320 >,
3321 _: (),
3322 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3323 if let Some(inner) = this {
3324 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3325 ::fidl_next::wire::Box::encode_present(out);
3326 } else {
3327 ::fidl_next::wire::Box::encode_absent(out);
3328 }
3329
3330 Ok(())
3331 }
3332 }
3333
3334 unsafe impl<'a, ___E>
3335 ::fidl_next::EncodeOption<
3336 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteAssetResponse>,
3337 ___E,
3338 > for &'a DataSinkWriteAssetResponse
3339 where
3340 ___E: ::fidl_next::Encoder + ?Sized,
3341 &'a DataSinkWriteAssetResponse:
3342 ::fidl_next::Encode<crate::wire::DataSinkWriteAssetResponse, ___E>,
3343 {
3344 #[inline]
3345 fn encode_option(
3346 this: ::core::option::Option<Self>,
3347 encoder: &mut ___E,
3348 out: &mut ::core::mem::MaybeUninit<
3349 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteAssetResponse>,
3350 >,
3351 _: (),
3352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3353 if let Some(inner) = this {
3354 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3355 ::fidl_next::wire::Box::encode_present(out);
3356 } else {
3357 ::fidl_next::wire::Box::encode_absent(out);
3358 }
3359
3360 Ok(())
3361 }
3362 }
3363
3364 impl ::fidl_next::FromWire<crate::wire::DataSinkWriteAssetResponse> for DataSinkWriteAssetResponse {
3365 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3366 crate::wire::DataSinkWriteAssetResponse,
3367 Self,
3368 > = unsafe {
3369 ::fidl_next::CopyOptimization::enable_if(
3370 true
3371
3372 && <
3373 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
3374 >::COPY_OPTIMIZATION.is_enabled()
3375
3376 )
3377 };
3378
3379 #[inline]
3380 fn from_wire(wire: crate::wire::DataSinkWriteAssetResponse) -> Self {
3381 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
3382 }
3383 }
3384
3385 impl ::fidl_next::FromWireRef<crate::wire::DataSinkWriteAssetResponse>
3386 for DataSinkWriteAssetResponse
3387 {
3388 #[inline]
3389 fn from_wire_ref(wire: &crate::wire::DataSinkWriteAssetResponse) -> Self {
3390 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
3391 }
3392 }
3393
3394 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3395 pub enum WriteFirmwareResult {
3396 Status(::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>),
3397
3398 Unsupported(bool),
3399 }
3400
3401 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WriteFirmwareResult, ___E>
3402 for WriteFirmwareResult
3403 where
3404 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3405 {
3406 #[inline]
3407 fn encode(
3408 self,
3409 encoder: &mut ___E,
3410 out: &mut ::core::mem::MaybeUninit<crate::wire::WriteFirmwareResult>,
3411 _: (),
3412 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3413 ::fidl_next::munge!(let crate::wire::WriteFirmwareResult { raw, _phantom: _ } = out);
3414
3415 match self {
3416 Self::Status(value) => ::fidl_next::wire::Union::encode_as_static::<
3417 ___E,
3418 ::fidl_next::wire::fuchsia::StatusResult,
3419 >(value, 1, encoder, raw, ())?,
3420
3421 Self::Unsupported(value) => {
3422 ::fidl_next::wire::Union::encode_as_static::<___E, bool>(
3423 value,
3424 2,
3425 encoder,
3426 raw,
3427 (),
3428 )?
3429 }
3430 }
3431
3432 Ok(())
3433 }
3434 }
3435
3436 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WriteFirmwareResult, ___E>
3437 for &'a WriteFirmwareResult
3438 where
3439 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3440 {
3441 #[inline]
3442 fn encode(
3443 self,
3444 encoder: &mut ___E,
3445 out: &mut ::core::mem::MaybeUninit<crate::wire::WriteFirmwareResult>,
3446 _: (),
3447 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3448 ::fidl_next::munge!(let crate::wire::WriteFirmwareResult { raw, _phantom: _ } = out);
3449
3450 match self {
3451 WriteFirmwareResult::Status(value) => ::fidl_next::wire::Union::encode_as_static::<
3452 ___E,
3453 ::fidl_next::wire::fuchsia::StatusResult,
3454 >(value, 1, encoder, raw, ())?,
3455
3456 WriteFirmwareResult::Unsupported(value) => {
3457 ::fidl_next::wire::Union::encode_as_static::<___E, bool>(
3458 value,
3459 2,
3460 encoder,
3461 raw,
3462 (),
3463 )?
3464 }
3465 }
3466
3467 Ok(())
3468 }
3469 }
3470
3471 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::WriteFirmwareResult, ___E>
3472 for WriteFirmwareResult
3473 where
3474 ___E: ?Sized,
3475 WriteFirmwareResult: ::fidl_next::Encode<crate::wire::WriteFirmwareResult, ___E>,
3476 {
3477 #[inline]
3478 fn encode_option(
3479 this: ::core::option::Option<Self>,
3480 encoder: &mut ___E,
3481 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::WriteFirmwareResult>,
3482 _: (),
3483 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3484 ::fidl_next::munge!(let crate::wire_optional::WriteFirmwareResult { raw, _phantom: _ } = &mut *out);
3485
3486 if let Some(inner) = this {
3487 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3488 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3489 } else {
3490 ::fidl_next::wire::Union::encode_absent(raw);
3491 }
3492
3493 Ok(())
3494 }
3495 }
3496
3497 unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::WriteFirmwareResult, ___E>
3498 for &'a WriteFirmwareResult
3499 where
3500 ___E: ?Sized,
3501 &'a WriteFirmwareResult: ::fidl_next::Encode<crate::wire::WriteFirmwareResult, ___E>,
3502 {
3503 #[inline]
3504 fn encode_option(
3505 this: ::core::option::Option<Self>,
3506 encoder: &mut ___E,
3507 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::WriteFirmwareResult>,
3508 _: (),
3509 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3510 ::fidl_next::munge!(let crate::wire_optional::WriteFirmwareResult { raw, _phantom: _ } = &mut *out);
3511
3512 if let Some(inner) = this {
3513 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3514 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3515 } else {
3516 ::fidl_next::wire::Union::encode_absent(raw);
3517 }
3518
3519 Ok(())
3520 }
3521 }
3522
3523 impl ::fidl_next::FromWire<crate::wire::WriteFirmwareResult> for WriteFirmwareResult {
3524 #[inline]
3525 fn from_wire(wire: crate::wire::WriteFirmwareResult) -> Self {
3526 let wire = ::core::mem::ManuallyDrop::new(wire);
3527 match wire.raw.ordinal() {
3528 1 => Self::Status(::fidl_next::FromWire::from_wire(unsafe {
3529 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
3530 })),
3531
3532 2 => Self::Unsupported(::fidl_next::FromWire::from_wire(unsafe {
3533 wire.raw.get().read_unchecked::<bool>()
3534 })),
3535
3536 _ => unsafe { ::core::hint::unreachable_unchecked() },
3537 }
3538 }
3539 }
3540
3541 impl ::fidl_next::FromWireRef<crate::wire::WriteFirmwareResult> for WriteFirmwareResult {
3542 #[inline]
3543 fn from_wire_ref(wire: &crate::wire::WriteFirmwareResult) -> Self {
3544 match wire.raw.ordinal() {
3545 1 => Self::Status(::fidl_next::FromWireRef::from_wire_ref(unsafe {
3546 wire.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
3547 })),
3548
3549 2 => Self::Unsupported(::fidl_next::FromWireRef::from_wire_ref(unsafe {
3550 wire.raw.get().deref_unchecked::<bool>()
3551 })),
3552
3553 _ => unsafe { ::core::hint::unreachable_unchecked() },
3554 }
3555 }
3556 }
3557
3558 impl ::fidl_next::FromWireOption<crate::wire_optional::WriteFirmwareResult>
3559 for WriteFirmwareResult
3560 {
3561 #[inline]
3562 fn from_wire_option(
3563 wire: crate::wire_optional::WriteFirmwareResult,
3564 ) -> ::core::option::Option<Self> {
3565 if let Some(inner) = wire.into_option() {
3566 Some(::fidl_next::FromWire::from_wire(inner))
3567 } else {
3568 None
3569 }
3570 }
3571 }
3572
3573 impl ::fidl_next::FromWireOption<crate::wire_optional::WriteFirmwareResult>
3574 for Box<WriteFirmwareResult>
3575 {
3576 #[inline]
3577 fn from_wire_option(
3578 wire: crate::wire_optional::WriteFirmwareResult,
3579 ) -> ::core::option::Option<Self> {
3580 <WriteFirmwareResult as ::fidl_next::FromWireOption<
3581 crate::wire_optional::WriteFirmwareResult,
3582 >>::from_wire_option(wire)
3583 .map(Box::new)
3584 }
3585 }
3586
3587 impl ::fidl_next::FromWireOptionRef<crate::wire_optional::WriteFirmwareResult>
3588 for Box<WriteFirmwareResult>
3589 {
3590 #[inline]
3591 fn from_wire_option_ref(
3592 wire: &crate::wire_optional::WriteFirmwareResult,
3593 ) -> ::core::option::Option<Self> {
3594 if let Some(inner) = wire.as_ref() {
3595 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
3596 } else {
3597 None
3598 }
3599 }
3600 }
3601
3602 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3603 pub struct DataSinkWriteFirmwareResponse {
3604 pub result: crate::natural::WriteFirmwareResult,
3605 }
3606
3607 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataSinkWriteFirmwareResponse, ___E>
3608 for DataSinkWriteFirmwareResponse
3609 where
3610 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3611 {
3612 #[inline]
3613 fn encode(
3614 self,
3615 encoder_: &mut ___E,
3616 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteFirmwareResponse>,
3617 _: (),
3618 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3619 ::fidl_next::munge! {
3620 let crate::wire::DataSinkWriteFirmwareResponse {
3621 result,
3622
3623 } = out_;
3624 }
3625
3626 ::fidl_next::Encode::encode(self.result, encoder_, result, ())?;
3627
3628 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(result.as_mut_ptr()) };
3629
3630 Ok(())
3631 }
3632 }
3633
3634 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DataSinkWriteFirmwareResponse, ___E>
3635 for &'a DataSinkWriteFirmwareResponse
3636 where
3637 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3638 {
3639 #[inline]
3640 fn encode(
3641 self,
3642 encoder_: &mut ___E,
3643 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteFirmwareResponse>,
3644 _: (),
3645 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3646 ::fidl_next::munge! {
3647 let crate::wire::DataSinkWriteFirmwareResponse {
3648 result,
3649
3650 } = out_;
3651 }
3652
3653 ::fidl_next::Encode::encode(&self.result, encoder_, result, ())?;
3654
3655 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(result.as_mut_ptr()) };
3656
3657 Ok(())
3658 }
3659 }
3660
3661 unsafe impl<___E>
3662 ::fidl_next::EncodeOption<
3663 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteFirmwareResponse>,
3664 ___E,
3665 > for DataSinkWriteFirmwareResponse
3666 where
3667 ___E: ::fidl_next::Encoder + ?Sized,
3668 DataSinkWriteFirmwareResponse:
3669 ::fidl_next::Encode<crate::wire::DataSinkWriteFirmwareResponse, ___E>,
3670 {
3671 #[inline]
3672 fn encode_option(
3673 this: ::core::option::Option<Self>,
3674 encoder: &mut ___E,
3675 out: &mut ::core::mem::MaybeUninit<
3676 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteFirmwareResponse>,
3677 >,
3678 _: (),
3679 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3680 if let Some(inner) = this {
3681 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3682 ::fidl_next::wire::Box::encode_present(out);
3683 } else {
3684 ::fidl_next::wire::Box::encode_absent(out);
3685 }
3686
3687 Ok(())
3688 }
3689 }
3690
3691 unsafe impl<'a, ___E>
3692 ::fidl_next::EncodeOption<
3693 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteFirmwareResponse>,
3694 ___E,
3695 > for &'a DataSinkWriteFirmwareResponse
3696 where
3697 ___E: ::fidl_next::Encoder + ?Sized,
3698 &'a DataSinkWriteFirmwareResponse:
3699 ::fidl_next::Encode<crate::wire::DataSinkWriteFirmwareResponse, ___E>,
3700 {
3701 #[inline]
3702 fn encode_option(
3703 this: ::core::option::Option<Self>,
3704 encoder: &mut ___E,
3705 out: &mut ::core::mem::MaybeUninit<
3706 ::fidl_next::wire::Box<'static, crate::wire::DataSinkWriteFirmwareResponse>,
3707 >,
3708 _: (),
3709 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3710 if let Some(inner) = this {
3711 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3712 ::fidl_next::wire::Box::encode_present(out);
3713 } else {
3714 ::fidl_next::wire::Box::encode_absent(out);
3715 }
3716
3717 Ok(())
3718 }
3719 }
3720
3721 impl ::fidl_next::FromWire<crate::wire::DataSinkWriteFirmwareResponse>
3722 for DataSinkWriteFirmwareResponse
3723 {
3724 #[inline]
3725 fn from_wire(wire: crate::wire::DataSinkWriteFirmwareResponse) -> Self {
3726 Self { result: ::fidl_next::FromWire::from_wire(wire.result) }
3727 }
3728 }
3729
3730 impl ::fidl_next::FromWireRef<crate::wire::DataSinkWriteFirmwareResponse>
3731 for DataSinkWriteFirmwareResponse
3732 {
3733 #[inline]
3734 fn from_wire_ref(wire: &crate::wire::DataSinkWriteFirmwareResponse) -> Self {
3735 Self { result: ::fidl_next::FromWireRef::from_wire_ref(&wire.result) }
3736 }
3737 }
3738
3739 pub type DataSinkWriteOpaqueVolumeResponse = ();
3740
3741 pub type DataSinkWriteSparseVolumeResponse = ();
3742
3743 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3744 #[repr(C)]
3745 pub struct DataSinkFlushResponse {
3746 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
3747 }
3748
3749 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataSinkFlushResponse, ___E>
3750 for DataSinkFlushResponse
3751 where
3752 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3753 {
3754 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3755 Self,
3756 crate::wire::DataSinkFlushResponse,
3757 > = unsafe {
3758 ::fidl_next::CopyOptimization::enable_if(
3759 true
3760
3761 && <
3762 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
3763 >::COPY_OPTIMIZATION.is_enabled()
3764
3765 )
3766 };
3767
3768 #[inline]
3769 fn encode(
3770 self,
3771 encoder_: &mut ___E,
3772 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkFlushResponse>,
3773 _: (),
3774 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3775 ::fidl_next::munge! {
3776 let crate::wire::DataSinkFlushResponse {
3777 status,
3778
3779 } = out_;
3780 }
3781
3782 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
3783
3784 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
3785
3786 Ok(())
3787 }
3788 }
3789
3790 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DataSinkFlushResponse, ___E>
3791 for &'a DataSinkFlushResponse
3792 where
3793 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3794 {
3795 #[inline]
3796 fn encode(
3797 self,
3798 encoder_: &mut ___E,
3799 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkFlushResponse>,
3800 _: (),
3801 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3802 ::fidl_next::munge! {
3803 let crate::wire::DataSinkFlushResponse {
3804 status,
3805
3806 } = out_;
3807 }
3808
3809 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
3810
3811 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
3812
3813 Ok(())
3814 }
3815 }
3816
3817 unsafe impl<___E>
3818 ::fidl_next::EncodeOption<
3819 ::fidl_next::wire::Box<'static, crate::wire::DataSinkFlushResponse>,
3820 ___E,
3821 > for DataSinkFlushResponse
3822 where
3823 ___E: ::fidl_next::Encoder + ?Sized,
3824 DataSinkFlushResponse: ::fidl_next::Encode<crate::wire::DataSinkFlushResponse, ___E>,
3825 {
3826 #[inline]
3827 fn encode_option(
3828 this: ::core::option::Option<Self>,
3829 encoder: &mut ___E,
3830 out: &mut ::core::mem::MaybeUninit<
3831 ::fidl_next::wire::Box<'static, crate::wire::DataSinkFlushResponse>,
3832 >,
3833 _: (),
3834 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3835 if let Some(inner) = this {
3836 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3837 ::fidl_next::wire::Box::encode_present(out);
3838 } else {
3839 ::fidl_next::wire::Box::encode_absent(out);
3840 }
3841
3842 Ok(())
3843 }
3844 }
3845
3846 unsafe impl<'a, ___E>
3847 ::fidl_next::EncodeOption<
3848 ::fidl_next::wire::Box<'static, crate::wire::DataSinkFlushResponse>,
3849 ___E,
3850 > for &'a DataSinkFlushResponse
3851 where
3852 ___E: ::fidl_next::Encoder + ?Sized,
3853 &'a DataSinkFlushResponse: ::fidl_next::Encode<crate::wire::DataSinkFlushResponse, ___E>,
3854 {
3855 #[inline]
3856 fn encode_option(
3857 this: ::core::option::Option<Self>,
3858 encoder: &mut ___E,
3859 out: &mut ::core::mem::MaybeUninit<
3860 ::fidl_next::wire::Box<'static, crate::wire::DataSinkFlushResponse>,
3861 >,
3862 _: (),
3863 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3864 if let Some(inner) = this {
3865 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3866 ::fidl_next::wire::Box::encode_present(out);
3867 } else {
3868 ::fidl_next::wire::Box::encode_absent(out);
3869 }
3870
3871 Ok(())
3872 }
3873 }
3874
3875 impl ::fidl_next::FromWire<crate::wire::DataSinkFlushResponse> for DataSinkFlushResponse {
3876 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3877 crate::wire::DataSinkFlushResponse,
3878 Self,
3879 > = unsafe {
3880 ::fidl_next::CopyOptimization::enable_if(
3881 true
3882
3883 && <
3884 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
3885 >::COPY_OPTIMIZATION.is_enabled()
3886
3887 )
3888 };
3889
3890 #[inline]
3891 fn from_wire(wire: crate::wire::DataSinkFlushResponse) -> Self {
3892 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
3893 }
3894 }
3895
3896 impl ::fidl_next::FromWireRef<crate::wire::DataSinkFlushResponse> for DataSinkFlushResponse {
3897 #[inline]
3898 fn from_wire_ref(wire: &crate::wire::DataSinkFlushResponse) -> Self {
3899 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
3900 }
3901 }
3902
3903 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3904 #[repr(C)]
3905 pub struct DynamicDataSinkInitializePartitionTablesResponse {
3906 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
3907 }
3908
3909 unsafe impl<___E>
3910 ::fidl_next::Encode<crate::wire::DynamicDataSinkInitializePartitionTablesResponse, ___E>
3911 for DynamicDataSinkInitializePartitionTablesResponse
3912 where
3913 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3914 {
3915 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3916 Self,
3917 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
3918 > = unsafe {
3919 ::fidl_next::CopyOptimization::enable_if(
3920 true
3921
3922 && <
3923 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
3924 >::COPY_OPTIMIZATION.is_enabled()
3925
3926 )
3927 };
3928
3929 #[inline]
3930 fn encode(
3931 self,
3932 encoder_: &mut ___E,
3933 out_: &mut ::core::mem::MaybeUninit<
3934 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
3935 >,
3936 _: (),
3937 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3938 ::fidl_next::munge! {
3939 let crate::wire::DynamicDataSinkInitializePartitionTablesResponse {
3940 status,
3941
3942 } = out_;
3943 }
3944
3945 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
3946
3947 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
3948
3949 Ok(())
3950 }
3951 }
3952
3953 unsafe impl<'a, ___E>
3954 ::fidl_next::Encode<crate::wire::DynamicDataSinkInitializePartitionTablesResponse, ___E>
3955 for &'a DynamicDataSinkInitializePartitionTablesResponse
3956 where
3957 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3958 {
3959 #[inline]
3960 fn encode(
3961 self,
3962 encoder_: &mut ___E,
3963 out_: &mut ::core::mem::MaybeUninit<
3964 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
3965 >,
3966 _: (),
3967 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3968 ::fidl_next::munge! {
3969 let crate::wire::DynamicDataSinkInitializePartitionTablesResponse {
3970 status,
3971
3972 } = out_;
3973 }
3974
3975 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
3976
3977 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
3978
3979 Ok(())
3980 }
3981 }
3982
3983 unsafe impl<___E>
3984 ::fidl_next::EncodeOption<
3985 ::fidl_next::wire::Box<
3986 'static,
3987 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
3988 >,
3989 ___E,
3990 > for DynamicDataSinkInitializePartitionTablesResponse
3991 where
3992 ___E: ::fidl_next::Encoder + ?Sized,
3993 DynamicDataSinkInitializePartitionTablesResponse: ::fidl_next::Encode<crate::wire::DynamicDataSinkInitializePartitionTablesResponse, ___E>,
3994 {
3995 #[inline]
3996 fn encode_option(
3997 this: ::core::option::Option<Self>,
3998 encoder: &mut ___E,
3999 out: &mut ::core::mem::MaybeUninit<
4000 ::fidl_next::wire::Box<
4001 'static,
4002 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
4003 >,
4004 >,
4005 _: (),
4006 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4007 if let Some(inner) = this {
4008 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4009 ::fidl_next::wire::Box::encode_present(out);
4010 } else {
4011 ::fidl_next::wire::Box::encode_absent(out);
4012 }
4013
4014 Ok(())
4015 }
4016 }
4017
4018 unsafe impl<'a, ___E>
4019 ::fidl_next::EncodeOption<
4020 ::fidl_next::wire::Box<
4021 'static,
4022 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
4023 >,
4024 ___E,
4025 > for &'a DynamicDataSinkInitializePartitionTablesResponse
4026 where
4027 ___E: ::fidl_next::Encoder + ?Sized,
4028 &'a DynamicDataSinkInitializePartitionTablesResponse: ::fidl_next::Encode<crate::wire::DynamicDataSinkInitializePartitionTablesResponse, ___E>,
4029 {
4030 #[inline]
4031 fn encode_option(
4032 this: ::core::option::Option<Self>,
4033 encoder: &mut ___E,
4034 out: &mut ::core::mem::MaybeUninit<
4035 ::fidl_next::wire::Box<
4036 'static,
4037 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
4038 >,
4039 >,
4040 _: (),
4041 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4042 if let Some(inner) = this {
4043 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4044 ::fidl_next::wire::Box::encode_present(out);
4045 } else {
4046 ::fidl_next::wire::Box::encode_absent(out);
4047 }
4048
4049 Ok(())
4050 }
4051 }
4052
4053 impl ::fidl_next::FromWire<crate::wire::DynamicDataSinkInitializePartitionTablesResponse>
4054 for DynamicDataSinkInitializePartitionTablesResponse
4055 {
4056 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4057 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
4058 Self,
4059 > = unsafe {
4060 ::fidl_next::CopyOptimization::enable_if(
4061 true
4062
4063 && <
4064 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
4065 >::COPY_OPTIMIZATION.is_enabled()
4066
4067 )
4068 };
4069
4070 #[inline]
4071 fn from_wire(wire: crate::wire::DynamicDataSinkInitializePartitionTablesResponse) -> Self {
4072 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
4073 }
4074 }
4075
4076 impl ::fidl_next::FromWireRef<crate::wire::DynamicDataSinkInitializePartitionTablesResponse>
4077 for DynamicDataSinkInitializePartitionTablesResponse
4078 {
4079 #[inline]
4080 fn from_wire_ref(
4081 wire: &crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
4082 ) -> Self {
4083 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
4084 }
4085 }
4086
4087 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4088 #[repr(C)]
4089 pub struct DynamicDataSinkWipePartitionTablesResponse {
4090 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
4091 }
4092
4093 unsafe impl<___E>
4094 ::fidl_next::Encode<crate::wire::DynamicDataSinkWipePartitionTablesResponse, ___E>
4095 for DynamicDataSinkWipePartitionTablesResponse
4096 where
4097 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4098 {
4099 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4100 Self,
4101 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4102 > = unsafe {
4103 ::fidl_next::CopyOptimization::enable_if(
4104 true
4105
4106 && <
4107 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
4108 >::COPY_OPTIMIZATION.is_enabled()
4109
4110 )
4111 };
4112
4113 #[inline]
4114 fn encode(
4115 self,
4116 encoder_: &mut ___E,
4117 out_: &mut ::core::mem::MaybeUninit<
4118 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4119 >,
4120 _: (),
4121 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4122 ::fidl_next::munge! {
4123 let crate::wire::DynamicDataSinkWipePartitionTablesResponse {
4124 status,
4125
4126 } = out_;
4127 }
4128
4129 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
4130
4131 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
4132
4133 Ok(())
4134 }
4135 }
4136
4137 unsafe impl<'a, ___E>
4138 ::fidl_next::Encode<crate::wire::DynamicDataSinkWipePartitionTablesResponse, ___E>
4139 for &'a DynamicDataSinkWipePartitionTablesResponse
4140 where
4141 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4142 {
4143 #[inline]
4144 fn encode(
4145 self,
4146 encoder_: &mut ___E,
4147 out_: &mut ::core::mem::MaybeUninit<
4148 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4149 >,
4150 _: (),
4151 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4152 ::fidl_next::munge! {
4153 let crate::wire::DynamicDataSinkWipePartitionTablesResponse {
4154 status,
4155
4156 } = out_;
4157 }
4158
4159 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
4160
4161 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
4162
4163 Ok(())
4164 }
4165 }
4166
4167 unsafe impl<___E>
4168 ::fidl_next::EncodeOption<
4169 ::fidl_next::wire::Box<
4170 'static,
4171 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4172 >,
4173 ___E,
4174 > for DynamicDataSinkWipePartitionTablesResponse
4175 where
4176 ___E: ::fidl_next::Encoder + ?Sized,
4177 DynamicDataSinkWipePartitionTablesResponse:
4178 ::fidl_next::Encode<crate::wire::DynamicDataSinkWipePartitionTablesResponse, ___E>,
4179 {
4180 #[inline]
4181 fn encode_option(
4182 this: ::core::option::Option<Self>,
4183 encoder: &mut ___E,
4184 out: &mut ::core::mem::MaybeUninit<
4185 ::fidl_next::wire::Box<
4186 'static,
4187 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4188 >,
4189 >,
4190 _: (),
4191 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4192 if let Some(inner) = this {
4193 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4194 ::fidl_next::wire::Box::encode_present(out);
4195 } else {
4196 ::fidl_next::wire::Box::encode_absent(out);
4197 }
4198
4199 Ok(())
4200 }
4201 }
4202
4203 unsafe impl<'a, ___E>
4204 ::fidl_next::EncodeOption<
4205 ::fidl_next::wire::Box<
4206 'static,
4207 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4208 >,
4209 ___E,
4210 > for &'a DynamicDataSinkWipePartitionTablesResponse
4211 where
4212 ___E: ::fidl_next::Encoder + ?Sized,
4213 &'a DynamicDataSinkWipePartitionTablesResponse:
4214 ::fidl_next::Encode<crate::wire::DynamicDataSinkWipePartitionTablesResponse, ___E>,
4215 {
4216 #[inline]
4217 fn encode_option(
4218 this: ::core::option::Option<Self>,
4219 encoder: &mut ___E,
4220 out: &mut ::core::mem::MaybeUninit<
4221 ::fidl_next::wire::Box<
4222 'static,
4223 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4224 >,
4225 >,
4226 _: (),
4227 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4228 if let Some(inner) = this {
4229 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4230 ::fidl_next::wire::Box::encode_present(out);
4231 } else {
4232 ::fidl_next::wire::Box::encode_absent(out);
4233 }
4234
4235 Ok(())
4236 }
4237 }
4238
4239 impl ::fidl_next::FromWire<crate::wire::DynamicDataSinkWipePartitionTablesResponse>
4240 for DynamicDataSinkWipePartitionTablesResponse
4241 {
4242 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4243 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
4244 Self,
4245 > = unsafe {
4246 ::fidl_next::CopyOptimization::enable_if(
4247 true
4248
4249 && <
4250 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
4251 >::COPY_OPTIMIZATION.is_enabled()
4252
4253 )
4254 };
4255
4256 #[inline]
4257 fn from_wire(wire: crate::wire::DynamicDataSinkWipePartitionTablesResponse) -> Self {
4258 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
4259 }
4260 }
4261
4262 impl ::fidl_next::FromWireRef<crate::wire::DynamicDataSinkWipePartitionTablesResponse>
4263 for DynamicDataSinkWipePartitionTablesResponse
4264 {
4265 #[inline]
4266 fn from_wire_ref(wire: &crate::wire::DynamicDataSinkWipePartitionTablesResponse) -> Self {
4267 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
4268 }
4269 }
4270
4271 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4272 pub struct PartitionIoGetPartitionSizeRequest {
4273 pub partition: ::std::string::String,
4274 }
4275
4276 unsafe impl<___E>
4277 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeRequest<'static>, ___E>
4278 for PartitionIoGetPartitionSizeRequest
4279 where
4280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4281 ___E: ::fidl_next::Encoder,
4282 {
4283 #[inline]
4284 fn encode(
4285 self,
4286 encoder_: &mut ___E,
4287 out_: &mut ::core::mem::MaybeUninit<
4288 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
4289 >,
4290 _: (),
4291 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4292 ::fidl_next::munge! {
4293 let crate::wire::PartitionIoGetPartitionSizeRequest {
4294 partition,
4295
4296 } = out_;
4297 }
4298
4299 ::fidl_next::Encode::encode(self.partition, encoder_, partition, 128)?;
4300
4301 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(partition.as_mut_ptr()) };
4302 ::fidl_next::Constrained::validate(_field, 128)?;
4303
4304 Ok(())
4305 }
4306 }
4307
4308 unsafe impl<'a, ___E>
4309 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeRequest<'static>, ___E>
4310 for &'a PartitionIoGetPartitionSizeRequest
4311 where
4312 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4313 ___E: ::fidl_next::Encoder,
4314 {
4315 #[inline]
4316 fn encode(
4317 self,
4318 encoder_: &mut ___E,
4319 out_: &mut ::core::mem::MaybeUninit<
4320 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
4321 >,
4322 _: (),
4323 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4324 ::fidl_next::munge! {
4325 let crate::wire::PartitionIoGetPartitionSizeRequest {
4326 partition,
4327
4328 } = out_;
4329 }
4330
4331 ::fidl_next::Encode::encode(&self.partition, encoder_, partition, 128)?;
4332
4333 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(partition.as_mut_ptr()) };
4334 ::fidl_next::Constrained::validate(_field, 128)?;
4335
4336 Ok(())
4337 }
4338 }
4339
4340 unsafe impl<___E>
4341 ::fidl_next::EncodeOption<
4342 ::fidl_next::wire::Box<
4343 'static,
4344 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
4345 >,
4346 ___E,
4347 > for PartitionIoGetPartitionSizeRequest
4348 where
4349 ___E: ::fidl_next::Encoder + ?Sized,
4350 PartitionIoGetPartitionSizeRequest:
4351 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeRequest<'static>, ___E>,
4352 {
4353 #[inline]
4354 fn encode_option(
4355 this: ::core::option::Option<Self>,
4356 encoder: &mut ___E,
4357 out: &mut ::core::mem::MaybeUninit<
4358 ::fidl_next::wire::Box<
4359 'static,
4360 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
4361 >,
4362 >,
4363 _: (),
4364 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4365 if let Some(inner) = this {
4366 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4367 ::fidl_next::wire::Box::encode_present(out);
4368 } else {
4369 ::fidl_next::wire::Box::encode_absent(out);
4370 }
4371
4372 Ok(())
4373 }
4374 }
4375
4376 unsafe impl<'a, ___E>
4377 ::fidl_next::EncodeOption<
4378 ::fidl_next::wire::Box<
4379 'static,
4380 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
4381 >,
4382 ___E,
4383 > for &'a PartitionIoGetPartitionSizeRequest
4384 where
4385 ___E: ::fidl_next::Encoder + ?Sized,
4386 &'a PartitionIoGetPartitionSizeRequest:
4387 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeRequest<'static>, ___E>,
4388 {
4389 #[inline]
4390 fn encode_option(
4391 this: ::core::option::Option<Self>,
4392 encoder: &mut ___E,
4393 out: &mut ::core::mem::MaybeUninit<
4394 ::fidl_next::wire::Box<
4395 'static,
4396 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
4397 >,
4398 >,
4399 _: (),
4400 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4401 if let Some(inner) = this {
4402 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4403 ::fidl_next::wire::Box::encode_present(out);
4404 } else {
4405 ::fidl_next::wire::Box::encode_absent(out);
4406 }
4407
4408 Ok(())
4409 }
4410 }
4411
4412 impl<'de> ::fidl_next::FromWire<crate::wire::PartitionIoGetPartitionSizeRequest<'de>>
4413 for PartitionIoGetPartitionSizeRequest
4414 {
4415 #[inline]
4416 fn from_wire(wire: crate::wire::PartitionIoGetPartitionSizeRequest<'de>) -> Self {
4417 Self { partition: ::fidl_next::FromWire::from_wire(wire.partition) }
4418 }
4419 }
4420
4421 impl<'de> ::fidl_next::FromWireRef<crate::wire::PartitionIoGetPartitionSizeRequest<'de>>
4422 for PartitionIoGetPartitionSizeRequest
4423 {
4424 #[inline]
4425 fn from_wire_ref(wire: &crate::wire::PartitionIoGetPartitionSizeRequest<'de>) -> Self {
4426 Self { partition: ::fidl_next::FromWireRef::from_wire_ref(&wire.partition) }
4427 }
4428 }
4429
4430 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4431 #[repr(C)]
4432 pub struct PartitionIoGetPartitionSizeResponse {
4433 pub size: u64,
4434 }
4435
4436 unsafe impl<___E> ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeResponse, ___E>
4437 for PartitionIoGetPartitionSizeResponse
4438 where
4439 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4440 {
4441 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4442 Self,
4443 crate::wire::PartitionIoGetPartitionSizeResponse,
4444 > = unsafe {
4445 ::fidl_next::CopyOptimization::enable_if(
4446 true
4447
4448 && <
4449 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
4450 >::COPY_OPTIMIZATION.is_enabled()
4451
4452 )
4453 };
4454
4455 #[inline]
4456 fn encode(
4457 self,
4458 encoder_: &mut ___E,
4459 out_: &mut ::core::mem::MaybeUninit<crate::wire::PartitionIoGetPartitionSizeResponse>,
4460 _: (),
4461 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4462 ::fidl_next::munge! {
4463 let crate::wire::PartitionIoGetPartitionSizeResponse {
4464 size,
4465
4466 } = out_;
4467 }
4468
4469 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
4470
4471 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
4472
4473 Ok(())
4474 }
4475 }
4476
4477 unsafe impl<'a, ___E>
4478 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeResponse, ___E>
4479 for &'a PartitionIoGetPartitionSizeResponse
4480 where
4481 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4482 {
4483 #[inline]
4484 fn encode(
4485 self,
4486 encoder_: &mut ___E,
4487 out_: &mut ::core::mem::MaybeUninit<crate::wire::PartitionIoGetPartitionSizeResponse>,
4488 _: (),
4489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4490 ::fidl_next::munge! {
4491 let crate::wire::PartitionIoGetPartitionSizeResponse {
4492 size,
4493
4494 } = out_;
4495 }
4496
4497 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
4498
4499 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
4500
4501 Ok(())
4502 }
4503 }
4504
4505 unsafe impl<___E>
4506 ::fidl_next::EncodeOption<
4507 ::fidl_next::wire::Box<'static, crate::wire::PartitionIoGetPartitionSizeResponse>,
4508 ___E,
4509 > for PartitionIoGetPartitionSizeResponse
4510 where
4511 ___E: ::fidl_next::Encoder + ?Sized,
4512 PartitionIoGetPartitionSizeResponse:
4513 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeResponse, ___E>,
4514 {
4515 #[inline]
4516 fn encode_option(
4517 this: ::core::option::Option<Self>,
4518 encoder: &mut ___E,
4519 out: &mut ::core::mem::MaybeUninit<
4520 ::fidl_next::wire::Box<'static, crate::wire::PartitionIoGetPartitionSizeResponse>,
4521 >,
4522 _: (),
4523 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4524 if let Some(inner) = this {
4525 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4526 ::fidl_next::wire::Box::encode_present(out);
4527 } else {
4528 ::fidl_next::wire::Box::encode_absent(out);
4529 }
4530
4531 Ok(())
4532 }
4533 }
4534
4535 unsafe impl<'a, ___E>
4536 ::fidl_next::EncodeOption<
4537 ::fidl_next::wire::Box<'static, crate::wire::PartitionIoGetPartitionSizeResponse>,
4538 ___E,
4539 > for &'a PartitionIoGetPartitionSizeResponse
4540 where
4541 ___E: ::fidl_next::Encoder + ?Sized,
4542 &'a PartitionIoGetPartitionSizeResponse:
4543 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeResponse, ___E>,
4544 {
4545 #[inline]
4546 fn encode_option(
4547 this: ::core::option::Option<Self>,
4548 encoder: &mut ___E,
4549 out: &mut ::core::mem::MaybeUninit<
4550 ::fidl_next::wire::Box<'static, crate::wire::PartitionIoGetPartitionSizeResponse>,
4551 >,
4552 _: (),
4553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4554 if let Some(inner) = this {
4555 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4556 ::fidl_next::wire::Box::encode_present(out);
4557 } else {
4558 ::fidl_next::wire::Box::encode_absent(out);
4559 }
4560
4561 Ok(())
4562 }
4563 }
4564
4565 impl ::fidl_next::FromWire<crate::wire::PartitionIoGetPartitionSizeResponse>
4566 for PartitionIoGetPartitionSizeResponse
4567 {
4568 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4569 crate::wire::PartitionIoGetPartitionSizeResponse,
4570 Self,
4571 > = unsafe {
4572 ::fidl_next::CopyOptimization::enable_if(
4573 true
4574 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
4575 .is_enabled(),
4576 )
4577 };
4578
4579 #[inline]
4580 fn from_wire(wire: crate::wire::PartitionIoGetPartitionSizeResponse) -> Self {
4581 Self { size: ::fidl_next::FromWire::from_wire(wire.size) }
4582 }
4583 }
4584
4585 impl ::fidl_next::FromWireRef<crate::wire::PartitionIoGetPartitionSizeResponse>
4586 for PartitionIoGetPartitionSizeResponse
4587 {
4588 #[inline]
4589 fn from_wire_ref(wire: &crate::wire::PartitionIoGetPartitionSizeResponse) -> Self {
4590 Self { size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size) }
4591 }
4592 }
4593
4594 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4595 pub struct PartitionIoReadPartitionRequest {
4596 pub partition: ::std::string::String,
4597
4598 pub offset: u64,
4599
4600 pub size: u64,
4601 }
4602
4603 unsafe impl<___E>
4604 ::fidl_next::Encode<crate::wire::PartitionIoReadPartitionRequest<'static>, ___E>
4605 for PartitionIoReadPartitionRequest
4606 where
4607 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4608 ___E: ::fidl_next::Encoder,
4609 {
4610 #[inline]
4611 fn encode(
4612 self,
4613 encoder_: &mut ___E,
4614 out_: &mut ::core::mem::MaybeUninit<
4615 crate::wire::PartitionIoReadPartitionRequest<'static>,
4616 >,
4617 _: (),
4618 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4619 ::fidl_next::munge! {
4620 let crate::wire::PartitionIoReadPartitionRequest {
4621 partition,
4622 offset,
4623 size,
4624
4625 } = out_;
4626 }
4627
4628 ::fidl_next::Encode::encode(self.partition, encoder_, partition, 128)?;
4629
4630 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(partition.as_mut_ptr()) };
4631 ::fidl_next::Constrained::validate(_field, 128)?;
4632
4633 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4634
4635 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4636
4637 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
4638
4639 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
4640
4641 Ok(())
4642 }
4643 }
4644
4645 unsafe impl<'a, ___E>
4646 ::fidl_next::Encode<crate::wire::PartitionIoReadPartitionRequest<'static>, ___E>
4647 for &'a PartitionIoReadPartitionRequest
4648 where
4649 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4650 ___E: ::fidl_next::Encoder,
4651 {
4652 #[inline]
4653 fn encode(
4654 self,
4655 encoder_: &mut ___E,
4656 out_: &mut ::core::mem::MaybeUninit<
4657 crate::wire::PartitionIoReadPartitionRequest<'static>,
4658 >,
4659 _: (),
4660 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4661 ::fidl_next::munge! {
4662 let crate::wire::PartitionIoReadPartitionRequest {
4663 partition,
4664 offset,
4665 size,
4666
4667 } = out_;
4668 }
4669
4670 ::fidl_next::Encode::encode(&self.partition, encoder_, partition, 128)?;
4671
4672 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(partition.as_mut_ptr()) };
4673 ::fidl_next::Constrained::validate(_field, 128)?;
4674
4675 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4676
4677 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4678
4679 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
4680
4681 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
4682
4683 Ok(())
4684 }
4685 }
4686
4687 unsafe impl<___E>
4688 ::fidl_next::EncodeOption<
4689 ::fidl_next::wire::Box<'static, crate::wire::PartitionIoReadPartitionRequest<'static>>,
4690 ___E,
4691 > for PartitionIoReadPartitionRequest
4692 where
4693 ___E: ::fidl_next::Encoder + ?Sized,
4694 PartitionIoReadPartitionRequest:
4695 ::fidl_next::Encode<crate::wire::PartitionIoReadPartitionRequest<'static>, ___E>,
4696 {
4697 #[inline]
4698 fn encode_option(
4699 this: ::core::option::Option<Self>,
4700 encoder: &mut ___E,
4701 out: &mut ::core::mem::MaybeUninit<
4702 ::fidl_next::wire::Box<
4703 'static,
4704 crate::wire::PartitionIoReadPartitionRequest<'static>,
4705 >,
4706 >,
4707 _: (),
4708 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4709 if let Some(inner) = this {
4710 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4711 ::fidl_next::wire::Box::encode_present(out);
4712 } else {
4713 ::fidl_next::wire::Box::encode_absent(out);
4714 }
4715
4716 Ok(())
4717 }
4718 }
4719
4720 unsafe impl<'a, ___E>
4721 ::fidl_next::EncodeOption<
4722 ::fidl_next::wire::Box<'static, crate::wire::PartitionIoReadPartitionRequest<'static>>,
4723 ___E,
4724 > for &'a PartitionIoReadPartitionRequest
4725 where
4726 ___E: ::fidl_next::Encoder + ?Sized,
4727 &'a PartitionIoReadPartitionRequest:
4728 ::fidl_next::Encode<crate::wire::PartitionIoReadPartitionRequest<'static>, ___E>,
4729 {
4730 #[inline]
4731 fn encode_option(
4732 this: ::core::option::Option<Self>,
4733 encoder: &mut ___E,
4734 out: &mut ::core::mem::MaybeUninit<
4735 ::fidl_next::wire::Box<
4736 'static,
4737 crate::wire::PartitionIoReadPartitionRequest<'static>,
4738 >,
4739 >,
4740 _: (),
4741 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4742 if let Some(inner) = this {
4743 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4744 ::fidl_next::wire::Box::encode_present(out);
4745 } else {
4746 ::fidl_next::wire::Box::encode_absent(out);
4747 }
4748
4749 Ok(())
4750 }
4751 }
4752
4753 impl<'de> ::fidl_next::FromWire<crate::wire::PartitionIoReadPartitionRequest<'de>>
4754 for PartitionIoReadPartitionRequest
4755 {
4756 #[inline]
4757 fn from_wire(wire: crate::wire::PartitionIoReadPartitionRequest<'de>) -> Self {
4758 Self {
4759 partition: ::fidl_next::FromWire::from_wire(wire.partition),
4760
4761 offset: ::fidl_next::FromWire::from_wire(wire.offset),
4762
4763 size: ::fidl_next::FromWire::from_wire(wire.size),
4764 }
4765 }
4766 }
4767
4768 impl<'de> ::fidl_next::FromWireRef<crate::wire::PartitionIoReadPartitionRequest<'de>>
4769 for PartitionIoReadPartitionRequest
4770 {
4771 #[inline]
4772 fn from_wire_ref(wire: &crate::wire::PartitionIoReadPartitionRequest<'de>) -> Self {
4773 Self {
4774 partition: ::fidl_next::FromWireRef::from_wire_ref(&wire.partition),
4775
4776 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
4777
4778 size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size),
4779 }
4780 }
4781 }
4782
4783 #[doc = " Controls how `PartitionIo.WritePartition` handles partition contents beyond the end of the\n written payload (`offset + size`).\n"]
4784 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4785 #[repr(u32)]
4786 pub enum TrailingBehavior {
4787 Retain = 1,
4788 Discard = 2,
4789 UnknownOrdinal_(u32) = 3,
4790 }
4791 impl ::std::convert::From<u32> for TrailingBehavior {
4792 fn from(value: u32) -> Self {
4793 match value {
4794 1 => Self::Retain,
4795 2 => Self::Discard,
4796
4797 _ => Self::UnknownOrdinal_(value),
4798 }
4799 }
4800 }
4801
4802 impl ::std::convert::From<TrailingBehavior> for u32 {
4803 fn from(value: TrailingBehavior) -> Self {
4804 match value {
4805 TrailingBehavior::Retain => 1,
4806 TrailingBehavior::Discard => 2,
4807
4808 TrailingBehavior::UnknownOrdinal_(value) => value,
4809 }
4810 }
4811 }
4812
4813 unsafe impl<___E> ::fidl_next::Encode<crate::wire::TrailingBehavior, ___E> for TrailingBehavior
4814 where
4815 ___E: ?Sized,
4816 {
4817 #[inline]
4818 fn encode(
4819 self,
4820 encoder: &mut ___E,
4821 out: &mut ::core::mem::MaybeUninit<crate::wire::TrailingBehavior>,
4822 _: (),
4823 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4824 ::fidl_next::Encode::encode(&self, encoder, out, ())
4825 }
4826 }
4827
4828 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::TrailingBehavior, ___E>
4829 for &'a TrailingBehavior
4830 where
4831 ___E: ?Sized,
4832 {
4833 #[inline]
4834 fn encode(
4835 self,
4836 encoder: &mut ___E,
4837 out: &mut ::core::mem::MaybeUninit<crate::wire::TrailingBehavior>,
4838 _: (),
4839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4840 ::fidl_next::munge!(let crate::wire::TrailingBehavior { value } = out);
4841 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
4842 TrailingBehavior::Retain => 1,
4843
4844 TrailingBehavior::Discard => 2,
4845
4846 TrailingBehavior::UnknownOrdinal_(value) => value,
4847 }));
4848
4849 Ok(())
4850 }
4851 }
4852
4853 impl ::core::convert::From<crate::wire::TrailingBehavior> for TrailingBehavior {
4854 fn from(wire: crate::wire::TrailingBehavior) -> Self {
4855 match u32::from(wire.value) {
4856 1 => Self::Retain,
4857
4858 2 => Self::Discard,
4859
4860 value => Self::UnknownOrdinal_(value),
4861 }
4862 }
4863 }
4864
4865 impl ::fidl_next::FromWire<crate::wire::TrailingBehavior> for TrailingBehavior {
4866 #[inline]
4867 fn from_wire(wire: crate::wire::TrailingBehavior) -> Self {
4868 Self::from(wire)
4869 }
4870 }
4871
4872 impl ::fidl_next::FromWireRef<crate::wire::TrailingBehavior> for TrailingBehavior {
4873 #[inline]
4874 fn from_wire_ref(wire: &crate::wire::TrailingBehavior) -> Self {
4875 Self::from(*wire)
4876 }
4877 }
4878
4879 pub type PartitionIoWritePartitionResponse = ();
4880
4881 pub type PartitionIoFlushResponse = ();
4882
4883 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4884 #[repr(C)]
4885 pub struct ReadInfo {
4886 pub offset: u64,
4887
4888 pub size: u64,
4889 }
4890
4891 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadInfo, ___E> for ReadInfo
4892 where
4893 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4894 {
4895 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ReadInfo> = unsafe {
4896 ::fidl_next::CopyOptimization::enable_if(
4897 true
4898
4899 && <
4900 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
4901 >::COPY_OPTIMIZATION.is_enabled()
4902
4903 && <
4904 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
4905 >::COPY_OPTIMIZATION.is_enabled()
4906
4907 )
4908 };
4909
4910 #[inline]
4911 fn encode(
4912 self,
4913 encoder_: &mut ___E,
4914 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadInfo>,
4915 _: (),
4916 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4917 ::fidl_next::munge! {
4918 let crate::wire::ReadInfo {
4919 offset,
4920 size,
4921
4922 } = out_;
4923 }
4924
4925 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
4926
4927 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4928
4929 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
4930
4931 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
4932
4933 Ok(())
4934 }
4935 }
4936
4937 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadInfo, ___E> for &'a ReadInfo
4938 where
4939 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4940 {
4941 #[inline]
4942 fn encode(
4943 self,
4944 encoder_: &mut ___E,
4945 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadInfo>,
4946 _: (),
4947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4948 ::fidl_next::munge! {
4949 let crate::wire::ReadInfo {
4950 offset,
4951 size,
4952
4953 } = out_;
4954 }
4955
4956 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
4957
4958 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
4959
4960 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
4961
4962 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
4963
4964 Ok(())
4965 }
4966 }
4967
4968 unsafe impl<___E>
4969 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::ReadInfo>, ___E>
4970 for ReadInfo
4971 where
4972 ___E: ::fidl_next::Encoder + ?Sized,
4973 ReadInfo: ::fidl_next::Encode<crate::wire::ReadInfo, ___E>,
4974 {
4975 #[inline]
4976 fn encode_option(
4977 this: ::core::option::Option<Self>,
4978 encoder: &mut ___E,
4979 out: &mut ::core::mem::MaybeUninit<
4980 ::fidl_next::wire::Box<'static, crate::wire::ReadInfo>,
4981 >,
4982 _: (),
4983 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4984 if let Some(inner) = this {
4985 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4986 ::fidl_next::wire::Box::encode_present(out);
4987 } else {
4988 ::fidl_next::wire::Box::encode_absent(out);
4989 }
4990
4991 Ok(())
4992 }
4993 }
4994
4995 unsafe impl<'a, ___E>
4996 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::ReadInfo>, ___E>
4997 for &'a ReadInfo
4998 where
4999 ___E: ::fidl_next::Encoder + ?Sized,
5000 &'a ReadInfo: ::fidl_next::Encode<crate::wire::ReadInfo, ___E>,
5001 {
5002 #[inline]
5003 fn encode_option(
5004 this: ::core::option::Option<Self>,
5005 encoder: &mut ___E,
5006 out: &mut ::core::mem::MaybeUninit<
5007 ::fidl_next::wire::Box<'static, crate::wire::ReadInfo>,
5008 >,
5009 _: (),
5010 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5011 if let Some(inner) = this {
5012 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5013 ::fidl_next::wire::Box::encode_present(out);
5014 } else {
5015 ::fidl_next::wire::Box::encode_absent(out);
5016 }
5017
5018 Ok(())
5019 }
5020 }
5021
5022 impl ::fidl_next::FromWire<crate::wire::ReadInfo> for ReadInfo {
5023 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ReadInfo, Self> = unsafe {
5024 ::fidl_next::CopyOptimization::enable_if(
5025 true
5026 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
5027 .is_enabled()
5028 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
5029 .is_enabled(),
5030 )
5031 };
5032
5033 #[inline]
5034 fn from_wire(wire: crate::wire::ReadInfo) -> Self {
5035 Self {
5036 offset: ::fidl_next::FromWire::from_wire(wire.offset),
5037
5038 size: ::fidl_next::FromWire::from_wire(wire.size),
5039 }
5040 }
5041 }
5042
5043 impl ::fidl_next::FromWireRef<crate::wire::ReadInfo> for ReadInfo {
5044 #[inline]
5045 fn from_wire_ref(wire: &crate::wire::ReadInfo) -> Self {
5046 Self {
5047 offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
5048
5049 size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size),
5050 }
5051 }
5052 }
5053
5054 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5055 pub enum ReadResult {
5056 Err(::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>),
5057
5058 Eof(bool),
5059
5060 Info(crate::natural::ReadInfo),
5061 }
5062
5063 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadResult<'static>, ___E> for ReadResult
5064 where
5065 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5066 ___E: ::fidl_next::Encoder,
5067 {
5068 #[inline]
5069 fn encode(
5070 self,
5071 encoder: &mut ___E,
5072 out: &mut ::core::mem::MaybeUninit<crate::wire::ReadResult<'static>>,
5073 _: (),
5074 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5075 ::fidl_next::munge!(let crate::wire::ReadResult { raw, _phantom: _ } = out);
5076
5077 match self {
5078 Self::Err(value) => ::fidl_next::wire::Union::encode_as::<
5079 ___E,
5080 ::fidl_next::wire::fuchsia::StatusResult,
5081 >(value, 1, encoder, raw, ())?,
5082
5083 Self::Eof(value) => {
5084 ::fidl_next::wire::Union::encode_as::<___E, bool>(value, 2, encoder, raw, ())?
5085 }
5086
5087 Self::Info(value) => ::fidl_next::wire::Union::encode_as::<
5088 ___E,
5089 crate::wire::ReadInfo,
5090 >(value, 3, encoder, raw, ())?,
5091 }
5092
5093 Ok(())
5094 }
5095 }
5096
5097 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadResult<'static>, ___E> for &'a ReadResult
5098 where
5099 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5100 ___E: ::fidl_next::Encoder,
5101 {
5102 #[inline]
5103 fn encode(
5104 self,
5105 encoder: &mut ___E,
5106 out: &mut ::core::mem::MaybeUninit<crate::wire::ReadResult<'static>>,
5107 _: (),
5108 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5109 ::fidl_next::munge!(let crate::wire::ReadResult { raw, _phantom: _ } = out);
5110
5111 match self {
5112 ReadResult::Err(value) => ::fidl_next::wire::Union::encode_as::<
5113 ___E,
5114 ::fidl_next::wire::fuchsia::StatusResult,
5115 >(value, 1, encoder, raw, ())?,
5116
5117 ReadResult::Eof(value) => {
5118 ::fidl_next::wire::Union::encode_as::<___E, bool>(value, 2, encoder, raw, ())?
5119 }
5120
5121 ReadResult::Info(value) => ::fidl_next::wire::Union::encode_as::<
5122 ___E,
5123 crate::wire::ReadInfo,
5124 >(value, 3, encoder, raw, ())?,
5125 }
5126
5127 Ok(())
5128 }
5129 }
5130
5131 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::ReadResult<'static>, ___E>
5132 for ReadResult
5133 where
5134 ___E: ?Sized,
5135 ReadResult: ::fidl_next::Encode<crate::wire::ReadResult<'static>, ___E>,
5136 {
5137 #[inline]
5138 fn encode_option(
5139 this: ::core::option::Option<Self>,
5140 encoder: &mut ___E,
5141 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ReadResult<'static>>,
5142 _: (),
5143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5144 ::fidl_next::munge!(let crate::wire_optional::ReadResult { raw, _phantom: _ } = &mut *out);
5145
5146 if let Some(inner) = this {
5147 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
5148 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
5149 } else {
5150 ::fidl_next::wire::Union::encode_absent(raw);
5151 }
5152
5153 Ok(())
5154 }
5155 }
5156
5157 unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::ReadResult<'static>, ___E>
5158 for &'a ReadResult
5159 where
5160 ___E: ?Sized,
5161 &'a ReadResult: ::fidl_next::Encode<crate::wire::ReadResult<'static>, ___E>,
5162 {
5163 #[inline]
5164 fn encode_option(
5165 this: ::core::option::Option<Self>,
5166 encoder: &mut ___E,
5167 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ReadResult<'static>>,
5168 _: (),
5169 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5170 ::fidl_next::munge!(let crate::wire_optional::ReadResult { raw, _phantom: _ } = &mut *out);
5171
5172 if let Some(inner) = this {
5173 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
5174 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
5175 } else {
5176 ::fidl_next::wire::Union::encode_absent(raw);
5177 }
5178
5179 Ok(())
5180 }
5181 }
5182
5183 impl<'de> ::fidl_next::FromWire<crate::wire::ReadResult<'de>> for ReadResult {
5184 #[inline]
5185 fn from_wire(wire: crate::wire::ReadResult<'de>) -> Self {
5186 let wire = ::core::mem::ManuallyDrop::new(wire);
5187 match wire.raw.ordinal() {
5188 1 => Self::Err(::fidl_next::FromWire::from_wire(unsafe {
5189 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
5190 })),
5191
5192 2 => Self::Eof(::fidl_next::FromWire::from_wire(unsafe {
5193 wire.raw.get().read_unchecked::<bool>()
5194 })),
5195
5196 3 => Self::Info(::fidl_next::FromWire::from_wire(unsafe {
5197 wire.raw.get().read_unchecked::<crate::wire::ReadInfo>()
5198 })),
5199
5200 _ => unsafe { ::core::hint::unreachable_unchecked() },
5201 }
5202 }
5203 }
5204
5205 impl<'de> ::fidl_next::FromWireRef<crate::wire::ReadResult<'de>> for ReadResult {
5206 #[inline]
5207 fn from_wire_ref(wire: &crate::wire::ReadResult<'de>) -> Self {
5208 match wire.raw.ordinal() {
5209 1 => Self::Err(::fidl_next::FromWireRef::from_wire_ref(unsafe {
5210 wire.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
5211 })),
5212
5213 2 => Self::Eof(::fidl_next::FromWireRef::from_wire_ref(unsafe {
5214 wire.raw.get().deref_unchecked::<bool>()
5215 })),
5216
5217 3 => Self::Info(::fidl_next::FromWireRef::from_wire_ref(unsafe {
5218 wire.raw.get().deref_unchecked::<crate::wire::ReadInfo>()
5219 })),
5220
5221 _ => unsafe { ::core::hint::unreachable_unchecked() },
5222 }
5223 }
5224 }
5225
5226 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ReadResult<'de>> for ReadResult {
5227 #[inline]
5228 fn from_wire_option(
5229 wire: crate::wire_optional::ReadResult<'de>,
5230 ) -> ::core::option::Option<Self> {
5231 if let Some(inner) = wire.into_option() {
5232 Some(::fidl_next::FromWire::from_wire(inner))
5233 } else {
5234 None
5235 }
5236 }
5237 }
5238
5239 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ReadResult<'de>> for Box<ReadResult> {
5240 #[inline]
5241 fn from_wire_option(
5242 wire: crate::wire_optional::ReadResult<'de>,
5243 ) -> ::core::option::Option<Self> {
5244 <
5245 ReadResult as ::fidl_next::FromWireOption<crate::wire_optional::ReadResult<'de>>
5246 >::from_wire_option(wire).map(Box::new)
5247 }
5248 }
5249
5250 impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::ReadResult<'de>>
5251 for Box<ReadResult>
5252 {
5253 #[inline]
5254 fn from_wire_option_ref(
5255 wire: &crate::wire_optional::ReadResult<'de>,
5256 ) -> ::core::option::Option<Self> {
5257 if let Some(inner) = wire.as_ref() {
5258 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
5259 } else {
5260 None
5261 }
5262 }
5263 }
5264
5265 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5266 #[repr(C)]
5267 pub struct SysconfigWriteResponse {
5268 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
5269 }
5270
5271 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SysconfigWriteResponse, ___E>
5272 for SysconfigWriteResponse
5273 where
5274 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5275 {
5276 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5277 Self,
5278 crate::wire::SysconfigWriteResponse,
5279 > = unsafe {
5280 ::fidl_next::CopyOptimization::enable_if(
5281 true
5282
5283 && <
5284 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
5285 >::COPY_OPTIMIZATION.is_enabled()
5286
5287 )
5288 };
5289
5290 #[inline]
5291 fn encode(
5292 self,
5293 encoder_: &mut ___E,
5294 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWriteResponse>,
5295 _: (),
5296 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5297 ::fidl_next::munge! {
5298 let crate::wire::SysconfigWriteResponse {
5299 status,
5300
5301 } = out_;
5302 }
5303
5304 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
5305
5306 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
5307
5308 Ok(())
5309 }
5310 }
5311
5312 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SysconfigWriteResponse, ___E>
5313 for &'a SysconfigWriteResponse
5314 where
5315 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5316 {
5317 #[inline]
5318 fn encode(
5319 self,
5320 encoder_: &mut ___E,
5321 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWriteResponse>,
5322 _: (),
5323 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5324 ::fidl_next::munge! {
5325 let crate::wire::SysconfigWriteResponse {
5326 status,
5327
5328 } = out_;
5329 }
5330
5331 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
5332
5333 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
5334
5335 Ok(())
5336 }
5337 }
5338
5339 unsafe impl<___E>
5340 ::fidl_next::EncodeOption<
5341 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWriteResponse>,
5342 ___E,
5343 > for SysconfigWriteResponse
5344 where
5345 ___E: ::fidl_next::Encoder + ?Sized,
5346 SysconfigWriteResponse: ::fidl_next::Encode<crate::wire::SysconfigWriteResponse, ___E>,
5347 {
5348 #[inline]
5349 fn encode_option(
5350 this: ::core::option::Option<Self>,
5351 encoder: &mut ___E,
5352 out: &mut ::core::mem::MaybeUninit<
5353 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWriteResponse>,
5354 >,
5355 _: (),
5356 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5357 if let Some(inner) = this {
5358 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5359 ::fidl_next::wire::Box::encode_present(out);
5360 } else {
5361 ::fidl_next::wire::Box::encode_absent(out);
5362 }
5363
5364 Ok(())
5365 }
5366 }
5367
5368 unsafe impl<'a, ___E>
5369 ::fidl_next::EncodeOption<
5370 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWriteResponse>,
5371 ___E,
5372 > for &'a SysconfigWriteResponse
5373 where
5374 ___E: ::fidl_next::Encoder + ?Sized,
5375 &'a SysconfigWriteResponse: ::fidl_next::Encode<crate::wire::SysconfigWriteResponse, ___E>,
5376 {
5377 #[inline]
5378 fn encode_option(
5379 this: ::core::option::Option<Self>,
5380 encoder: &mut ___E,
5381 out: &mut ::core::mem::MaybeUninit<
5382 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWriteResponse>,
5383 >,
5384 _: (),
5385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5386 if let Some(inner) = this {
5387 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5388 ::fidl_next::wire::Box::encode_present(out);
5389 } else {
5390 ::fidl_next::wire::Box::encode_absent(out);
5391 }
5392
5393 Ok(())
5394 }
5395 }
5396
5397 impl ::fidl_next::FromWire<crate::wire::SysconfigWriteResponse> for SysconfigWriteResponse {
5398 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5399 crate::wire::SysconfigWriteResponse,
5400 Self,
5401 > = unsafe {
5402 ::fidl_next::CopyOptimization::enable_if(
5403 true
5404
5405 && <
5406 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
5407 >::COPY_OPTIMIZATION.is_enabled()
5408
5409 )
5410 };
5411
5412 #[inline]
5413 fn from_wire(wire: crate::wire::SysconfigWriteResponse) -> Self {
5414 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
5415 }
5416 }
5417
5418 impl ::fidl_next::FromWireRef<crate::wire::SysconfigWriteResponse> for SysconfigWriteResponse {
5419 #[inline]
5420 fn from_wire_ref(wire: &crate::wire::SysconfigWriteResponse) -> Self {
5421 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
5422 }
5423 }
5424
5425 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5426 #[repr(C)]
5427 pub struct SysconfigGetPartitionSizeResponse {
5428 pub size: u64,
5429 }
5430
5431 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SysconfigGetPartitionSizeResponse, ___E>
5432 for SysconfigGetPartitionSizeResponse
5433 where
5434 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5435 {
5436 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5437 Self,
5438 crate::wire::SysconfigGetPartitionSizeResponse,
5439 > = unsafe {
5440 ::fidl_next::CopyOptimization::enable_if(
5441 true
5442
5443 && <
5444 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
5445 >::COPY_OPTIMIZATION.is_enabled()
5446
5447 )
5448 };
5449
5450 #[inline]
5451 fn encode(
5452 self,
5453 encoder_: &mut ___E,
5454 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigGetPartitionSizeResponse>,
5455 _: (),
5456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5457 ::fidl_next::munge! {
5458 let crate::wire::SysconfigGetPartitionSizeResponse {
5459 size,
5460
5461 } = out_;
5462 }
5463
5464 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
5465
5466 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
5467
5468 Ok(())
5469 }
5470 }
5471
5472 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SysconfigGetPartitionSizeResponse, ___E>
5473 for &'a SysconfigGetPartitionSizeResponse
5474 where
5475 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5476 {
5477 #[inline]
5478 fn encode(
5479 self,
5480 encoder_: &mut ___E,
5481 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigGetPartitionSizeResponse>,
5482 _: (),
5483 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5484 ::fidl_next::munge! {
5485 let crate::wire::SysconfigGetPartitionSizeResponse {
5486 size,
5487
5488 } = out_;
5489 }
5490
5491 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
5492
5493 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };
5494
5495 Ok(())
5496 }
5497 }
5498
5499 unsafe impl<___E>
5500 ::fidl_next::EncodeOption<
5501 ::fidl_next::wire::Box<'static, crate::wire::SysconfigGetPartitionSizeResponse>,
5502 ___E,
5503 > for SysconfigGetPartitionSizeResponse
5504 where
5505 ___E: ::fidl_next::Encoder + ?Sized,
5506 SysconfigGetPartitionSizeResponse:
5507 ::fidl_next::Encode<crate::wire::SysconfigGetPartitionSizeResponse, ___E>,
5508 {
5509 #[inline]
5510 fn encode_option(
5511 this: ::core::option::Option<Self>,
5512 encoder: &mut ___E,
5513 out: &mut ::core::mem::MaybeUninit<
5514 ::fidl_next::wire::Box<'static, crate::wire::SysconfigGetPartitionSizeResponse>,
5515 >,
5516 _: (),
5517 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5518 if let Some(inner) = this {
5519 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5520 ::fidl_next::wire::Box::encode_present(out);
5521 } else {
5522 ::fidl_next::wire::Box::encode_absent(out);
5523 }
5524
5525 Ok(())
5526 }
5527 }
5528
5529 unsafe impl<'a, ___E>
5530 ::fidl_next::EncodeOption<
5531 ::fidl_next::wire::Box<'static, crate::wire::SysconfigGetPartitionSizeResponse>,
5532 ___E,
5533 > for &'a SysconfigGetPartitionSizeResponse
5534 where
5535 ___E: ::fidl_next::Encoder + ?Sized,
5536 &'a SysconfigGetPartitionSizeResponse:
5537 ::fidl_next::Encode<crate::wire::SysconfigGetPartitionSizeResponse, ___E>,
5538 {
5539 #[inline]
5540 fn encode_option(
5541 this: ::core::option::Option<Self>,
5542 encoder: &mut ___E,
5543 out: &mut ::core::mem::MaybeUninit<
5544 ::fidl_next::wire::Box<'static, crate::wire::SysconfigGetPartitionSizeResponse>,
5545 >,
5546 _: (),
5547 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5548 if let Some(inner) = this {
5549 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5550 ::fidl_next::wire::Box::encode_present(out);
5551 } else {
5552 ::fidl_next::wire::Box::encode_absent(out);
5553 }
5554
5555 Ok(())
5556 }
5557 }
5558
5559 impl ::fidl_next::FromWire<crate::wire::SysconfigGetPartitionSizeResponse>
5560 for SysconfigGetPartitionSizeResponse
5561 {
5562 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5563 crate::wire::SysconfigGetPartitionSizeResponse,
5564 Self,
5565 > = unsafe {
5566 ::fidl_next::CopyOptimization::enable_if(
5567 true
5568 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
5569 .is_enabled(),
5570 )
5571 };
5572
5573 #[inline]
5574 fn from_wire(wire: crate::wire::SysconfigGetPartitionSizeResponse) -> Self {
5575 Self { size: ::fidl_next::FromWire::from_wire(wire.size) }
5576 }
5577 }
5578
5579 impl ::fidl_next::FromWireRef<crate::wire::SysconfigGetPartitionSizeResponse>
5580 for SysconfigGetPartitionSizeResponse
5581 {
5582 #[inline]
5583 fn from_wire_ref(wire: &crate::wire::SysconfigGetPartitionSizeResponse) -> Self {
5584 Self { size: ::fidl_next::FromWireRef::from_wire_ref(&wire.size) }
5585 }
5586 }
5587
5588 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5589 #[repr(C)]
5590 pub struct SysconfigFlushResponse {
5591 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
5592 }
5593
5594 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SysconfigFlushResponse, ___E>
5595 for SysconfigFlushResponse
5596 where
5597 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5598 {
5599 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5600 Self,
5601 crate::wire::SysconfigFlushResponse,
5602 > = unsafe {
5603 ::fidl_next::CopyOptimization::enable_if(
5604 true
5605
5606 && <
5607 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
5608 >::COPY_OPTIMIZATION.is_enabled()
5609
5610 )
5611 };
5612
5613 #[inline]
5614 fn encode(
5615 self,
5616 encoder_: &mut ___E,
5617 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigFlushResponse>,
5618 _: (),
5619 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5620 ::fidl_next::munge! {
5621 let crate::wire::SysconfigFlushResponse {
5622 status,
5623
5624 } = out_;
5625 }
5626
5627 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
5628
5629 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
5630
5631 Ok(())
5632 }
5633 }
5634
5635 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SysconfigFlushResponse, ___E>
5636 for &'a SysconfigFlushResponse
5637 where
5638 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5639 {
5640 #[inline]
5641 fn encode(
5642 self,
5643 encoder_: &mut ___E,
5644 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigFlushResponse>,
5645 _: (),
5646 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5647 ::fidl_next::munge! {
5648 let crate::wire::SysconfigFlushResponse {
5649 status,
5650
5651 } = out_;
5652 }
5653
5654 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
5655
5656 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
5657
5658 Ok(())
5659 }
5660 }
5661
5662 unsafe impl<___E>
5663 ::fidl_next::EncodeOption<
5664 ::fidl_next::wire::Box<'static, crate::wire::SysconfigFlushResponse>,
5665 ___E,
5666 > for SysconfigFlushResponse
5667 where
5668 ___E: ::fidl_next::Encoder + ?Sized,
5669 SysconfigFlushResponse: ::fidl_next::Encode<crate::wire::SysconfigFlushResponse, ___E>,
5670 {
5671 #[inline]
5672 fn encode_option(
5673 this: ::core::option::Option<Self>,
5674 encoder: &mut ___E,
5675 out: &mut ::core::mem::MaybeUninit<
5676 ::fidl_next::wire::Box<'static, crate::wire::SysconfigFlushResponse>,
5677 >,
5678 _: (),
5679 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5680 if let Some(inner) = this {
5681 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5682 ::fidl_next::wire::Box::encode_present(out);
5683 } else {
5684 ::fidl_next::wire::Box::encode_absent(out);
5685 }
5686
5687 Ok(())
5688 }
5689 }
5690
5691 unsafe impl<'a, ___E>
5692 ::fidl_next::EncodeOption<
5693 ::fidl_next::wire::Box<'static, crate::wire::SysconfigFlushResponse>,
5694 ___E,
5695 > for &'a SysconfigFlushResponse
5696 where
5697 ___E: ::fidl_next::Encoder + ?Sized,
5698 &'a SysconfigFlushResponse: ::fidl_next::Encode<crate::wire::SysconfigFlushResponse, ___E>,
5699 {
5700 #[inline]
5701 fn encode_option(
5702 this: ::core::option::Option<Self>,
5703 encoder: &mut ___E,
5704 out: &mut ::core::mem::MaybeUninit<
5705 ::fidl_next::wire::Box<'static, crate::wire::SysconfigFlushResponse>,
5706 >,
5707 _: (),
5708 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5709 if let Some(inner) = this {
5710 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5711 ::fidl_next::wire::Box::encode_present(out);
5712 } else {
5713 ::fidl_next::wire::Box::encode_absent(out);
5714 }
5715
5716 Ok(())
5717 }
5718 }
5719
5720 impl ::fidl_next::FromWire<crate::wire::SysconfigFlushResponse> for SysconfigFlushResponse {
5721 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5722 crate::wire::SysconfigFlushResponse,
5723 Self,
5724 > = unsafe {
5725 ::fidl_next::CopyOptimization::enable_if(
5726 true
5727
5728 && <
5729 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
5730 >::COPY_OPTIMIZATION.is_enabled()
5731
5732 )
5733 };
5734
5735 #[inline]
5736 fn from_wire(wire: crate::wire::SysconfigFlushResponse) -> Self {
5737 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
5738 }
5739 }
5740
5741 impl ::fidl_next::FromWireRef<crate::wire::SysconfigFlushResponse> for SysconfigFlushResponse {
5742 #[inline]
5743 fn from_wire_ref(wire: &crate::wire::SysconfigFlushResponse) -> Self {
5744 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
5745 }
5746 }
5747
5748 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5749 #[repr(C)]
5750 pub struct SysconfigWipeResponse {
5751 pub status: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
5752 }
5753
5754 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SysconfigWipeResponse, ___E>
5755 for SysconfigWipeResponse
5756 where
5757 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5758 {
5759 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5760 Self,
5761 crate::wire::SysconfigWipeResponse,
5762 > = unsafe {
5763 ::fidl_next::CopyOptimization::enable_if(
5764 true
5765
5766 && <
5767 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
5768 >::COPY_OPTIMIZATION.is_enabled()
5769
5770 )
5771 };
5772
5773 #[inline]
5774 fn encode(
5775 self,
5776 encoder_: &mut ___E,
5777 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWipeResponse>,
5778 _: (),
5779 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5780 ::fidl_next::munge! {
5781 let crate::wire::SysconfigWipeResponse {
5782 status,
5783
5784 } = out_;
5785 }
5786
5787 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
5788
5789 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
5790
5791 Ok(())
5792 }
5793 }
5794
5795 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SysconfigWipeResponse, ___E>
5796 for &'a SysconfigWipeResponse
5797 where
5798 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5799 {
5800 #[inline]
5801 fn encode(
5802 self,
5803 encoder_: &mut ___E,
5804 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWipeResponse>,
5805 _: (),
5806 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5807 ::fidl_next::munge! {
5808 let crate::wire::SysconfigWipeResponse {
5809 status,
5810
5811 } = out_;
5812 }
5813
5814 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
5815
5816 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status.as_mut_ptr()) };
5817
5818 Ok(())
5819 }
5820 }
5821
5822 unsafe impl<___E>
5823 ::fidl_next::EncodeOption<
5824 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWipeResponse>,
5825 ___E,
5826 > for SysconfigWipeResponse
5827 where
5828 ___E: ::fidl_next::Encoder + ?Sized,
5829 SysconfigWipeResponse: ::fidl_next::Encode<crate::wire::SysconfigWipeResponse, ___E>,
5830 {
5831 #[inline]
5832 fn encode_option(
5833 this: ::core::option::Option<Self>,
5834 encoder: &mut ___E,
5835 out: &mut ::core::mem::MaybeUninit<
5836 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWipeResponse>,
5837 >,
5838 _: (),
5839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5840 if let Some(inner) = this {
5841 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5842 ::fidl_next::wire::Box::encode_present(out);
5843 } else {
5844 ::fidl_next::wire::Box::encode_absent(out);
5845 }
5846
5847 Ok(())
5848 }
5849 }
5850
5851 unsafe impl<'a, ___E>
5852 ::fidl_next::EncodeOption<
5853 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWipeResponse>,
5854 ___E,
5855 > for &'a SysconfigWipeResponse
5856 where
5857 ___E: ::fidl_next::Encoder + ?Sized,
5858 &'a SysconfigWipeResponse: ::fidl_next::Encode<crate::wire::SysconfigWipeResponse, ___E>,
5859 {
5860 #[inline]
5861 fn encode_option(
5862 this: ::core::option::Option<Self>,
5863 encoder: &mut ___E,
5864 out: &mut ::core::mem::MaybeUninit<
5865 ::fidl_next::wire::Box<'static, crate::wire::SysconfigWipeResponse>,
5866 >,
5867 _: (),
5868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5869 if let Some(inner) = this {
5870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5871 ::fidl_next::wire::Box::encode_present(out);
5872 } else {
5873 ::fidl_next::wire::Box::encode_absent(out);
5874 }
5875
5876 Ok(())
5877 }
5878 }
5879
5880 impl ::fidl_next::FromWire<crate::wire::SysconfigWipeResponse> for SysconfigWipeResponse {
5881 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5882 crate::wire::SysconfigWipeResponse,
5883 Self,
5884 > = unsafe {
5885 ::fidl_next::CopyOptimization::enable_if(
5886 true
5887
5888 && <
5889 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
5890 >::COPY_OPTIMIZATION.is_enabled()
5891
5892 )
5893 };
5894
5895 #[inline]
5896 fn from_wire(wire: crate::wire::SysconfigWipeResponse) -> Self {
5897 Self { status: ::fidl_next::FromWire::from_wire(wire.status) }
5898 }
5899 }
5900
5901 impl ::fidl_next::FromWireRef<crate::wire::SysconfigWipeResponse> for SysconfigWipeResponse {
5902 #[inline]
5903 fn from_wire_ref(wire: &crate::wire::SysconfigWipeResponse) -> Self {
5904 Self { status: ::fidl_next::FromWireRef::from_wire_ref(&wire.status) }
5905 }
5906 }
5907}
5908
5909pub mod wire {
5910
5911 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
5913 #[repr(transparent)]
5914 pub struct Asset {
5915 pub(crate) value: ::fidl_next::wire::Uint32,
5916 }
5917
5918 impl ::fidl_next::Constrained for Asset {
5919 type Constraint = ();
5920
5921 fn validate(
5922 _: ::fidl_next::Slot<'_, Self>,
5923 _: Self::Constraint,
5924 ) -> Result<(), ::fidl_next::ValidationError> {
5925 Ok(())
5926 }
5927 }
5928
5929 unsafe impl ::fidl_next::Wire for Asset {
5930 type Narrowed<'de> = Self;
5931
5932 #[inline]
5933 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
5934 }
5936 }
5937
5938 impl Asset {
5939 pub const KERNEL: Asset = Asset { value: ::fidl_next::wire::Uint32(1) };
5940
5941 pub const VERIFIED_BOOT_METADATA: Asset = Asset { value: ::fidl_next::wire::Uint32(2) };
5942 }
5943
5944 unsafe impl<___D> ::fidl_next::Decode<___D> for Asset
5945 where
5946 ___D: ?Sized,
5947 {
5948 fn decode(
5949 slot: ::fidl_next::Slot<'_, Self>,
5950 _: &mut ___D,
5951 _: (),
5952 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5953 ::fidl_next::munge!(let Self { value } = slot);
5954
5955 match u32::from(*value) {
5956 1 | 2 => (),
5957 unknown => {
5958 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
5959 }
5960 }
5961
5962 Ok(())
5963 }
5964 }
5965
5966 impl ::core::convert::From<crate::natural::Asset> for Asset {
5967 fn from(natural: crate::natural::Asset) -> Self {
5968 match natural {
5969 crate::natural::Asset::Kernel => Asset::KERNEL,
5970
5971 crate::natural::Asset::VerifiedBootMetadata => Asset::VERIFIED_BOOT_METADATA,
5972 }
5973 }
5974 }
5975
5976 impl ::fidl_next::IntoNatural for Asset {
5977 type Natural = crate::natural::Asset;
5978 }
5979
5980 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
5982 #[repr(transparent)]
5983 pub struct Configuration {
5984 pub(crate) value: ::fidl_next::wire::Uint32,
5985 }
5986
5987 impl ::fidl_next::Constrained for Configuration {
5988 type Constraint = ();
5989
5990 fn validate(
5991 _: ::fidl_next::Slot<'_, Self>,
5992 _: Self::Constraint,
5993 ) -> Result<(), ::fidl_next::ValidationError> {
5994 Ok(())
5995 }
5996 }
5997
5998 unsafe impl ::fidl_next::Wire for Configuration {
5999 type Narrowed<'de> = Self;
6000
6001 #[inline]
6002 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6003 }
6005 }
6006
6007 impl Configuration {
6008 pub const A: Configuration = Configuration { value: ::fidl_next::wire::Uint32(1) };
6009
6010 pub const B: Configuration = Configuration { value: ::fidl_next::wire::Uint32(2) };
6011
6012 pub const RECOVERY: Configuration = Configuration { value: ::fidl_next::wire::Uint32(3) };
6013 }
6014
6015 unsafe impl<___D> ::fidl_next::Decode<___D> for Configuration
6016 where
6017 ___D: ?Sized,
6018 {
6019 fn decode(
6020 slot: ::fidl_next::Slot<'_, Self>,
6021 _: &mut ___D,
6022 _: (),
6023 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6024 ::fidl_next::munge!(let Self { value } = slot);
6025
6026 match u32::from(*value) {
6027 1 | 2 | 3 => (),
6028 unknown => {
6029 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
6030 }
6031 }
6032
6033 Ok(())
6034 }
6035 }
6036
6037 impl ::core::convert::From<crate::natural::Configuration> for Configuration {
6038 fn from(natural: crate::natural::Configuration) -> Self {
6039 match natural {
6040 crate::natural::Configuration::A => Configuration::A,
6041
6042 crate::natural::Configuration::B => Configuration::B,
6043
6044 crate::natural::Configuration::Recovery => Configuration::RECOVERY,
6045 }
6046 }
6047 }
6048
6049 impl ::fidl_next::IntoNatural for Configuration {
6050 type Natural = crate::natural::Configuration;
6051 }
6052
6053 #[derive(Clone, Debug)]
6055 #[repr(C)]
6056 pub struct BootManagerQueryCurrentConfigurationResponse {
6057 pub configuration: crate::wire::Configuration,
6058 }
6059
6060 static_assertions::const_assert_eq!(
6061 std::mem::size_of::<BootManagerQueryCurrentConfigurationResponse>(),
6062 4
6063 );
6064 static_assertions::const_assert_eq!(
6065 std::mem::align_of::<BootManagerQueryCurrentConfigurationResponse>(),
6066 4
6067 );
6068
6069 static_assertions::const_assert_eq!(
6070 std::mem::offset_of!(BootManagerQueryCurrentConfigurationResponse, configuration),
6071 0
6072 );
6073
6074 impl ::fidl_next::Constrained for BootManagerQueryCurrentConfigurationResponse {
6075 type Constraint = ();
6076
6077 fn validate(
6078 _: ::fidl_next::Slot<'_, Self>,
6079 _: Self::Constraint,
6080 ) -> Result<(), ::fidl_next::ValidationError> {
6081 Ok(())
6082 }
6083 }
6084
6085 unsafe impl ::fidl_next::Wire for BootManagerQueryCurrentConfigurationResponse {
6086 type Narrowed<'de> = BootManagerQueryCurrentConfigurationResponse;
6087
6088 #[inline]
6089 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6090 ::fidl_next::munge! {
6091 let Self {
6092 configuration,
6093
6094 } = &mut *out_;
6095 }
6096
6097 ::fidl_next::Wire::zero_padding(configuration);
6098 }
6099 }
6100
6101 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerQueryCurrentConfigurationResponse
6102 where
6103 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6104 {
6105 fn decode(
6106 slot_: ::fidl_next::Slot<'_, Self>,
6107 decoder_: &mut ___D,
6108 _: (),
6109 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6110 ::fidl_next::munge! {
6111 let Self {
6112 mut configuration,
6113
6114 } = slot_;
6115 }
6116
6117 let _field = configuration.as_mut();
6118
6119 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
6120
6121 Ok(())
6122 }
6123 }
6124
6125 impl ::fidl_next::IntoNatural for BootManagerQueryCurrentConfigurationResponse {
6126 type Natural = crate::natural::BootManagerQueryCurrentConfigurationResponse;
6127 }
6128
6129 #[derive(Clone, Debug)]
6131 #[repr(C)]
6132 pub struct BootManagerQueryActiveConfigurationResponse {
6133 pub configuration: crate::wire::Configuration,
6134 }
6135
6136 static_assertions::const_assert_eq!(
6137 std::mem::size_of::<BootManagerQueryActiveConfigurationResponse>(),
6138 4
6139 );
6140 static_assertions::const_assert_eq!(
6141 std::mem::align_of::<BootManagerQueryActiveConfigurationResponse>(),
6142 4
6143 );
6144
6145 static_assertions::const_assert_eq!(
6146 std::mem::offset_of!(BootManagerQueryActiveConfigurationResponse, configuration),
6147 0
6148 );
6149
6150 impl ::fidl_next::Constrained for BootManagerQueryActiveConfigurationResponse {
6151 type Constraint = ();
6152
6153 fn validate(
6154 _: ::fidl_next::Slot<'_, Self>,
6155 _: Self::Constraint,
6156 ) -> Result<(), ::fidl_next::ValidationError> {
6157 Ok(())
6158 }
6159 }
6160
6161 unsafe impl ::fidl_next::Wire for BootManagerQueryActiveConfigurationResponse {
6162 type Narrowed<'de> = BootManagerQueryActiveConfigurationResponse;
6163
6164 #[inline]
6165 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6166 ::fidl_next::munge! {
6167 let Self {
6168 configuration,
6169
6170 } = &mut *out_;
6171 }
6172
6173 ::fidl_next::Wire::zero_padding(configuration);
6174 }
6175 }
6176
6177 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerQueryActiveConfigurationResponse
6178 where
6179 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6180 {
6181 fn decode(
6182 slot_: ::fidl_next::Slot<'_, Self>,
6183 decoder_: &mut ___D,
6184 _: (),
6185 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6186 ::fidl_next::munge! {
6187 let Self {
6188 mut configuration,
6189
6190 } = slot_;
6191 }
6192
6193 let _field = configuration.as_mut();
6194
6195 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
6196
6197 Ok(())
6198 }
6199 }
6200
6201 impl ::fidl_next::IntoNatural for BootManagerQueryActiveConfigurationResponse {
6202 type Natural = crate::natural::BootManagerQueryActiveConfigurationResponse;
6203 }
6204
6205 #[derive(Clone, Debug)]
6207 #[repr(C)]
6208 pub struct BootManagerQueryConfigurationLastSetActiveResponse {
6209 pub configuration: crate::wire::Configuration,
6210 }
6211
6212 static_assertions::const_assert_eq!(
6213 std::mem::size_of::<BootManagerQueryConfigurationLastSetActiveResponse>(),
6214 4
6215 );
6216 static_assertions::const_assert_eq!(
6217 std::mem::align_of::<BootManagerQueryConfigurationLastSetActiveResponse>(),
6218 4
6219 );
6220
6221 static_assertions::const_assert_eq!(
6222 std::mem::offset_of!(BootManagerQueryConfigurationLastSetActiveResponse, configuration),
6223 0
6224 );
6225
6226 impl ::fidl_next::Constrained for BootManagerQueryConfigurationLastSetActiveResponse {
6227 type Constraint = ();
6228
6229 fn validate(
6230 _: ::fidl_next::Slot<'_, Self>,
6231 _: Self::Constraint,
6232 ) -> Result<(), ::fidl_next::ValidationError> {
6233 Ok(())
6234 }
6235 }
6236
6237 unsafe impl ::fidl_next::Wire for BootManagerQueryConfigurationLastSetActiveResponse {
6238 type Narrowed<'de> = BootManagerQueryConfigurationLastSetActiveResponse;
6239
6240 #[inline]
6241 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6242 ::fidl_next::munge! {
6243 let Self {
6244 configuration,
6245
6246 } = &mut *out_;
6247 }
6248
6249 ::fidl_next::Wire::zero_padding(configuration);
6250 }
6251 }
6252
6253 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerQueryConfigurationLastSetActiveResponse
6254 where
6255 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6256 {
6257 fn decode(
6258 slot_: ::fidl_next::Slot<'_, Self>,
6259 decoder_: &mut ___D,
6260 _: (),
6261 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6262 ::fidl_next::munge! {
6263 let Self {
6264 mut configuration,
6265
6266 } = slot_;
6267 }
6268
6269 let _field = configuration.as_mut();
6270
6271 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
6272
6273 Ok(())
6274 }
6275 }
6276
6277 impl ::fidl_next::IntoNatural for BootManagerQueryConfigurationLastSetActiveResponse {
6278 type Natural = crate::natural::BootManagerQueryConfigurationLastSetActiveResponse;
6279 }
6280
6281 #[derive(Clone, Debug)]
6283 #[repr(C)]
6284 pub struct BootManagerQueryConfigurationStatusRequest {
6285 pub configuration: crate::wire::Configuration,
6286 }
6287
6288 static_assertions::const_assert_eq!(
6289 std::mem::size_of::<BootManagerQueryConfigurationStatusRequest>(),
6290 4
6291 );
6292 static_assertions::const_assert_eq!(
6293 std::mem::align_of::<BootManagerQueryConfigurationStatusRequest>(),
6294 4
6295 );
6296
6297 static_assertions::const_assert_eq!(
6298 std::mem::offset_of!(BootManagerQueryConfigurationStatusRequest, configuration),
6299 0
6300 );
6301
6302 impl ::fidl_next::Constrained for BootManagerQueryConfigurationStatusRequest {
6303 type Constraint = ();
6304
6305 fn validate(
6306 _: ::fidl_next::Slot<'_, Self>,
6307 _: Self::Constraint,
6308 ) -> Result<(), ::fidl_next::ValidationError> {
6309 Ok(())
6310 }
6311 }
6312
6313 unsafe impl ::fidl_next::Wire for BootManagerQueryConfigurationStatusRequest {
6314 type Narrowed<'de> = BootManagerQueryConfigurationStatusRequest;
6315
6316 #[inline]
6317 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6318 ::fidl_next::munge! {
6319 let Self {
6320 configuration,
6321
6322 } = &mut *out_;
6323 }
6324
6325 ::fidl_next::Wire::zero_padding(configuration);
6326 }
6327 }
6328
6329 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerQueryConfigurationStatusRequest
6330 where
6331 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6332 {
6333 fn decode(
6334 slot_: ::fidl_next::Slot<'_, Self>,
6335 decoder_: &mut ___D,
6336 _: (),
6337 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6338 ::fidl_next::munge! {
6339 let Self {
6340 mut configuration,
6341
6342 } = slot_;
6343 }
6344
6345 let _field = configuration.as_mut();
6346
6347 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
6348
6349 Ok(())
6350 }
6351 }
6352
6353 impl ::fidl_next::IntoNatural for BootManagerQueryConfigurationStatusRequest {
6354 type Natural = crate::natural::BootManagerQueryConfigurationStatusRequest;
6355 }
6356
6357 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6359 #[repr(transparent)]
6360 pub struct ConfigurationStatus {
6361 pub(crate) value: ::fidl_next::wire::Uint32,
6362 }
6363
6364 impl ::fidl_next::Constrained for ConfigurationStatus {
6365 type Constraint = ();
6366
6367 fn validate(
6368 _: ::fidl_next::Slot<'_, Self>,
6369 _: Self::Constraint,
6370 ) -> Result<(), ::fidl_next::ValidationError> {
6371 Ok(())
6372 }
6373 }
6374
6375 unsafe impl ::fidl_next::Wire for ConfigurationStatus {
6376 type Narrowed<'de> = Self;
6377
6378 #[inline]
6379 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6380 }
6382 }
6383
6384 impl ConfigurationStatus {
6385 pub const HEALTHY: ConfigurationStatus =
6386 ConfigurationStatus { value: ::fidl_next::wire::Uint32(1) };
6387
6388 pub const PENDING: ConfigurationStatus =
6389 ConfigurationStatus { value: ::fidl_next::wire::Uint32(2) };
6390
6391 pub const UNBOOTABLE: ConfigurationStatus =
6392 ConfigurationStatus { value: ::fidl_next::wire::Uint32(3) };
6393 }
6394
6395 unsafe impl<___D> ::fidl_next::Decode<___D> for ConfigurationStatus
6396 where
6397 ___D: ?Sized,
6398 {
6399 fn decode(
6400 slot: ::fidl_next::Slot<'_, Self>,
6401 _: &mut ___D,
6402 _: (),
6403 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6404 ::fidl_next::munge!(let Self { value } = slot);
6405
6406 match u32::from(*value) {
6407 1 | 2 | 3 => (),
6408 unknown => {
6409 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
6410 }
6411 }
6412
6413 Ok(())
6414 }
6415 }
6416
6417 impl ::core::convert::From<crate::natural::ConfigurationStatus> for ConfigurationStatus {
6418 fn from(natural: crate::natural::ConfigurationStatus) -> Self {
6419 match natural {
6420 crate::natural::ConfigurationStatus::Healthy => ConfigurationStatus::HEALTHY,
6421
6422 crate::natural::ConfigurationStatus::Pending => ConfigurationStatus::PENDING,
6423
6424 crate::natural::ConfigurationStatus::Unbootable => ConfigurationStatus::UNBOOTABLE,
6425 }
6426 }
6427 }
6428
6429 impl ::fidl_next::IntoNatural for ConfigurationStatus {
6430 type Natural = crate::natural::ConfigurationStatus;
6431 }
6432
6433 #[derive(Clone, Debug)]
6435 #[repr(C)]
6436 pub struct BootManagerQueryConfigurationStatusResponse {
6437 pub status: crate::wire::ConfigurationStatus,
6438 }
6439
6440 static_assertions::const_assert_eq!(
6441 std::mem::size_of::<BootManagerQueryConfigurationStatusResponse>(),
6442 4
6443 );
6444 static_assertions::const_assert_eq!(
6445 std::mem::align_of::<BootManagerQueryConfigurationStatusResponse>(),
6446 4
6447 );
6448
6449 static_assertions::const_assert_eq!(
6450 std::mem::offset_of!(BootManagerQueryConfigurationStatusResponse, status),
6451 0
6452 );
6453
6454 impl ::fidl_next::Constrained for BootManagerQueryConfigurationStatusResponse {
6455 type Constraint = ();
6456
6457 fn validate(
6458 _: ::fidl_next::Slot<'_, Self>,
6459 _: Self::Constraint,
6460 ) -> Result<(), ::fidl_next::ValidationError> {
6461 Ok(())
6462 }
6463 }
6464
6465 unsafe impl ::fidl_next::Wire for BootManagerQueryConfigurationStatusResponse {
6466 type Narrowed<'de> = BootManagerQueryConfigurationStatusResponse;
6467
6468 #[inline]
6469 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6470 ::fidl_next::munge! {
6471 let Self {
6472 status,
6473
6474 } = &mut *out_;
6475 }
6476
6477 ::fidl_next::Wire::zero_padding(status);
6478 }
6479 }
6480
6481 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerQueryConfigurationStatusResponse
6482 where
6483 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6484 {
6485 fn decode(
6486 slot_: ::fidl_next::Slot<'_, Self>,
6487 decoder_: &mut ___D,
6488 _: (),
6489 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6490 ::fidl_next::munge! {
6491 let Self {
6492 mut status,
6493
6494 } = slot_;
6495 }
6496
6497 let _field = status.as_mut();
6498
6499 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
6500
6501 Ok(())
6502 }
6503 }
6504
6505 impl ::fidl_next::IntoNatural for BootManagerQueryConfigurationStatusResponse {
6506 type Natural = crate::natural::BootManagerQueryConfigurationStatusResponse;
6507 }
6508
6509 #[derive(Clone, Debug)]
6511 #[repr(C)]
6512 pub struct BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
6513 pub configuration: crate::wire::Configuration,
6514 }
6515
6516 static_assertions::const_assert_eq!(
6517 std::mem::size_of::<BootManagerQueryConfigurationStatusAndBootAttemptsRequest>(),
6518 4
6519 );
6520 static_assertions::const_assert_eq!(
6521 std::mem::align_of::<BootManagerQueryConfigurationStatusAndBootAttemptsRequest>(),
6522 4
6523 );
6524
6525 static_assertions::const_assert_eq!(
6526 std::mem::offset_of!(
6527 BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
6528 configuration
6529 ),
6530 0
6531 );
6532
6533 impl ::fidl_next::Constrained for BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
6534 type Constraint = ();
6535
6536 fn validate(
6537 _: ::fidl_next::Slot<'_, Self>,
6538 _: Self::Constraint,
6539 ) -> Result<(), ::fidl_next::ValidationError> {
6540 Ok(())
6541 }
6542 }
6543
6544 unsafe impl ::fidl_next::Wire for BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
6545 type Narrowed<'de> = BootManagerQueryConfigurationStatusAndBootAttemptsRequest;
6546
6547 #[inline]
6548 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6549 ::fidl_next::munge! {
6550 let Self {
6551 configuration,
6552
6553 } = &mut *out_;
6554 }
6555
6556 ::fidl_next::Wire::zero_padding(configuration);
6557 }
6558 }
6559
6560 unsafe impl<___D> ::fidl_next::Decode<___D>
6561 for BootManagerQueryConfigurationStatusAndBootAttemptsRequest
6562 where
6563 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6564 {
6565 fn decode(
6566 slot_: ::fidl_next::Slot<'_, Self>,
6567 decoder_: &mut ___D,
6568 _: (),
6569 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6570 ::fidl_next::munge! {
6571 let Self {
6572 mut configuration,
6573
6574 } = slot_;
6575 }
6576
6577 let _field = configuration.as_mut();
6578
6579 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
6580
6581 Ok(())
6582 }
6583 }
6584
6585 impl ::fidl_next::IntoNatural for BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
6586 type Natural = crate::natural::BootManagerQueryConfigurationStatusAndBootAttemptsRequest;
6587 }
6588
6589 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6591 #[repr(transparent)]
6592 pub struct UnbootableReason {
6593 pub(crate) value: ::fidl_next::wire::Uint32,
6594 }
6595
6596 impl ::fidl_next::Constrained for UnbootableReason {
6597 type Constraint = ();
6598
6599 fn validate(
6600 _: ::fidl_next::Slot<'_, Self>,
6601 _: Self::Constraint,
6602 ) -> Result<(), ::fidl_next::ValidationError> {
6603 Ok(())
6604 }
6605 }
6606
6607 unsafe impl ::fidl_next::Wire for UnbootableReason {
6608 type Narrowed<'de> = Self;
6609
6610 #[inline]
6611 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6612 }
6614 }
6615
6616 impl UnbootableReason {
6617 pub const NONE: UnbootableReason = UnbootableReason { value: ::fidl_next::wire::Uint32(0) };
6618
6619 pub const NO_MORE_TRIES: UnbootableReason =
6620 UnbootableReason { value: ::fidl_next::wire::Uint32(1) };
6621
6622 pub const OS_REQUESTED: UnbootableReason =
6623 UnbootableReason { value: ::fidl_next::wire::Uint32(2) };
6624
6625 pub const VERIFICATION_FAILURE: UnbootableReason =
6626 UnbootableReason { value: ::fidl_next::wire::Uint32(3) };
6627 }
6628
6629 unsafe impl<___D> ::fidl_next::Decode<___D> for UnbootableReason
6630 where
6631 ___D: ?Sized,
6632 {
6633 fn decode(
6634 slot: ::fidl_next::Slot<'_, Self>,
6635 _: &mut ___D,
6636 _: (),
6637 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6638 Ok(())
6639 }
6640 }
6641
6642 impl ::core::convert::From<crate::natural::UnbootableReason> for UnbootableReason {
6643 fn from(natural: crate::natural::UnbootableReason) -> Self {
6644 match natural {
6645 crate::natural::UnbootableReason::None => UnbootableReason::NONE,
6646
6647 crate::natural::UnbootableReason::NoMoreTries => UnbootableReason::NO_MORE_TRIES,
6648
6649 crate::natural::UnbootableReason::OsRequested => UnbootableReason::OS_REQUESTED,
6650
6651 crate::natural::UnbootableReason::VerificationFailure => {
6652 UnbootableReason::VERIFICATION_FAILURE
6653 }
6654
6655 crate::natural::UnbootableReason::UnknownOrdinal_(value) => {
6656 UnbootableReason { value: ::fidl_next::wire::Uint32::from(value) }
6657 }
6658 }
6659 }
6660 }
6661
6662 impl ::fidl_next::IntoNatural for UnbootableReason {
6663 type Natural = crate::natural::UnbootableReason;
6664 }
6665
6666 #[repr(C)]
6668 pub struct BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de> {
6669 pub(crate) table: ::fidl_next::wire::Table<'de>,
6670 }
6671
6672 impl<'de> Drop for BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de> {
6673 fn drop(&mut self) {
6674 let _ = self.table.get(1).map(|envelope| unsafe {
6675 envelope.read_unchecked::<crate::wire::ConfigurationStatus>()
6676 });
6677
6678 let _ = self.table.get(2).map(|envelope| unsafe { envelope.read_unchecked::<u8>() });
6679
6680 let _ = self.table.get(3).map(|envelope| unsafe {
6681 envelope.read_unchecked::<crate::wire::UnbootableReason>()
6682 });
6683 }
6684 }
6685
6686 impl ::fidl_next::Constrained for BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'_> {
6687 type Constraint = ();
6688
6689 fn validate(
6690 _: ::fidl_next::Slot<'_, Self>,
6691 _: Self::Constraint,
6692 ) -> Result<(), ::fidl_next::ValidationError> {
6693 Ok(())
6694 }
6695 }
6696
6697 unsafe impl ::fidl_next::Wire
6698 for BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'static>
6699 {
6700 type Narrowed<'de> = BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>;
6701
6702 #[inline]
6703 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6704 ::fidl_next::munge!(let Self { table } = out);
6705 ::fidl_next::wire::Table::zero_padding(table);
6706 }
6707 }
6708
6709 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
6710 for BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>
6711 where
6712 ___D: ::fidl_next::Decoder<'de> + ?Sized,
6713 {
6714 fn decode(
6715 slot: ::fidl_next::Slot<'_, Self>,
6716 decoder: &mut ___D,
6717 _: (),
6718 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6719 ::fidl_next::munge!(let Self { table } = slot);
6720
6721 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
6722 match ordinal {
6723 0 => unsafe { ::core::hint::unreachable_unchecked() },
6724
6725 1 => {
6726 ::fidl_next::wire::Envelope::decode_as::<
6727 ___D,
6728 crate::wire::ConfigurationStatus,
6729 >(slot.as_mut(), decoder, ())?;
6730
6731 Ok(())
6732 }
6733
6734 2 => {
6735 ::fidl_next::wire::Envelope::decode_as::<___D, u8>(
6736 slot.as_mut(),
6737 decoder,
6738 (),
6739 )?;
6740
6741 Ok(())
6742 }
6743
6744 3 => {
6745 ::fidl_next::wire::Envelope::decode_as::<
6746 ___D,
6747 crate::wire::UnbootableReason,
6748 >(slot.as_mut(), decoder, ())?;
6749
6750 Ok(())
6751 }
6752
6753 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
6754 }
6755 })
6756 }
6757 }
6758
6759 impl<'de> BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de> {
6760 pub fn status(&self) -> ::core::option::Option<&crate::wire::ConfigurationStatus> {
6761 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
6762 }
6763
6764 pub fn take_status(&mut self) -> ::core::option::Option<crate::wire::ConfigurationStatus> {
6765 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
6766 }
6767
6768 pub fn boot_attempts(&self) -> ::core::option::Option<&u8> {
6769 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
6770 }
6771
6772 pub fn take_boot_attempts(&mut self) -> ::core::option::Option<u8> {
6773 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
6774 }
6775
6776 pub fn unbootable_reason(&self) -> ::core::option::Option<&crate::wire::UnbootableReason> {
6777 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
6778 }
6779
6780 pub fn take_unbootable_reason(
6781 &mut self,
6782 ) -> ::core::option::Option<crate::wire::UnbootableReason> {
6783 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
6784 }
6785 }
6786
6787 impl<'de> ::core::fmt::Debug for BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de> {
6788 fn fmt(
6789 &self,
6790 f: &mut ::core::fmt::Formatter<'_>,
6791 ) -> ::core::result::Result<(), ::core::fmt::Error> {
6792 f.debug_struct("BootManagerQueryConfigurationStatusAndBootAttemptsResponse")
6793 .field("status", &self.status())
6794 .field("boot_attempts", &self.boot_attempts())
6795 .field("unbootable_reason", &self.unbootable_reason())
6796 .finish()
6797 }
6798 }
6799
6800 impl<'de> ::fidl_next::IntoNatural
6801 for BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'de>
6802 {
6803 type Natural = crate::natural::BootManagerQueryConfigurationStatusAndBootAttemptsResponse;
6804 }
6805
6806 #[derive(Clone, Debug)]
6808 #[repr(C)]
6809 pub struct BootManagerSetConfigurationActiveRequest {
6810 pub configuration: crate::wire::Configuration,
6811 }
6812
6813 static_assertions::const_assert_eq!(
6814 std::mem::size_of::<BootManagerSetConfigurationActiveRequest>(),
6815 4
6816 );
6817 static_assertions::const_assert_eq!(
6818 std::mem::align_of::<BootManagerSetConfigurationActiveRequest>(),
6819 4
6820 );
6821
6822 static_assertions::const_assert_eq!(
6823 std::mem::offset_of!(BootManagerSetConfigurationActiveRequest, configuration),
6824 0
6825 );
6826
6827 impl ::fidl_next::Constrained for BootManagerSetConfigurationActiveRequest {
6828 type Constraint = ();
6829
6830 fn validate(
6831 _: ::fidl_next::Slot<'_, Self>,
6832 _: Self::Constraint,
6833 ) -> Result<(), ::fidl_next::ValidationError> {
6834 Ok(())
6835 }
6836 }
6837
6838 unsafe impl ::fidl_next::Wire for BootManagerSetConfigurationActiveRequest {
6839 type Narrowed<'de> = BootManagerSetConfigurationActiveRequest;
6840
6841 #[inline]
6842 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6843 ::fidl_next::munge! {
6844 let Self {
6845 configuration,
6846
6847 } = &mut *out_;
6848 }
6849
6850 ::fidl_next::Wire::zero_padding(configuration);
6851 }
6852 }
6853
6854 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerSetConfigurationActiveRequest
6855 where
6856 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6857 {
6858 fn decode(
6859 slot_: ::fidl_next::Slot<'_, Self>,
6860 decoder_: &mut ___D,
6861 _: (),
6862 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6863 ::fidl_next::munge! {
6864 let Self {
6865 mut configuration,
6866
6867 } = slot_;
6868 }
6869
6870 let _field = configuration.as_mut();
6871
6872 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
6873
6874 Ok(())
6875 }
6876 }
6877
6878 impl ::fidl_next::IntoNatural for BootManagerSetConfigurationActiveRequest {
6879 type Natural = crate::natural::BootManagerSetConfigurationActiveRequest;
6880 }
6881
6882 #[derive(Clone, Debug)]
6884 #[repr(C)]
6885 pub struct BootManagerSetConfigurationActiveResponse {
6886 pub status: ::fidl_next::wire::fuchsia::StatusResult,
6887 }
6888
6889 static_assertions::const_assert_eq!(
6890 std::mem::size_of::<BootManagerSetConfigurationActiveResponse>(),
6891 4
6892 );
6893 static_assertions::const_assert_eq!(
6894 std::mem::align_of::<BootManagerSetConfigurationActiveResponse>(),
6895 4
6896 );
6897
6898 static_assertions::const_assert_eq!(
6899 std::mem::offset_of!(BootManagerSetConfigurationActiveResponse, status),
6900 0
6901 );
6902
6903 impl ::fidl_next::Constrained for BootManagerSetConfigurationActiveResponse {
6904 type Constraint = ();
6905
6906 fn validate(
6907 _: ::fidl_next::Slot<'_, Self>,
6908 _: Self::Constraint,
6909 ) -> Result<(), ::fidl_next::ValidationError> {
6910 Ok(())
6911 }
6912 }
6913
6914 unsafe impl ::fidl_next::Wire for BootManagerSetConfigurationActiveResponse {
6915 type Narrowed<'de> = BootManagerSetConfigurationActiveResponse;
6916
6917 #[inline]
6918 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6919 ::fidl_next::munge! {
6920 let Self {
6921 status,
6922
6923 } = &mut *out_;
6924 }
6925
6926 ::fidl_next::Wire::zero_padding(status);
6927 }
6928 }
6929
6930 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerSetConfigurationActiveResponse
6931 where
6932 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6933 {
6934 fn decode(
6935 slot_: ::fidl_next::Slot<'_, Self>,
6936 decoder_: &mut ___D,
6937 _: (),
6938 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6939 ::fidl_next::munge! {
6940 let Self {
6941 mut status,
6942
6943 } = slot_;
6944 }
6945
6946 let _field = status.as_mut();
6947
6948 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
6949
6950 Ok(())
6951 }
6952 }
6953
6954 impl ::fidl_next::IntoNatural for BootManagerSetConfigurationActiveResponse {
6955 type Natural = crate::natural::BootManagerSetConfigurationActiveResponse;
6956 }
6957
6958 #[derive(Clone, Debug)]
6960 #[repr(C)]
6961 pub struct BootManagerSetConfigurationUnbootableRequest {
6962 pub configuration: crate::wire::Configuration,
6963 }
6964
6965 static_assertions::const_assert_eq!(
6966 std::mem::size_of::<BootManagerSetConfigurationUnbootableRequest>(),
6967 4
6968 );
6969 static_assertions::const_assert_eq!(
6970 std::mem::align_of::<BootManagerSetConfigurationUnbootableRequest>(),
6971 4
6972 );
6973
6974 static_assertions::const_assert_eq!(
6975 std::mem::offset_of!(BootManagerSetConfigurationUnbootableRequest, configuration),
6976 0
6977 );
6978
6979 impl ::fidl_next::Constrained for BootManagerSetConfigurationUnbootableRequest {
6980 type Constraint = ();
6981
6982 fn validate(
6983 _: ::fidl_next::Slot<'_, Self>,
6984 _: Self::Constraint,
6985 ) -> Result<(), ::fidl_next::ValidationError> {
6986 Ok(())
6987 }
6988 }
6989
6990 unsafe impl ::fidl_next::Wire for BootManagerSetConfigurationUnbootableRequest {
6991 type Narrowed<'de> = BootManagerSetConfigurationUnbootableRequest;
6992
6993 #[inline]
6994 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6995 ::fidl_next::munge! {
6996 let Self {
6997 configuration,
6998
6999 } = &mut *out_;
7000 }
7001
7002 ::fidl_next::Wire::zero_padding(configuration);
7003 }
7004 }
7005
7006 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerSetConfigurationUnbootableRequest
7007 where
7008 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7009 {
7010 fn decode(
7011 slot_: ::fidl_next::Slot<'_, Self>,
7012 decoder_: &mut ___D,
7013 _: (),
7014 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7015 ::fidl_next::munge! {
7016 let Self {
7017 mut configuration,
7018
7019 } = slot_;
7020 }
7021
7022 let _field = configuration.as_mut();
7023
7024 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
7025
7026 Ok(())
7027 }
7028 }
7029
7030 impl ::fidl_next::IntoNatural for BootManagerSetConfigurationUnbootableRequest {
7031 type Natural = crate::natural::BootManagerSetConfigurationUnbootableRequest;
7032 }
7033
7034 #[derive(Clone, Debug)]
7036 #[repr(C)]
7037 pub struct BootManagerSetConfigurationUnbootableResponse {
7038 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7039 }
7040
7041 static_assertions::const_assert_eq!(
7042 std::mem::size_of::<BootManagerSetConfigurationUnbootableResponse>(),
7043 4
7044 );
7045 static_assertions::const_assert_eq!(
7046 std::mem::align_of::<BootManagerSetConfigurationUnbootableResponse>(),
7047 4
7048 );
7049
7050 static_assertions::const_assert_eq!(
7051 std::mem::offset_of!(BootManagerSetConfigurationUnbootableResponse, status),
7052 0
7053 );
7054
7055 impl ::fidl_next::Constrained for BootManagerSetConfigurationUnbootableResponse {
7056 type Constraint = ();
7057
7058 fn validate(
7059 _: ::fidl_next::Slot<'_, Self>,
7060 _: Self::Constraint,
7061 ) -> Result<(), ::fidl_next::ValidationError> {
7062 Ok(())
7063 }
7064 }
7065
7066 unsafe impl ::fidl_next::Wire for BootManagerSetConfigurationUnbootableResponse {
7067 type Narrowed<'de> = BootManagerSetConfigurationUnbootableResponse;
7068
7069 #[inline]
7070 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7071 ::fidl_next::munge! {
7072 let Self {
7073 status,
7074
7075 } = &mut *out_;
7076 }
7077
7078 ::fidl_next::Wire::zero_padding(status);
7079 }
7080 }
7081
7082 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerSetConfigurationUnbootableResponse
7083 where
7084 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7085 {
7086 fn decode(
7087 slot_: ::fidl_next::Slot<'_, Self>,
7088 decoder_: &mut ___D,
7089 _: (),
7090 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7091 ::fidl_next::munge! {
7092 let Self {
7093 mut status,
7094
7095 } = slot_;
7096 }
7097
7098 let _field = status.as_mut();
7099
7100 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7101
7102 Ok(())
7103 }
7104 }
7105
7106 impl ::fidl_next::IntoNatural for BootManagerSetConfigurationUnbootableResponse {
7107 type Natural = crate::natural::BootManagerSetConfigurationUnbootableResponse;
7108 }
7109
7110 #[derive(Clone, Debug)]
7112 #[repr(C)]
7113 pub struct BootManagerSetConfigurationHealthyRequest {
7114 pub configuration: crate::wire::Configuration,
7115 }
7116
7117 static_assertions::const_assert_eq!(
7118 std::mem::size_of::<BootManagerSetConfigurationHealthyRequest>(),
7119 4
7120 );
7121 static_assertions::const_assert_eq!(
7122 std::mem::align_of::<BootManagerSetConfigurationHealthyRequest>(),
7123 4
7124 );
7125
7126 static_assertions::const_assert_eq!(
7127 std::mem::offset_of!(BootManagerSetConfigurationHealthyRequest, configuration),
7128 0
7129 );
7130
7131 impl ::fidl_next::Constrained for BootManagerSetConfigurationHealthyRequest {
7132 type Constraint = ();
7133
7134 fn validate(
7135 _: ::fidl_next::Slot<'_, Self>,
7136 _: Self::Constraint,
7137 ) -> Result<(), ::fidl_next::ValidationError> {
7138 Ok(())
7139 }
7140 }
7141
7142 unsafe impl ::fidl_next::Wire for BootManagerSetConfigurationHealthyRequest {
7143 type Narrowed<'de> = BootManagerSetConfigurationHealthyRequest;
7144
7145 #[inline]
7146 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7147 ::fidl_next::munge! {
7148 let Self {
7149 configuration,
7150
7151 } = &mut *out_;
7152 }
7153
7154 ::fidl_next::Wire::zero_padding(configuration);
7155 }
7156 }
7157
7158 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerSetConfigurationHealthyRequest
7159 where
7160 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7161 {
7162 fn decode(
7163 slot_: ::fidl_next::Slot<'_, Self>,
7164 decoder_: &mut ___D,
7165 _: (),
7166 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7167 ::fidl_next::munge! {
7168 let Self {
7169 mut configuration,
7170
7171 } = slot_;
7172 }
7173
7174 let _field = configuration.as_mut();
7175
7176 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
7177
7178 Ok(())
7179 }
7180 }
7181
7182 impl ::fidl_next::IntoNatural for BootManagerSetConfigurationHealthyRequest {
7183 type Natural = crate::natural::BootManagerSetConfigurationHealthyRequest;
7184 }
7185
7186 #[derive(Clone, Debug)]
7188 #[repr(C)]
7189 pub struct BootManagerSetConfigurationHealthyResponse {
7190 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7191 }
7192
7193 static_assertions::const_assert_eq!(
7194 std::mem::size_of::<BootManagerSetConfigurationHealthyResponse>(),
7195 4
7196 );
7197 static_assertions::const_assert_eq!(
7198 std::mem::align_of::<BootManagerSetConfigurationHealthyResponse>(),
7199 4
7200 );
7201
7202 static_assertions::const_assert_eq!(
7203 std::mem::offset_of!(BootManagerSetConfigurationHealthyResponse, status),
7204 0
7205 );
7206
7207 impl ::fidl_next::Constrained for BootManagerSetConfigurationHealthyResponse {
7208 type Constraint = ();
7209
7210 fn validate(
7211 _: ::fidl_next::Slot<'_, Self>,
7212 _: Self::Constraint,
7213 ) -> Result<(), ::fidl_next::ValidationError> {
7214 Ok(())
7215 }
7216 }
7217
7218 unsafe impl ::fidl_next::Wire for BootManagerSetConfigurationHealthyResponse {
7219 type Narrowed<'de> = BootManagerSetConfigurationHealthyResponse;
7220
7221 #[inline]
7222 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7223 ::fidl_next::munge! {
7224 let Self {
7225 status,
7226
7227 } = &mut *out_;
7228 }
7229
7230 ::fidl_next::Wire::zero_padding(status);
7231 }
7232 }
7233
7234 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerSetConfigurationHealthyResponse
7235 where
7236 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7237 {
7238 fn decode(
7239 slot_: ::fidl_next::Slot<'_, Self>,
7240 decoder_: &mut ___D,
7241 _: (),
7242 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7243 ::fidl_next::munge! {
7244 let Self {
7245 mut status,
7246
7247 } = slot_;
7248 }
7249
7250 let _field = status.as_mut();
7251
7252 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7253
7254 Ok(())
7255 }
7256 }
7257
7258 impl ::fidl_next::IntoNatural for BootManagerSetConfigurationHealthyResponse {
7259 type Natural = crate::natural::BootManagerSetConfigurationHealthyResponse;
7260 }
7261
7262 pub type BootManagerSetOneShotRecoveryResponse = ::fidl_next::wire::Unit;
7264
7265 #[derive(Clone, Debug)]
7267 #[repr(C)]
7268 pub struct BootManagerFlushResponse {
7269 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7270 }
7271
7272 static_assertions::const_assert_eq!(std::mem::size_of::<BootManagerFlushResponse>(), 4);
7273 static_assertions::const_assert_eq!(std::mem::align_of::<BootManagerFlushResponse>(), 4);
7274
7275 static_assertions::const_assert_eq!(std::mem::offset_of!(BootManagerFlushResponse, status), 0);
7276
7277 impl ::fidl_next::Constrained for BootManagerFlushResponse {
7278 type Constraint = ();
7279
7280 fn validate(
7281 _: ::fidl_next::Slot<'_, Self>,
7282 _: Self::Constraint,
7283 ) -> Result<(), ::fidl_next::ValidationError> {
7284 Ok(())
7285 }
7286 }
7287
7288 unsafe impl ::fidl_next::Wire for BootManagerFlushResponse {
7289 type Narrowed<'de> = BootManagerFlushResponse;
7290
7291 #[inline]
7292 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7293 ::fidl_next::munge! {
7294 let Self {
7295 status,
7296
7297 } = &mut *out_;
7298 }
7299
7300 ::fidl_next::Wire::zero_padding(status);
7301 }
7302 }
7303
7304 unsafe impl<___D> ::fidl_next::Decode<___D> for BootManagerFlushResponse
7305 where
7306 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7307 {
7308 fn decode(
7309 slot_: ::fidl_next::Slot<'_, Self>,
7310 decoder_: &mut ___D,
7311 _: (),
7312 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7313 ::fidl_next::munge! {
7314 let Self {
7315 mut status,
7316
7317 } = slot_;
7318 }
7319
7320 let _field = status.as_mut();
7321
7322 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7323
7324 Ok(())
7325 }
7326 }
7327
7328 impl ::fidl_next::IntoNatural for BootManagerFlushResponse {
7329 type Natural = crate::natural::BootManagerFlushResponse;
7330 }
7331
7332 #[derive(Clone, Debug)]
7334 #[repr(C)]
7335 pub struct DataSinkReadAssetRequest {
7336 pub configuration: crate::wire::Configuration,
7337
7338 pub asset: crate::wire::Asset,
7339 }
7340
7341 static_assertions::const_assert_eq!(std::mem::size_of::<DataSinkReadAssetRequest>(), 8);
7342 static_assertions::const_assert_eq!(std::mem::align_of::<DataSinkReadAssetRequest>(), 4);
7343
7344 static_assertions::const_assert_eq!(
7345 std::mem::offset_of!(DataSinkReadAssetRequest, configuration),
7346 0
7347 );
7348
7349 static_assertions::const_assert_eq!(std::mem::offset_of!(DataSinkReadAssetRequest, asset), 4);
7350
7351 impl ::fidl_next::Constrained for DataSinkReadAssetRequest {
7352 type Constraint = ();
7353
7354 fn validate(
7355 _: ::fidl_next::Slot<'_, Self>,
7356 _: Self::Constraint,
7357 ) -> Result<(), ::fidl_next::ValidationError> {
7358 Ok(())
7359 }
7360 }
7361
7362 unsafe impl ::fidl_next::Wire for DataSinkReadAssetRequest {
7363 type Narrowed<'de> = DataSinkReadAssetRequest;
7364
7365 #[inline]
7366 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7367 ::fidl_next::munge! {
7368 let Self {
7369 configuration,
7370 asset,
7371
7372 } = &mut *out_;
7373 }
7374
7375 ::fidl_next::Wire::zero_padding(configuration);
7376
7377 ::fidl_next::Wire::zero_padding(asset);
7378 }
7379 }
7380
7381 unsafe impl<___D> ::fidl_next::Decode<___D> for DataSinkReadAssetRequest
7382 where
7383 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7384 {
7385 fn decode(
7386 slot_: ::fidl_next::Slot<'_, Self>,
7387 decoder_: &mut ___D,
7388 _: (),
7389 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7390 ::fidl_next::munge! {
7391 let Self {
7392 mut configuration,
7393 mut asset,
7394
7395 } = slot_;
7396 }
7397
7398 let _field = configuration.as_mut();
7399
7400 ::fidl_next::Decode::decode(configuration.as_mut(), decoder_, ())?;
7401
7402 let _field = asset.as_mut();
7403
7404 ::fidl_next::Decode::decode(asset.as_mut(), decoder_, ())?;
7405
7406 Ok(())
7407 }
7408 }
7409
7410 impl ::fidl_next::IntoNatural for DataSinkReadAssetRequest {
7411 type Natural = crate::natural::DataSinkReadAssetRequest;
7412 }
7413
7414 #[derive(Clone, Debug)]
7416 #[repr(C)]
7417 pub struct DataSinkWriteAssetResponse {
7418 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7419 }
7420
7421 static_assertions::const_assert_eq!(std::mem::size_of::<DataSinkWriteAssetResponse>(), 4);
7422 static_assertions::const_assert_eq!(std::mem::align_of::<DataSinkWriteAssetResponse>(), 4);
7423
7424 static_assertions::const_assert_eq!(
7425 std::mem::offset_of!(DataSinkWriteAssetResponse, status),
7426 0
7427 );
7428
7429 impl ::fidl_next::Constrained for DataSinkWriteAssetResponse {
7430 type Constraint = ();
7431
7432 fn validate(
7433 _: ::fidl_next::Slot<'_, Self>,
7434 _: Self::Constraint,
7435 ) -> Result<(), ::fidl_next::ValidationError> {
7436 Ok(())
7437 }
7438 }
7439
7440 unsafe impl ::fidl_next::Wire for DataSinkWriteAssetResponse {
7441 type Narrowed<'de> = DataSinkWriteAssetResponse;
7442
7443 #[inline]
7444 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7445 ::fidl_next::munge! {
7446 let Self {
7447 status,
7448
7449 } = &mut *out_;
7450 }
7451
7452 ::fidl_next::Wire::zero_padding(status);
7453 }
7454 }
7455
7456 unsafe impl<___D> ::fidl_next::Decode<___D> for DataSinkWriteAssetResponse
7457 where
7458 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7459 {
7460 fn decode(
7461 slot_: ::fidl_next::Slot<'_, Self>,
7462 decoder_: &mut ___D,
7463 _: (),
7464 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7465 ::fidl_next::munge! {
7466 let Self {
7467 mut status,
7468
7469 } = slot_;
7470 }
7471
7472 let _field = status.as_mut();
7473
7474 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7475
7476 Ok(())
7477 }
7478 }
7479
7480 impl ::fidl_next::IntoNatural for DataSinkWriteAssetResponse {
7481 type Natural = crate::natural::DataSinkWriteAssetResponse;
7482 }
7483
7484 #[repr(transparent)]
7486 pub struct WriteFirmwareResult {
7487 pub(crate) raw: ::fidl_next::wire::Union,
7488 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7489 }
7490
7491 impl Drop for WriteFirmwareResult {
7492 fn drop(&mut self) {
7493 match self.raw.ordinal() {
7494 1 => {
7495 let _ = unsafe {
7496 self.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
7497 };
7498 }
7499
7500 2 => {
7501 let _ = unsafe { self.raw.get().read_unchecked::<bool>() };
7502 }
7503
7504 _ => unsafe { ::core::hint::unreachable_unchecked() },
7505 }
7506 }
7507 }
7508
7509 impl ::fidl_next::Constrained for WriteFirmwareResult {
7510 type Constraint = ();
7511
7512 fn validate(
7513 _: ::fidl_next::Slot<'_, Self>,
7514 _: Self::Constraint,
7515 ) -> Result<(), ::fidl_next::ValidationError> {
7516 Ok(())
7517 }
7518 }
7519
7520 unsafe impl ::fidl_next::Wire for WriteFirmwareResult {
7521 type Narrowed<'de> = WriteFirmwareResult;
7522
7523 #[inline]
7524 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7525 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7526 ::fidl_next::wire::Union::zero_padding(raw);
7527 }
7528 }
7529
7530 pub mod write_firmware_result {
7531 pub enum Ref<'de> {
7532 Status(&'de ::fidl_next::wire::fuchsia::StatusResult),
7533
7534 Unsupported(&'de bool),
7535 }
7536
7537 pub enum Value {
7538 Status(::fidl_next::wire::fuchsia::StatusResult),
7539
7540 Unsupported(bool),
7541 }
7542 }
7543
7544 impl WriteFirmwareResult {
7545 pub fn as_ref(&self) -> crate::wire::write_firmware_result::Ref<'_> {
7546 match self.raw.ordinal() {
7547 1 => crate::wire::write_firmware_result::Ref::Status(unsafe {
7548 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
7549 }),
7550
7551 2 => crate::wire::write_firmware_result::Ref::Unsupported(unsafe {
7552 self.raw.get().deref_unchecked::<bool>()
7553 }),
7554
7555 _ => unsafe { ::core::hint::unreachable_unchecked() },
7556 }
7557 }
7558
7559 pub fn into_inner(self) -> crate::wire::write_firmware_result::Value {
7560 let this = ::core::mem::ManuallyDrop::new(self);
7561
7562 match this.raw.ordinal() {
7563 1 => crate::wire::write_firmware_result::Value::Status(unsafe {
7564 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
7565 }),
7566
7567 2 => crate::wire::write_firmware_result::Value::Unsupported(unsafe {
7568 this.raw.get().read_unchecked::<bool>()
7569 }),
7570
7571 _ => unsafe { ::core::hint::unreachable_unchecked() },
7572 }
7573 }
7574 }
7575
7576 impl Clone for WriteFirmwareResult {
7577 fn clone(&self) -> Self {
7578 match self.raw.ordinal() {
7579 1 => Self {
7580 raw: unsafe {
7581 self.raw
7582 .clone_inline_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
7583 },
7584 _phantom: ::core::marker::PhantomData,
7585 },
7586
7587 2 => Self {
7588 raw: unsafe { self.raw.clone_inline_unchecked::<bool>() },
7589 _phantom: ::core::marker::PhantomData,
7590 },
7591
7592 _ => unsafe { ::core::hint::unreachable_unchecked() },
7593 }
7594 }
7595 }
7596
7597 unsafe impl<___D> ::fidl_next::Decode<___D> for WriteFirmwareResult
7598 where
7599 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7600 {
7601 fn decode(
7602 mut slot: ::fidl_next::Slot<'_, Self>,
7603 decoder: &mut ___D,
7604 _: (),
7605 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7606 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7607 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7608 1 => ::fidl_next::wire::Union::decode_as_static::<
7609 ___D,
7610 ::fidl_next::wire::fuchsia::StatusResult,
7611 >(raw, decoder, ())?,
7612
7613 2 => ::fidl_next::wire::Union::decode_as_static::<___D, bool>(raw, decoder, ())?,
7614
7615 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
7616 }
7617
7618 Ok(())
7619 }
7620 }
7621
7622 impl ::core::fmt::Debug for WriteFirmwareResult {
7623 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7624 match self.raw.ordinal() {
7625 1 => unsafe {
7626 self.raw
7627 .get()
7628 .deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
7629 .fmt(f)
7630 },
7631 2 => unsafe { self.raw.get().deref_unchecked::<bool>().fmt(f) },
7632 _ => unsafe { ::core::hint::unreachable_unchecked() },
7633 }
7634 }
7635 }
7636
7637 impl ::fidl_next::IntoNatural for WriteFirmwareResult {
7638 type Natural = crate::natural::WriteFirmwareResult;
7639 }
7640
7641 #[derive(Clone, Debug)]
7643 #[repr(C)]
7644 pub struct DataSinkWriteFirmwareResponse {
7645 pub result: crate::wire::WriteFirmwareResult,
7646 }
7647
7648 static_assertions::const_assert_eq!(std::mem::size_of::<DataSinkWriteFirmwareResponse>(), 16);
7649 static_assertions::const_assert_eq!(std::mem::align_of::<DataSinkWriteFirmwareResponse>(), 8);
7650
7651 static_assertions::const_assert_eq!(
7652 std::mem::offset_of!(DataSinkWriteFirmwareResponse, result),
7653 0
7654 );
7655
7656 impl ::fidl_next::Constrained for DataSinkWriteFirmwareResponse {
7657 type Constraint = ();
7658
7659 fn validate(
7660 _: ::fidl_next::Slot<'_, Self>,
7661 _: Self::Constraint,
7662 ) -> Result<(), ::fidl_next::ValidationError> {
7663 Ok(())
7664 }
7665 }
7666
7667 unsafe impl ::fidl_next::Wire for DataSinkWriteFirmwareResponse {
7668 type Narrowed<'de> = DataSinkWriteFirmwareResponse;
7669
7670 #[inline]
7671 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7672 ::fidl_next::munge! {
7673 let Self {
7674 result,
7675
7676 } = &mut *out_;
7677 }
7678
7679 ::fidl_next::Wire::zero_padding(result);
7680 }
7681 }
7682
7683 unsafe impl<___D> ::fidl_next::Decode<___D> for DataSinkWriteFirmwareResponse
7684 where
7685 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7686 {
7687 fn decode(
7688 slot_: ::fidl_next::Slot<'_, Self>,
7689 decoder_: &mut ___D,
7690 _: (),
7691 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7692 ::fidl_next::munge! {
7693 let Self {
7694 mut result,
7695
7696 } = slot_;
7697 }
7698
7699 let _field = result.as_mut();
7700
7701 ::fidl_next::Decode::decode(result.as_mut(), decoder_, ())?;
7702
7703 Ok(())
7704 }
7705 }
7706
7707 impl ::fidl_next::IntoNatural for DataSinkWriteFirmwareResponse {
7708 type Natural = crate::natural::DataSinkWriteFirmwareResponse;
7709 }
7710
7711 pub type DataSinkWriteOpaqueVolumeResponse = ::fidl_next::wire::Unit;
7713
7714 pub type DataSinkWriteSparseVolumeResponse = ::fidl_next::wire::Unit;
7716
7717 #[derive(Clone, Debug)]
7719 #[repr(C)]
7720 pub struct DataSinkFlushResponse {
7721 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7722 }
7723
7724 static_assertions::const_assert_eq!(std::mem::size_of::<DataSinkFlushResponse>(), 4);
7725 static_assertions::const_assert_eq!(std::mem::align_of::<DataSinkFlushResponse>(), 4);
7726
7727 static_assertions::const_assert_eq!(std::mem::offset_of!(DataSinkFlushResponse, status), 0);
7728
7729 impl ::fidl_next::Constrained for DataSinkFlushResponse {
7730 type Constraint = ();
7731
7732 fn validate(
7733 _: ::fidl_next::Slot<'_, Self>,
7734 _: Self::Constraint,
7735 ) -> Result<(), ::fidl_next::ValidationError> {
7736 Ok(())
7737 }
7738 }
7739
7740 unsafe impl ::fidl_next::Wire for DataSinkFlushResponse {
7741 type Narrowed<'de> = DataSinkFlushResponse;
7742
7743 #[inline]
7744 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7745 ::fidl_next::munge! {
7746 let Self {
7747 status,
7748
7749 } = &mut *out_;
7750 }
7751
7752 ::fidl_next::Wire::zero_padding(status);
7753 }
7754 }
7755
7756 unsafe impl<___D> ::fidl_next::Decode<___D> for DataSinkFlushResponse
7757 where
7758 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7759 {
7760 fn decode(
7761 slot_: ::fidl_next::Slot<'_, Self>,
7762 decoder_: &mut ___D,
7763 _: (),
7764 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7765 ::fidl_next::munge! {
7766 let Self {
7767 mut status,
7768
7769 } = slot_;
7770 }
7771
7772 let _field = status.as_mut();
7773
7774 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7775
7776 Ok(())
7777 }
7778 }
7779
7780 impl ::fidl_next::IntoNatural for DataSinkFlushResponse {
7781 type Natural = crate::natural::DataSinkFlushResponse;
7782 }
7783
7784 #[derive(Clone, Debug)]
7786 #[repr(C)]
7787 pub struct DynamicDataSinkInitializePartitionTablesResponse {
7788 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7789 }
7790
7791 static_assertions::const_assert_eq!(
7792 std::mem::size_of::<DynamicDataSinkInitializePartitionTablesResponse>(),
7793 4
7794 );
7795 static_assertions::const_assert_eq!(
7796 std::mem::align_of::<DynamicDataSinkInitializePartitionTablesResponse>(),
7797 4
7798 );
7799
7800 static_assertions::const_assert_eq!(
7801 std::mem::offset_of!(DynamicDataSinkInitializePartitionTablesResponse, status),
7802 0
7803 );
7804
7805 impl ::fidl_next::Constrained for DynamicDataSinkInitializePartitionTablesResponse {
7806 type Constraint = ();
7807
7808 fn validate(
7809 _: ::fidl_next::Slot<'_, Self>,
7810 _: Self::Constraint,
7811 ) -> Result<(), ::fidl_next::ValidationError> {
7812 Ok(())
7813 }
7814 }
7815
7816 unsafe impl ::fidl_next::Wire for DynamicDataSinkInitializePartitionTablesResponse {
7817 type Narrowed<'de> = DynamicDataSinkInitializePartitionTablesResponse;
7818
7819 #[inline]
7820 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7821 ::fidl_next::munge! {
7822 let Self {
7823 status,
7824
7825 } = &mut *out_;
7826 }
7827
7828 ::fidl_next::Wire::zero_padding(status);
7829 }
7830 }
7831
7832 unsafe impl<___D> ::fidl_next::Decode<___D> for DynamicDataSinkInitializePartitionTablesResponse
7833 where
7834 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7835 {
7836 fn decode(
7837 slot_: ::fidl_next::Slot<'_, Self>,
7838 decoder_: &mut ___D,
7839 _: (),
7840 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7841 ::fidl_next::munge! {
7842 let Self {
7843 mut status,
7844
7845 } = slot_;
7846 }
7847
7848 let _field = status.as_mut();
7849
7850 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7851
7852 Ok(())
7853 }
7854 }
7855
7856 impl ::fidl_next::IntoNatural for DynamicDataSinkInitializePartitionTablesResponse {
7857 type Natural = crate::natural::DynamicDataSinkInitializePartitionTablesResponse;
7858 }
7859
7860 #[derive(Clone, Debug)]
7862 #[repr(C)]
7863 pub struct DynamicDataSinkWipePartitionTablesResponse {
7864 pub status: ::fidl_next::wire::fuchsia::StatusResult,
7865 }
7866
7867 static_assertions::const_assert_eq!(
7868 std::mem::size_of::<DynamicDataSinkWipePartitionTablesResponse>(),
7869 4
7870 );
7871 static_assertions::const_assert_eq!(
7872 std::mem::align_of::<DynamicDataSinkWipePartitionTablesResponse>(),
7873 4
7874 );
7875
7876 static_assertions::const_assert_eq!(
7877 std::mem::offset_of!(DynamicDataSinkWipePartitionTablesResponse, status),
7878 0
7879 );
7880
7881 impl ::fidl_next::Constrained for DynamicDataSinkWipePartitionTablesResponse {
7882 type Constraint = ();
7883
7884 fn validate(
7885 _: ::fidl_next::Slot<'_, Self>,
7886 _: Self::Constraint,
7887 ) -> Result<(), ::fidl_next::ValidationError> {
7888 Ok(())
7889 }
7890 }
7891
7892 unsafe impl ::fidl_next::Wire for DynamicDataSinkWipePartitionTablesResponse {
7893 type Narrowed<'de> = DynamicDataSinkWipePartitionTablesResponse;
7894
7895 #[inline]
7896 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7897 ::fidl_next::munge! {
7898 let Self {
7899 status,
7900
7901 } = &mut *out_;
7902 }
7903
7904 ::fidl_next::Wire::zero_padding(status);
7905 }
7906 }
7907
7908 unsafe impl<___D> ::fidl_next::Decode<___D> for DynamicDataSinkWipePartitionTablesResponse
7909 where
7910 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7911 {
7912 fn decode(
7913 slot_: ::fidl_next::Slot<'_, Self>,
7914 decoder_: &mut ___D,
7915 _: (),
7916 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7917 ::fidl_next::munge! {
7918 let Self {
7919 mut status,
7920
7921 } = slot_;
7922 }
7923
7924 let _field = status.as_mut();
7925
7926 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
7927
7928 Ok(())
7929 }
7930 }
7931
7932 impl ::fidl_next::IntoNatural for DynamicDataSinkWipePartitionTablesResponse {
7933 type Natural = crate::natural::DynamicDataSinkWipePartitionTablesResponse;
7934 }
7935
7936 #[derive(Debug)]
7938 #[repr(C)]
7939 pub struct PartitionIoGetPartitionSizeRequest<'de> {
7940 pub partition: ::fidl_next::wire::String<'de>,
7941 }
7942
7943 static_assertions::const_assert_eq!(
7944 std::mem::size_of::<PartitionIoGetPartitionSizeRequest<'_>>(),
7945 16
7946 );
7947 static_assertions::const_assert_eq!(
7948 std::mem::align_of::<PartitionIoGetPartitionSizeRequest<'_>>(),
7949 8
7950 );
7951
7952 static_assertions::const_assert_eq!(
7953 std::mem::offset_of!(PartitionIoGetPartitionSizeRequest<'_>, partition),
7954 0
7955 );
7956
7957 impl ::fidl_next::Constrained for PartitionIoGetPartitionSizeRequest<'_> {
7958 type Constraint = ();
7959
7960 fn validate(
7961 _: ::fidl_next::Slot<'_, Self>,
7962 _: Self::Constraint,
7963 ) -> Result<(), ::fidl_next::ValidationError> {
7964 Ok(())
7965 }
7966 }
7967
7968 unsafe impl ::fidl_next::Wire for PartitionIoGetPartitionSizeRequest<'static> {
7969 type Narrowed<'de> = PartitionIoGetPartitionSizeRequest<'de>;
7970
7971 #[inline]
7972 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7973 ::fidl_next::munge! {
7974 let Self {
7975 partition,
7976
7977 } = &mut *out_;
7978 }
7979
7980 ::fidl_next::Wire::zero_padding(partition);
7981 }
7982 }
7983
7984 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PartitionIoGetPartitionSizeRequest<'de>
7985 where
7986 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7987 ___D: ::fidl_next::Decoder<'de>,
7988 {
7989 fn decode(
7990 slot_: ::fidl_next::Slot<'_, Self>,
7991 decoder_: &mut ___D,
7992 _: (),
7993 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7994 ::fidl_next::munge! {
7995 let Self {
7996 mut partition,
7997
7998 } = slot_;
7999 }
8000
8001 let _field = partition.as_mut();
8002 ::fidl_next::Constrained::validate(_field, 128)?;
8003 ::fidl_next::Decode::decode(partition.as_mut(), decoder_, 128)?;
8004
8005 let partition = unsafe { partition.deref_unchecked() };
8006
8007 if partition.len() > 128 {
8008 return Err(::fidl_next::DecodeError::VectorTooLong {
8009 size: partition.len() as u64,
8010 limit: 128,
8011 });
8012 }
8013
8014 Ok(())
8015 }
8016 }
8017
8018 impl<'de> ::fidl_next::IntoNatural for PartitionIoGetPartitionSizeRequest<'de> {
8019 type Natural = crate::natural::PartitionIoGetPartitionSizeRequest;
8020 }
8021
8022 #[derive(Clone, Debug)]
8024 #[repr(C)]
8025 pub struct PartitionIoGetPartitionSizeResponse {
8026 pub size: ::fidl_next::wire::Uint64,
8027 }
8028
8029 static_assertions::const_assert_eq!(
8030 std::mem::size_of::<PartitionIoGetPartitionSizeResponse>(),
8031 8
8032 );
8033 static_assertions::const_assert_eq!(
8034 std::mem::align_of::<PartitionIoGetPartitionSizeResponse>(),
8035 8
8036 );
8037
8038 static_assertions::const_assert_eq!(
8039 std::mem::offset_of!(PartitionIoGetPartitionSizeResponse, size),
8040 0
8041 );
8042
8043 impl ::fidl_next::Constrained for PartitionIoGetPartitionSizeResponse {
8044 type Constraint = ();
8045
8046 fn validate(
8047 _: ::fidl_next::Slot<'_, Self>,
8048 _: Self::Constraint,
8049 ) -> Result<(), ::fidl_next::ValidationError> {
8050 Ok(())
8051 }
8052 }
8053
8054 unsafe impl ::fidl_next::Wire for PartitionIoGetPartitionSizeResponse {
8055 type Narrowed<'de> = PartitionIoGetPartitionSizeResponse;
8056
8057 #[inline]
8058 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8059 ::fidl_next::munge! {
8060 let Self {
8061 size,
8062
8063 } = &mut *out_;
8064 }
8065
8066 ::fidl_next::Wire::zero_padding(size);
8067 }
8068 }
8069
8070 unsafe impl<___D> ::fidl_next::Decode<___D> for PartitionIoGetPartitionSizeResponse
8071 where
8072 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8073 {
8074 fn decode(
8075 slot_: ::fidl_next::Slot<'_, Self>,
8076 decoder_: &mut ___D,
8077 _: (),
8078 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8079 ::fidl_next::munge! {
8080 let Self {
8081 mut size,
8082
8083 } = slot_;
8084 }
8085
8086 let _field = size.as_mut();
8087
8088 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
8089
8090 Ok(())
8091 }
8092 }
8093
8094 impl ::fidl_next::IntoNatural for PartitionIoGetPartitionSizeResponse {
8095 type Natural = crate::natural::PartitionIoGetPartitionSizeResponse;
8096 }
8097
8098 #[derive(Debug)]
8100 #[repr(C)]
8101 pub struct PartitionIoReadPartitionRequest<'de> {
8102 pub partition: ::fidl_next::wire::String<'de>,
8103
8104 pub offset: ::fidl_next::wire::Uint64,
8105
8106 pub size: ::fidl_next::wire::Uint64,
8107 }
8108
8109 static_assertions::const_assert_eq!(
8110 std::mem::size_of::<PartitionIoReadPartitionRequest<'_>>(),
8111 32
8112 );
8113 static_assertions::const_assert_eq!(
8114 std::mem::align_of::<PartitionIoReadPartitionRequest<'_>>(),
8115 8
8116 );
8117
8118 static_assertions::const_assert_eq!(
8119 std::mem::offset_of!(PartitionIoReadPartitionRequest<'_>, partition),
8120 0
8121 );
8122
8123 static_assertions::const_assert_eq!(
8124 std::mem::offset_of!(PartitionIoReadPartitionRequest<'_>, offset),
8125 16
8126 );
8127
8128 static_assertions::const_assert_eq!(
8129 std::mem::offset_of!(PartitionIoReadPartitionRequest<'_>, size),
8130 24
8131 );
8132
8133 impl ::fidl_next::Constrained for PartitionIoReadPartitionRequest<'_> {
8134 type Constraint = ();
8135
8136 fn validate(
8137 _: ::fidl_next::Slot<'_, Self>,
8138 _: Self::Constraint,
8139 ) -> Result<(), ::fidl_next::ValidationError> {
8140 Ok(())
8141 }
8142 }
8143
8144 unsafe impl ::fidl_next::Wire for PartitionIoReadPartitionRequest<'static> {
8145 type Narrowed<'de> = PartitionIoReadPartitionRequest<'de>;
8146
8147 #[inline]
8148 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8149 ::fidl_next::munge! {
8150 let Self {
8151 partition,
8152 offset,
8153 size,
8154
8155 } = &mut *out_;
8156 }
8157
8158 ::fidl_next::Wire::zero_padding(partition);
8159
8160 ::fidl_next::Wire::zero_padding(offset);
8161
8162 ::fidl_next::Wire::zero_padding(size);
8163 }
8164 }
8165
8166 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PartitionIoReadPartitionRequest<'de>
8167 where
8168 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8169 ___D: ::fidl_next::Decoder<'de>,
8170 {
8171 fn decode(
8172 slot_: ::fidl_next::Slot<'_, Self>,
8173 decoder_: &mut ___D,
8174 _: (),
8175 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8176 ::fidl_next::munge! {
8177 let Self {
8178 mut partition,
8179 mut offset,
8180 mut size,
8181
8182 } = slot_;
8183 }
8184
8185 let _field = partition.as_mut();
8186 ::fidl_next::Constrained::validate(_field, 128)?;
8187 ::fidl_next::Decode::decode(partition.as_mut(), decoder_, 128)?;
8188
8189 let partition = unsafe { partition.deref_unchecked() };
8190
8191 if partition.len() > 128 {
8192 return Err(::fidl_next::DecodeError::VectorTooLong {
8193 size: partition.len() as u64,
8194 limit: 128,
8195 });
8196 }
8197
8198 let _field = offset.as_mut();
8199
8200 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
8201
8202 let _field = size.as_mut();
8203
8204 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
8205
8206 Ok(())
8207 }
8208 }
8209
8210 impl<'de> ::fidl_next::IntoNatural for PartitionIoReadPartitionRequest<'de> {
8211 type Natural = crate::natural::PartitionIoReadPartitionRequest;
8212 }
8213
8214 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8216 #[repr(transparent)]
8217 pub struct TrailingBehavior {
8218 pub(crate) value: ::fidl_next::wire::Uint32,
8219 }
8220
8221 impl ::fidl_next::Constrained for TrailingBehavior {
8222 type Constraint = ();
8223
8224 fn validate(
8225 _: ::fidl_next::Slot<'_, Self>,
8226 _: Self::Constraint,
8227 ) -> Result<(), ::fidl_next::ValidationError> {
8228 Ok(())
8229 }
8230 }
8231
8232 unsafe impl ::fidl_next::Wire for TrailingBehavior {
8233 type Narrowed<'de> = Self;
8234
8235 #[inline]
8236 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8237 }
8239 }
8240
8241 impl TrailingBehavior {
8242 pub const RETAIN: TrailingBehavior =
8243 TrailingBehavior { value: ::fidl_next::wire::Uint32(1) };
8244
8245 pub const DISCARD: TrailingBehavior =
8246 TrailingBehavior { value: ::fidl_next::wire::Uint32(2) };
8247 }
8248
8249 unsafe impl<___D> ::fidl_next::Decode<___D> for TrailingBehavior
8250 where
8251 ___D: ?Sized,
8252 {
8253 fn decode(
8254 slot: ::fidl_next::Slot<'_, Self>,
8255 _: &mut ___D,
8256 _: (),
8257 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8258 Ok(())
8259 }
8260 }
8261
8262 impl ::core::convert::From<crate::natural::TrailingBehavior> for TrailingBehavior {
8263 fn from(natural: crate::natural::TrailingBehavior) -> Self {
8264 match natural {
8265 crate::natural::TrailingBehavior::Retain => TrailingBehavior::RETAIN,
8266
8267 crate::natural::TrailingBehavior::Discard => TrailingBehavior::DISCARD,
8268
8269 crate::natural::TrailingBehavior::UnknownOrdinal_(value) => {
8270 TrailingBehavior { value: ::fidl_next::wire::Uint32::from(value) }
8271 }
8272 }
8273 }
8274 }
8275
8276 impl ::fidl_next::IntoNatural for TrailingBehavior {
8277 type Natural = crate::natural::TrailingBehavior;
8278 }
8279
8280 pub type PartitionIoWritePartitionResponse = ::fidl_next::wire::Unit;
8282
8283 pub type PartitionIoFlushResponse = ::fidl_next::wire::Unit;
8285
8286 #[derive(Clone, Debug)]
8288 #[repr(C)]
8289 pub struct ReadInfo {
8290 pub offset: ::fidl_next::wire::Uint64,
8291
8292 pub size: ::fidl_next::wire::Uint64,
8293 }
8294
8295 static_assertions::const_assert_eq!(std::mem::size_of::<ReadInfo>(), 16);
8296 static_assertions::const_assert_eq!(std::mem::align_of::<ReadInfo>(), 8);
8297
8298 static_assertions::const_assert_eq!(std::mem::offset_of!(ReadInfo, offset), 0);
8299
8300 static_assertions::const_assert_eq!(std::mem::offset_of!(ReadInfo, size), 8);
8301
8302 impl ::fidl_next::Constrained for ReadInfo {
8303 type Constraint = ();
8304
8305 fn validate(
8306 _: ::fidl_next::Slot<'_, Self>,
8307 _: Self::Constraint,
8308 ) -> Result<(), ::fidl_next::ValidationError> {
8309 Ok(())
8310 }
8311 }
8312
8313 unsafe impl ::fidl_next::Wire for ReadInfo {
8314 type Narrowed<'de> = ReadInfo;
8315
8316 #[inline]
8317 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8318 ::fidl_next::munge! {
8319 let Self {
8320 offset,
8321 size,
8322
8323 } = &mut *out_;
8324 }
8325
8326 ::fidl_next::Wire::zero_padding(offset);
8327
8328 ::fidl_next::Wire::zero_padding(size);
8329 }
8330 }
8331
8332 unsafe impl<___D> ::fidl_next::Decode<___D> for ReadInfo
8333 where
8334 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8335 {
8336 fn decode(
8337 slot_: ::fidl_next::Slot<'_, Self>,
8338 decoder_: &mut ___D,
8339 _: (),
8340 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8341 ::fidl_next::munge! {
8342 let Self {
8343 mut offset,
8344 mut size,
8345
8346 } = slot_;
8347 }
8348
8349 let _field = offset.as_mut();
8350
8351 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
8352
8353 let _field = size.as_mut();
8354
8355 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
8356
8357 Ok(())
8358 }
8359 }
8360
8361 impl ::fidl_next::IntoNatural for ReadInfo {
8362 type Natural = crate::natural::ReadInfo;
8363 }
8364
8365 #[repr(transparent)]
8367 pub struct ReadResult<'de> {
8368 pub(crate) raw: ::fidl_next::wire::Union,
8369 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8370 }
8371
8372 impl<'de> Drop for ReadResult<'de> {
8373 fn drop(&mut self) {
8374 match self.raw.ordinal() {
8375 1 => {
8376 let _ = unsafe {
8377 self.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
8378 };
8379 }
8380
8381 2 => {
8382 let _ = unsafe { self.raw.get().read_unchecked::<bool>() };
8383 }
8384
8385 3 => {
8386 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::ReadInfo>() };
8387 }
8388
8389 _ => unsafe { ::core::hint::unreachable_unchecked() },
8390 }
8391 }
8392 }
8393
8394 impl ::fidl_next::Constrained for ReadResult<'_> {
8395 type Constraint = ();
8396
8397 fn validate(
8398 _: ::fidl_next::Slot<'_, Self>,
8399 _: Self::Constraint,
8400 ) -> Result<(), ::fidl_next::ValidationError> {
8401 Ok(())
8402 }
8403 }
8404
8405 unsafe impl ::fidl_next::Wire for ReadResult<'static> {
8406 type Narrowed<'de> = ReadResult<'de>;
8407
8408 #[inline]
8409 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8410 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8411 ::fidl_next::wire::Union::zero_padding(raw);
8412 }
8413 }
8414
8415 pub mod read_result {
8416 pub enum Ref<'de> {
8417 Err(&'de ::fidl_next::wire::fuchsia::StatusResult),
8418
8419 Eof(&'de bool),
8420
8421 Info(&'de crate::wire::ReadInfo),
8422 }
8423
8424 pub enum Value {
8425 Err(::fidl_next::wire::fuchsia::StatusResult),
8426
8427 Eof(bool),
8428
8429 Info(crate::wire::ReadInfo),
8430 }
8431 }
8432
8433 impl<'de> ReadResult<'de> {
8434 pub fn as_ref(&self) -> crate::wire::read_result::Ref<'_> {
8435 match self.raw.ordinal() {
8436 1 => crate::wire::read_result::Ref::Err(unsafe {
8437 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
8438 }),
8439
8440 2 => crate::wire::read_result::Ref::Eof(unsafe {
8441 self.raw.get().deref_unchecked::<bool>()
8442 }),
8443
8444 3 => crate::wire::read_result::Ref::Info(unsafe {
8445 self.raw.get().deref_unchecked::<crate::wire::ReadInfo>()
8446 }),
8447
8448 _ => unsafe { ::core::hint::unreachable_unchecked() },
8449 }
8450 }
8451
8452 pub fn into_inner(self) -> crate::wire::read_result::Value {
8453 let this = ::core::mem::ManuallyDrop::new(self);
8454
8455 match this.raw.ordinal() {
8456 1 => crate::wire::read_result::Value::Err(unsafe {
8457 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
8458 }),
8459
8460 2 => crate::wire::read_result::Value::Eof(unsafe {
8461 this.raw.get().read_unchecked::<bool>()
8462 }),
8463
8464 3 => crate::wire::read_result::Value::Info(unsafe {
8465 this.raw.get().read_unchecked::<crate::wire::ReadInfo>()
8466 }),
8467
8468 _ => unsafe { ::core::hint::unreachable_unchecked() },
8469 }
8470 }
8471 }
8472
8473 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ReadResult<'de>
8474 where
8475 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8476 ___D: ::fidl_next::Decoder<'de>,
8477 {
8478 fn decode(
8479 mut slot: ::fidl_next::Slot<'_, Self>,
8480 decoder: &mut ___D,
8481 _: (),
8482 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8483 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8484 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8485 1 => ::fidl_next::wire::Union::decode_as::<
8486 ___D,
8487 ::fidl_next::wire::fuchsia::StatusResult,
8488 >(raw, decoder, ())?,
8489
8490 2 => ::fidl_next::wire::Union::decode_as::<___D, bool>(raw, decoder, ())?,
8491
8492 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ReadInfo>(
8493 raw,
8494 decoder,
8495 (),
8496 )?,
8497
8498 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
8499 }
8500
8501 Ok(())
8502 }
8503 }
8504
8505 impl<'de> ::core::fmt::Debug for ReadResult<'de> {
8506 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8507 match self.raw.ordinal() {
8508 1 => unsafe {
8509 self.raw
8510 .get()
8511 .deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
8512 .fmt(f)
8513 },
8514 2 => unsafe { self.raw.get().deref_unchecked::<bool>().fmt(f) },
8515 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::ReadInfo>().fmt(f) },
8516 _ => unsafe { ::core::hint::unreachable_unchecked() },
8517 }
8518 }
8519 }
8520
8521 impl<'de> ::fidl_next::IntoNatural for ReadResult<'de> {
8522 type Natural = crate::natural::ReadResult;
8523 }
8524
8525 #[derive(Clone, Debug)]
8527 #[repr(C)]
8528 pub struct SysconfigWriteResponse {
8529 pub status: ::fidl_next::wire::fuchsia::StatusResult,
8530 }
8531
8532 static_assertions::const_assert_eq!(std::mem::size_of::<SysconfigWriteResponse>(), 4);
8533 static_assertions::const_assert_eq!(std::mem::align_of::<SysconfigWriteResponse>(), 4);
8534
8535 static_assertions::const_assert_eq!(std::mem::offset_of!(SysconfigWriteResponse, status), 0);
8536
8537 impl ::fidl_next::Constrained for SysconfigWriteResponse {
8538 type Constraint = ();
8539
8540 fn validate(
8541 _: ::fidl_next::Slot<'_, Self>,
8542 _: Self::Constraint,
8543 ) -> Result<(), ::fidl_next::ValidationError> {
8544 Ok(())
8545 }
8546 }
8547
8548 unsafe impl ::fidl_next::Wire for SysconfigWriteResponse {
8549 type Narrowed<'de> = SysconfigWriteResponse;
8550
8551 #[inline]
8552 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8553 ::fidl_next::munge! {
8554 let Self {
8555 status,
8556
8557 } = &mut *out_;
8558 }
8559
8560 ::fidl_next::Wire::zero_padding(status);
8561 }
8562 }
8563
8564 unsafe impl<___D> ::fidl_next::Decode<___D> for SysconfigWriteResponse
8565 where
8566 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8567 {
8568 fn decode(
8569 slot_: ::fidl_next::Slot<'_, Self>,
8570 decoder_: &mut ___D,
8571 _: (),
8572 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8573 ::fidl_next::munge! {
8574 let Self {
8575 mut status,
8576
8577 } = slot_;
8578 }
8579
8580 let _field = status.as_mut();
8581
8582 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
8583
8584 Ok(())
8585 }
8586 }
8587
8588 impl ::fidl_next::IntoNatural for SysconfigWriteResponse {
8589 type Natural = crate::natural::SysconfigWriteResponse;
8590 }
8591
8592 #[derive(Clone, Debug)]
8594 #[repr(C)]
8595 pub struct SysconfigGetPartitionSizeResponse {
8596 pub size: ::fidl_next::wire::Uint64,
8597 }
8598
8599 static_assertions::const_assert_eq!(
8600 std::mem::size_of::<SysconfigGetPartitionSizeResponse>(),
8601 8
8602 );
8603 static_assertions::const_assert_eq!(
8604 std::mem::align_of::<SysconfigGetPartitionSizeResponse>(),
8605 8
8606 );
8607
8608 static_assertions::const_assert_eq!(
8609 std::mem::offset_of!(SysconfigGetPartitionSizeResponse, size),
8610 0
8611 );
8612
8613 impl ::fidl_next::Constrained for SysconfigGetPartitionSizeResponse {
8614 type Constraint = ();
8615
8616 fn validate(
8617 _: ::fidl_next::Slot<'_, Self>,
8618 _: Self::Constraint,
8619 ) -> Result<(), ::fidl_next::ValidationError> {
8620 Ok(())
8621 }
8622 }
8623
8624 unsafe impl ::fidl_next::Wire for SysconfigGetPartitionSizeResponse {
8625 type Narrowed<'de> = SysconfigGetPartitionSizeResponse;
8626
8627 #[inline]
8628 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8629 ::fidl_next::munge! {
8630 let Self {
8631 size,
8632
8633 } = &mut *out_;
8634 }
8635
8636 ::fidl_next::Wire::zero_padding(size);
8637 }
8638 }
8639
8640 unsafe impl<___D> ::fidl_next::Decode<___D> for SysconfigGetPartitionSizeResponse
8641 where
8642 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8643 {
8644 fn decode(
8645 slot_: ::fidl_next::Slot<'_, Self>,
8646 decoder_: &mut ___D,
8647 _: (),
8648 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8649 ::fidl_next::munge! {
8650 let Self {
8651 mut size,
8652
8653 } = slot_;
8654 }
8655
8656 let _field = size.as_mut();
8657
8658 ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;
8659
8660 Ok(())
8661 }
8662 }
8663
8664 impl ::fidl_next::IntoNatural for SysconfigGetPartitionSizeResponse {
8665 type Natural = crate::natural::SysconfigGetPartitionSizeResponse;
8666 }
8667
8668 #[derive(Clone, Debug)]
8670 #[repr(C)]
8671 pub struct SysconfigFlushResponse {
8672 pub status: ::fidl_next::wire::fuchsia::StatusResult,
8673 }
8674
8675 static_assertions::const_assert_eq!(std::mem::size_of::<SysconfigFlushResponse>(), 4);
8676 static_assertions::const_assert_eq!(std::mem::align_of::<SysconfigFlushResponse>(), 4);
8677
8678 static_assertions::const_assert_eq!(std::mem::offset_of!(SysconfigFlushResponse, status), 0);
8679
8680 impl ::fidl_next::Constrained for SysconfigFlushResponse {
8681 type Constraint = ();
8682
8683 fn validate(
8684 _: ::fidl_next::Slot<'_, Self>,
8685 _: Self::Constraint,
8686 ) -> Result<(), ::fidl_next::ValidationError> {
8687 Ok(())
8688 }
8689 }
8690
8691 unsafe impl ::fidl_next::Wire for SysconfigFlushResponse {
8692 type Narrowed<'de> = SysconfigFlushResponse;
8693
8694 #[inline]
8695 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8696 ::fidl_next::munge! {
8697 let Self {
8698 status,
8699
8700 } = &mut *out_;
8701 }
8702
8703 ::fidl_next::Wire::zero_padding(status);
8704 }
8705 }
8706
8707 unsafe impl<___D> ::fidl_next::Decode<___D> for SysconfigFlushResponse
8708 where
8709 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8710 {
8711 fn decode(
8712 slot_: ::fidl_next::Slot<'_, Self>,
8713 decoder_: &mut ___D,
8714 _: (),
8715 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8716 ::fidl_next::munge! {
8717 let Self {
8718 mut status,
8719
8720 } = slot_;
8721 }
8722
8723 let _field = status.as_mut();
8724
8725 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
8726
8727 Ok(())
8728 }
8729 }
8730
8731 impl ::fidl_next::IntoNatural for SysconfigFlushResponse {
8732 type Natural = crate::natural::SysconfigFlushResponse;
8733 }
8734
8735 #[derive(Clone, Debug)]
8737 #[repr(C)]
8738 pub struct SysconfigWipeResponse {
8739 pub status: ::fidl_next::wire::fuchsia::StatusResult,
8740 }
8741
8742 static_assertions::const_assert_eq!(std::mem::size_of::<SysconfigWipeResponse>(), 4);
8743 static_assertions::const_assert_eq!(std::mem::align_of::<SysconfigWipeResponse>(), 4);
8744
8745 static_assertions::const_assert_eq!(std::mem::offset_of!(SysconfigWipeResponse, status), 0);
8746
8747 impl ::fidl_next::Constrained for SysconfigWipeResponse {
8748 type Constraint = ();
8749
8750 fn validate(
8751 _: ::fidl_next::Slot<'_, Self>,
8752 _: Self::Constraint,
8753 ) -> Result<(), ::fidl_next::ValidationError> {
8754 Ok(())
8755 }
8756 }
8757
8758 unsafe impl ::fidl_next::Wire for SysconfigWipeResponse {
8759 type Narrowed<'de> = SysconfigWipeResponse;
8760
8761 #[inline]
8762 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8763 ::fidl_next::munge! {
8764 let Self {
8765 status,
8766
8767 } = &mut *out_;
8768 }
8769
8770 ::fidl_next::Wire::zero_padding(status);
8771 }
8772 }
8773
8774 unsafe impl<___D> ::fidl_next::Decode<___D> for SysconfigWipeResponse
8775 where
8776 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8777 {
8778 fn decode(
8779 slot_: ::fidl_next::Slot<'_, Self>,
8780 decoder_: &mut ___D,
8781 _: (),
8782 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8783 ::fidl_next::munge! {
8784 let Self {
8785 mut status,
8786
8787 } = slot_;
8788 }
8789
8790 let _field = status.as_mut();
8791
8792 ::fidl_next::Decode::decode(status.as_mut(), decoder_, ())?;
8793
8794 Ok(())
8795 }
8796 }
8797
8798 impl ::fidl_next::IntoNatural for SysconfigWipeResponse {
8799 type Natural = crate::natural::SysconfigWipeResponse;
8800 }
8801}
8802
8803pub mod wire_optional {
8804
8805 #[repr(transparent)]
8806 pub struct WriteFirmwareResult {
8807 pub(crate) raw: ::fidl_next::wire::Union,
8808 pub(crate) _phantom: ::core::marker::PhantomData<()>,
8809 }
8810
8811 impl ::fidl_next::Constrained for WriteFirmwareResult {
8812 type Constraint = ();
8813
8814 fn validate(
8815 _: ::fidl_next::Slot<'_, Self>,
8816 _: Self::Constraint,
8817 ) -> Result<(), ::fidl_next::ValidationError> {
8818 Ok(())
8819 }
8820 }
8821
8822 unsafe impl ::fidl_next::Wire for WriteFirmwareResult {
8823 type Narrowed<'de> = WriteFirmwareResult;
8824
8825 #[inline]
8826 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8827 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8828 ::fidl_next::wire::Union::zero_padding(raw);
8829 }
8830 }
8831
8832 impl WriteFirmwareResult {
8833 pub fn is_some(&self) -> bool {
8834 self.raw.is_some()
8835 }
8836
8837 pub fn is_none(&self) -> bool {
8838 self.raw.is_none()
8839 }
8840
8841 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::WriteFirmwareResult> {
8842 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
8843 }
8844
8845 pub fn into_option(self) -> ::core::option::Option<crate::wire::WriteFirmwareResult> {
8846 if self.is_some() {
8847 Some(crate::wire::WriteFirmwareResult {
8848 raw: self.raw,
8849 _phantom: ::core::marker::PhantomData,
8850 })
8851 } else {
8852 None
8853 }
8854 }
8855 }
8856
8857 impl Clone for WriteFirmwareResult {
8858 fn clone(&self) -> Self {
8859 if self.is_none() {
8860 return WriteFirmwareResult {
8861 raw: ::fidl_next::wire::Union::absent(),
8862 _phantom: ::core::marker::PhantomData,
8863 };
8864 }
8865
8866 match self.raw.ordinal() {
8867 1 => Self {
8868 raw: unsafe {
8869 self.raw
8870 .clone_inline_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
8871 },
8872 _phantom: ::core::marker::PhantomData,
8873 },
8874
8875 2 => Self {
8876 raw: unsafe { self.raw.clone_inline_unchecked::<bool>() },
8877 _phantom: ::core::marker::PhantomData,
8878 },
8879
8880 _ => unsafe { ::core::hint::unreachable_unchecked() },
8881 }
8882 }
8883 }
8884
8885 unsafe impl<___D> ::fidl_next::Decode<___D> for WriteFirmwareResult
8886 where
8887 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8888 {
8889 fn decode(
8890 mut slot: ::fidl_next::Slot<'_, Self>,
8891 decoder: &mut ___D,
8892 _: (),
8893 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8894 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8895 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8896 1 => ::fidl_next::wire::Union::decode_as_static::<
8897 ___D,
8898 ::fidl_next::wire::fuchsia::StatusResult,
8899 >(raw, decoder, ())?,
8900
8901 2 => ::fidl_next::wire::Union::decode_as_static::<___D, bool>(raw, decoder, ())?,
8902
8903 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
8904 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
8905 }
8906
8907 Ok(())
8908 }
8909 }
8910
8911 impl ::core::fmt::Debug for WriteFirmwareResult {
8912 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8913 self.as_ref().fmt(f)
8914 }
8915 }
8916
8917 impl ::fidl_next::IntoNatural for WriteFirmwareResult {
8918 type Natural = ::core::option::Option<crate::natural::WriteFirmwareResult>;
8919 }
8920
8921 #[repr(transparent)]
8922 pub struct ReadResult<'de> {
8923 pub(crate) raw: ::fidl_next::wire::Union,
8924 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8925 }
8926
8927 impl ::fidl_next::Constrained for ReadResult<'_> {
8928 type Constraint = ();
8929
8930 fn validate(
8931 _: ::fidl_next::Slot<'_, Self>,
8932 _: Self::Constraint,
8933 ) -> Result<(), ::fidl_next::ValidationError> {
8934 Ok(())
8935 }
8936 }
8937
8938 unsafe impl ::fidl_next::Wire for ReadResult<'static> {
8939 type Narrowed<'de> = ReadResult<'de>;
8940
8941 #[inline]
8942 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8943 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8944 ::fidl_next::wire::Union::zero_padding(raw);
8945 }
8946 }
8947
8948 impl<'de> ReadResult<'de> {
8949 pub fn is_some(&self) -> bool {
8950 self.raw.is_some()
8951 }
8952
8953 pub fn is_none(&self) -> bool {
8954 self.raw.is_none()
8955 }
8956
8957 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ReadResult<'de>> {
8958 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
8959 }
8960
8961 pub fn into_option(self) -> ::core::option::Option<crate::wire::ReadResult<'de>> {
8962 if self.is_some() {
8963 Some(crate::wire::ReadResult {
8964 raw: self.raw,
8965 _phantom: ::core::marker::PhantomData,
8966 })
8967 } else {
8968 None
8969 }
8970 }
8971 }
8972
8973 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ReadResult<'de>
8974 where
8975 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8976 ___D: ::fidl_next::Decoder<'de>,
8977 {
8978 fn decode(
8979 mut slot: ::fidl_next::Slot<'_, Self>,
8980 decoder: &mut ___D,
8981 _: (),
8982 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8983 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8984 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8985 1 => ::fidl_next::wire::Union::decode_as::<
8986 ___D,
8987 ::fidl_next::wire::fuchsia::StatusResult,
8988 >(raw, decoder, ())?,
8989
8990 2 => ::fidl_next::wire::Union::decode_as::<___D, bool>(raw, decoder, ())?,
8991
8992 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ReadInfo>(
8993 raw,
8994 decoder,
8995 (),
8996 )?,
8997
8998 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
8999 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
9000 }
9001
9002 Ok(())
9003 }
9004 }
9005
9006 impl<'de> ::core::fmt::Debug for ReadResult<'de> {
9007 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9008 self.as_ref().fmt(f)
9009 }
9010 }
9011
9012 impl<'de> ::fidl_next::IntoNatural for ReadResult<'de> {
9013 type Natural = ::core::option::Option<crate::natural::ReadResult>;
9014 }
9015}
9016
9017pub mod generic {
9018
9019 pub struct BootManagerQueryCurrentConfigurationResponse<T0> {
9021 pub configuration: T0,
9022 }
9023
9024 unsafe impl<___E, T0>
9025 ::fidl_next::Encode<crate::wire::BootManagerQueryCurrentConfigurationResponse, ___E>
9026 for BootManagerQueryCurrentConfigurationResponse<T0>
9027 where
9028 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9029 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9030 {
9031 #[inline]
9032 fn encode(
9033 self,
9034 encoder_: &mut ___E,
9035 out_: &mut ::core::mem::MaybeUninit<
9036 crate::wire::BootManagerQueryCurrentConfigurationResponse,
9037 >,
9038 _: (),
9039 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9040 ::fidl_next::munge! {
9041 let crate::wire::BootManagerQueryCurrentConfigurationResponse {
9042 configuration,
9043
9044 } = out_;
9045 }
9046
9047 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9048
9049 Ok(())
9050 }
9051 }
9052
9053 unsafe impl<'a, ___E, T0>
9054 ::fidl_next::Encode<crate::wire::BootManagerQueryCurrentConfigurationResponse, ___E>
9055 for &'a BootManagerQueryCurrentConfigurationResponse<T0>
9056 where
9057 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9058 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9059 {
9060 #[inline]
9061 fn encode(
9062 self,
9063 encoder_: &mut ___E,
9064 out_: &mut ::core::mem::MaybeUninit<
9065 crate::wire::BootManagerQueryCurrentConfigurationResponse,
9066 >,
9067 _: (),
9068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9069 ::fidl_next::munge! {
9070 let crate::wire::BootManagerQueryCurrentConfigurationResponse {
9071 configuration,
9072
9073 } = out_;
9074 }
9075
9076 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9077
9078 Ok(())
9079 }
9080 }
9081
9082 pub struct BootManagerQueryActiveConfigurationResponse<T0> {
9084 pub configuration: T0,
9085 }
9086
9087 unsafe impl<___E, T0>
9088 ::fidl_next::Encode<crate::wire::BootManagerQueryActiveConfigurationResponse, ___E>
9089 for BootManagerQueryActiveConfigurationResponse<T0>
9090 where
9091 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9092 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9093 {
9094 #[inline]
9095 fn encode(
9096 self,
9097 encoder_: &mut ___E,
9098 out_: &mut ::core::mem::MaybeUninit<
9099 crate::wire::BootManagerQueryActiveConfigurationResponse,
9100 >,
9101 _: (),
9102 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9103 ::fidl_next::munge! {
9104 let crate::wire::BootManagerQueryActiveConfigurationResponse {
9105 configuration,
9106
9107 } = out_;
9108 }
9109
9110 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9111
9112 Ok(())
9113 }
9114 }
9115
9116 unsafe impl<'a, ___E, T0>
9117 ::fidl_next::Encode<crate::wire::BootManagerQueryActiveConfigurationResponse, ___E>
9118 for &'a BootManagerQueryActiveConfigurationResponse<T0>
9119 where
9120 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9121 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9122 {
9123 #[inline]
9124 fn encode(
9125 self,
9126 encoder_: &mut ___E,
9127 out_: &mut ::core::mem::MaybeUninit<
9128 crate::wire::BootManagerQueryActiveConfigurationResponse,
9129 >,
9130 _: (),
9131 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9132 ::fidl_next::munge! {
9133 let crate::wire::BootManagerQueryActiveConfigurationResponse {
9134 configuration,
9135
9136 } = out_;
9137 }
9138
9139 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9140
9141 Ok(())
9142 }
9143 }
9144
9145 pub struct BootManagerQueryConfigurationLastSetActiveResponse<T0> {
9147 pub configuration: T0,
9148 }
9149
9150 unsafe impl<___E, T0>
9151 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationLastSetActiveResponse, ___E>
9152 for BootManagerQueryConfigurationLastSetActiveResponse<T0>
9153 where
9154 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9155 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9156 {
9157 #[inline]
9158 fn encode(
9159 self,
9160 encoder_: &mut ___E,
9161 out_: &mut ::core::mem::MaybeUninit<
9162 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
9163 >,
9164 _: (),
9165 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9166 ::fidl_next::munge! {
9167 let crate::wire::BootManagerQueryConfigurationLastSetActiveResponse {
9168 configuration,
9169
9170 } = out_;
9171 }
9172
9173 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9174
9175 Ok(())
9176 }
9177 }
9178
9179 unsafe impl<'a, ___E, T0>
9180 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationLastSetActiveResponse, ___E>
9181 for &'a BootManagerQueryConfigurationLastSetActiveResponse<T0>
9182 where
9183 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9184 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9185 {
9186 #[inline]
9187 fn encode(
9188 self,
9189 encoder_: &mut ___E,
9190 out_: &mut ::core::mem::MaybeUninit<
9191 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
9192 >,
9193 _: (),
9194 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9195 ::fidl_next::munge! {
9196 let crate::wire::BootManagerQueryConfigurationLastSetActiveResponse {
9197 configuration,
9198
9199 } = out_;
9200 }
9201
9202 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9203
9204 Ok(())
9205 }
9206 }
9207
9208 pub struct BootManagerQueryConfigurationStatusRequest<T0> {
9210 pub configuration: T0,
9211 }
9212
9213 unsafe impl<___E, T0>
9214 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusRequest, ___E>
9215 for BootManagerQueryConfigurationStatusRequest<T0>
9216 where
9217 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9218 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9219 {
9220 #[inline]
9221 fn encode(
9222 self,
9223 encoder_: &mut ___E,
9224 out_: &mut ::core::mem::MaybeUninit<
9225 crate::wire::BootManagerQueryConfigurationStatusRequest,
9226 >,
9227 _: (),
9228 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9229 ::fidl_next::munge! {
9230 let crate::wire::BootManagerQueryConfigurationStatusRequest {
9231 configuration,
9232
9233 } = out_;
9234 }
9235
9236 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9237
9238 Ok(())
9239 }
9240 }
9241
9242 unsafe impl<'a, ___E, T0>
9243 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusRequest, ___E>
9244 for &'a BootManagerQueryConfigurationStatusRequest<T0>
9245 where
9246 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9247 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9248 {
9249 #[inline]
9250 fn encode(
9251 self,
9252 encoder_: &mut ___E,
9253 out_: &mut ::core::mem::MaybeUninit<
9254 crate::wire::BootManagerQueryConfigurationStatusRequest,
9255 >,
9256 _: (),
9257 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9258 ::fidl_next::munge! {
9259 let crate::wire::BootManagerQueryConfigurationStatusRequest {
9260 configuration,
9261
9262 } = out_;
9263 }
9264
9265 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9266
9267 Ok(())
9268 }
9269 }
9270
9271 pub struct BootManagerQueryConfigurationStatusResponse<T0> {
9273 pub status: T0,
9274 }
9275
9276 unsafe impl<___E, T0>
9277 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusResponse, ___E>
9278 for BootManagerQueryConfigurationStatusResponse<T0>
9279 where
9280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9281 T0: ::fidl_next::Encode<crate::wire::ConfigurationStatus, ___E>,
9282 {
9283 #[inline]
9284 fn encode(
9285 self,
9286 encoder_: &mut ___E,
9287 out_: &mut ::core::mem::MaybeUninit<
9288 crate::wire::BootManagerQueryConfigurationStatusResponse,
9289 >,
9290 _: (),
9291 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9292 ::fidl_next::munge! {
9293 let crate::wire::BootManagerQueryConfigurationStatusResponse {
9294 status,
9295
9296 } = out_;
9297 }
9298
9299 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
9300
9301 Ok(())
9302 }
9303 }
9304
9305 unsafe impl<'a, ___E, T0>
9306 ::fidl_next::Encode<crate::wire::BootManagerQueryConfigurationStatusResponse, ___E>
9307 for &'a BootManagerQueryConfigurationStatusResponse<T0>
9308 where
9309 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9310 &'a T0: ::fidl_next::Encode<crate::wire::ConfigurationStatus, ___E>,
9311 {
9312 #[inline]
9313 fn encode(
9314 self,
9315 encoder_: &mut ___E,
9316 out_: &mut ::core::mem::MaybeUninit<
9317 crate::wire::BootManagerQueryConfigurationStatusResponse,
9318 >,
9319 _: (),
9320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9321 ::fidl_next::munge! {
9322 let crate::wire::BootManagerQueryConfigurationStatusResponse {
9323 status,
9324
9325 } = out_;
9326 }
9327
9328 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
9329
9330 Ok(())
9331 }
9332 }
9333
9334 pub struct BootManagerQueryConfigurationStatusAndBootAttemptsRequest<T0> {
9336 pub configuration: T0,
9337 }
9338
9339 unsafe impl<___E, T0>
9340 ::fidl_next::Encode<
9341 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
9342 ___E,
9343 > for BootManagerQueryConfigurationStatusAndBootAttemptsRequest<T0>
9344 where
9345 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9346 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9347 {
9348 #[inline]
9349 fn encode(
9350 self,
9351 encoder_: &mut ___E,
9352 out_: &mut ::core::mem::MaybeUninit<
9353 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
9354 >,
9355 _: (),
9356 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9357 ::fidl_next::munge! {
9358 let crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
9359 configuration,
9360
9361 } = out_;
9362 }
9363
9364 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9365
9366 Ok(())
9367 }
9368 }
9369
9370 unsafe impl<'a, ___E, T0>
9371 ::fidl_next::Encode<
9372 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
9373 ___E,
9374 > for &'a BootManagerQueryConfigurationStatusAndBootAttemptsRequest<T0>
9375 where
9376 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9377 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9378 {
9379 #[inline]
9380 fn encode(
9381 self,
9382 encoder_: &mut ___E,
9383 out_: &mut ::core::mem::MaybeUninit<
9384 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
9385 >,
9386 _: (),
9387 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9388 ::fidl_next::munge! {
9389 let crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
9390 configuration,
9391
9392 } = out_;
9393 }
9394
9395 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9396
9397 Ok(())
9398 }
9399 }
9400
9401 pub struct BootManagerSetConfigurationActiveRequest<T0> {
9403 pub configuration: T0,
9404 }
9405
9406 unsafe impl<___E, T0>
9407 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveRequest, ___E>
9408 for BootManagerSetConfigurationActiveRequest<T0>
9409 where
9410 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9411 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9412 {
9413 #[inline]
9414 fn encode(
9415 self,
9416 encoder_: &mut ___E,
9417 out_: &mut ::core::mem::MaybeUninit<
9418 crate::wire::BootManagerSetConfigurationActiveRequest,
9419 >,
9420 _: (),
9421 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9422 ::fidl_next::munge! {
9423 let crate::wire::BootManagerSetConfigurationActiveRequest {
9424 configuration,
9425
9426 } = out_;
9427 }
9428
9429 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9430
9431 Ok(())
9432 }
9433 }
9434
9435 unsafe impl<'a, ___E, T0>
9436 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveRequest, ___E>
9437 for &'a BootManagerSetConfigurationActiveRequest<T0>
9438 where
9439 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9440 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9441 {
9442 #[inline]
9443 fn encode(
9444 self,
9445 encoder_: &mut ___E,
9446 out_: &mut ::core::mem::MaybeUninit<
9447 crate::wire::BootManagerSetConfigurationActiveRequest,
9448 >,
9449 _: (),
9450 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9451 ::fidl_next::munge! {
9452 let crate::wire::BootManagerSetConfigurationActiveRequest {
9453 configuration,
9454
9455 } = out_;
9456 }
9457
9458 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9459
9460 Ok(())
9461 }
9462 }
9463
9464 pub struct BootManagerSetConfigurationActiveResponse<T0> {
9466 pub status: T0,
9467 }
9468
9469 unsafe impl<___E, T0>
9470 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveResponse, ___E>
9471 for BootManagerSetConfigurationActiveResponse<T0>
9472 where
9473 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9474 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9475 {
9476 #[inline]
9477 fn encode(
9478 self,
9479 encoder_: &mut ___E,
9480 out_: &mut ::core::mem::MaybeUninit<
9481 crate::wire::BootManagerSetConfigurationActiveResponse,
9482 >,
9483 _: (),
9484 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9485 ::fidl_next::munge! {
9486 let crate::wire::BootManagerSetConfigurationActiveResponse {
9487 status,
9488
9489 } = out_;
9490 }
9491
9492 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
9493
9494 Ok(())
9495 }
9496 }
9497
9498 unsafe impl<'a, ___E, T0>
9499 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationActiveResponse, ___E>
9500 for &'a BootManagerSetConfigurationActiveResponse<T0>
9501 where
9502 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9503 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9504 {
9505 #[inline]
9506 fn encode(
9507 self,
9508 encoder_: &mut ___E,
9509 out_: &mut ::core::mem::MaybeUninit<
9510 crate::wire::BootManagerSetConfigurationActiveResponse,
9511 >,
9512 _: (),
9513 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9514 ::fidl_next::munge! {
9515 let crate::wire::BootManagerSetConfigurationActiveResponse {
9516 status,
9517
9518 } = out_;
9519 }
9520
9521 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
9522
9523 Ok(())
9524 }
9525 }
9526
9527 pub struct BootManagerSetConfigurationUnbootableRequest<T0> {
9529 pub configuration: T0,
9530 }
9531
9532 unsafe impl<___E, T0>
9533 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableRequest, ___E>
9534 for BootManagerSetConfigurationUnbootableRequest<T0>
9535 where
9536 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9537 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9538 {
9539 #[inline]
9540 fn encode(
9541 self,
9542 encoder_: &mut ___E,
9543 out_: &mut ::core::mem::MaybeUninit<
9544 crate::wire::BootManagerSetConfigurationUnbootableRequest,
9545 >,
9546 _: (),
9547 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9548 ::fidl_next::munge! {
9549 let crate::wire::BootManagerSetConfigurationUnbootableRequest {
9550 configuration,
9551
9552 } = out_;
9553 }
9554
9555 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9556
9557 Ok(())
9558 }
9559 }
9560
9561 unsafe impl<'a, ___E, T0>
9562 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableRequest, ___E>
9563 for &'a BootManagerSetConfigurationUnbootableRequest<T0>
9564 where
9565 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9566 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9567 {
9568 #[inline]
9569 fn encode(
9570 self,
9571 encoder_: &mut ___E,
9572 out_: &mut ::core::mem::MaybeUninit<
9573 crate::wire::BootManagerSetConfigurationUnbootableRequest,
9574 >,
9575 _: (),
9576 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9577 ::fidl_next::munge! {
9578 let crate::wire::BootManagerSetConfigurationUnbootableRequest {
9579 configuration,
9580
9581 } = out_;
9582 }
9583
9584 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9585
9586 Ok(())
9587 }
9588 }
9589
9590 pub struct BootManagerSetConfigurationUnbootableResponse<T0> {
9592 pub status: T0,
9593 }
9594
9595 unsafe impl<___E, T0>
9596 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableResponse, ___E>
9597 for BootManagerSetConfigurationUnbootableResponse<T0>
9598 where
9599 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9600 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9601 {
9602 #[inline]
9603 fn encode(
9604 self,
9605 encoder_: &mut ___E,
9606 out_: &mut ::core::mem::MaybeUninit<
9607 crate::wire::BootManagerSetConfigurationUnbootableResponse,
9608 >,
9609 _: (),
9610 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9611 ::fidl_next::munge! {
9612 let crate::wire::BootManagerSetConfigurationUnbootableResponse {
9613 status,
9614
9615 } = out_;
9616 }
9617
9618 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
9619
9620 Ok(())
9621 }
9622 }
9623
9624 unsafe impl<'a, ___E, T0>
9625 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationUnbootableResponse, ___E>
9626 for &'a BootManagerSetConfigurationUnbootableResponse<T0>
9627 where
9628 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9629 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9630 {
9631 #[inline]
9632 fn encode(
9633 self,
9634 encoder_: &mut ___E,
9635 out_: &mut ::core::mem::MaybeUninit<
9636 crate::wire::BootManagerSetConfigurationUnbootableResponse,
9637 >,
9638 _: (),
9639 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9640 ::fidl_next::munge! {
9641 let crate::wire::BootManagerSetConfigurationUnbootableResponse {
9642 status,
9643
9644 } = out_;
9645 }
9646
9647 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
9648
9649 Ok(())
9650 }
9651 }
9652
9653 pub struct BootManagerSetConfigurationHealthyRequest<T0> {
9655 pub configuration: T0,
9656 }
9657
9658 unsafe impl<___E, T0>
9659 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyRequest, ___E>
9660 for BootManagerSetConfigurationHealthyRequest<T0>
9661 where
9662 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9663 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9664 {
9665 #[inline]
9666 fn encode(
9667 self,
9668 encoder_: &mut ___E,
9669 out_: &mut ::core::mem::MaybeUninit<
9670 crate::wire::BootManagerSetConfigurationHealthyRequest,
9671 >,
9672 _: (),
9673 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9674 ::fidl_next::munge! {
9675 let crate::wire::BootManagerSetConfigurationHealthyRequest {
9676 configuration,
9677
9678 } = out_;
9679 }
9680
9681 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9682
9683 Ok(())
9684 }
9685 }
9686
9687 unsafe impl<'a, ___E, T0>
9688 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyRequest, ___E>
9689 for &'a BootManagerSetConfigurationHealthyRequest<T0>
9690 where
9691 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9692 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9693 {
9694 #[inline]
9695 fn encode(
9696 self,
9697 encoder_: &mut ___E,
9698 out_: &mut ::core::mem::MaybeUninit<
9699 crate::wire::BootManagerSetConfigurationHealthyRequest,
9700 >,
9701 _: (),
9702 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9703 ::fidl_next::munge! {
9704 let crate::wire::BootManagerSetConfigurationHealthyRequest {
9705 configuration,
9706
9707 } = out_;
9708 }
9709
9710 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9711
9712 Ok(())
9713 }
9714 }
9715
9716 pub struct BootManagerSetConfigurationHealthyResponse<T0> {
9718 pub status: T0,
9719 }
9720
9721 unsafe impl<___E, T0>
9722 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyResponse, ___E>
9723 for BootManagerSetConfigurationHealthyResponse<T0>
9724 where
9725 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9726 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9727 {
9728 #[inline]
9729 fn encode(
9730 self,
9731 encoder_: &mut ___E,
9732 out_: &mut ::core::mem::MaybeUninit<
9733 crate::wire::BootManagerSetConfigurationHealthyResponse,
9734 >,
9735 _: (),
9736 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9737 ::fidl_next::munge! {
9738 let crate::wire::BootManagerSetConfigurationHealthyResponse {
9739 status,
9740
9741 } = out_;
9742 }
9743
9744 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
9745
9746 Ok(())
9747 }
9748 }
9749
9750 unsafe impl<'a, ___E, T0>
9751 ::fidl_next::Encode<crate::wire::BootManagerSetConfigurationHealthyResponse, ___E>
9752 for &'a BootManagerSetConfigurationHealthyResponse<T0>
9753 where
9754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9755 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9756 {
9757 #[inline]
9758 fn encode(
9759 self,
9760 encoder_: &mut ___E,
9761 out_: &mut ::core::mem::MaybeUninit<
9762 crate::wire::BootManagerSetConfigurationHealthyResponse,
9763 >,
9764 _: (),
9765 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9766 ::fidl_next::munge! {
9767 let crate::wire::BootManagerSetConfigurationHealthyResponse {
9768 status,
9769
9770 } = out_;
9771 }
9772
9773 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
9774
9775 Ok(())
9776 }
9777 }
9778
9779 pub type BootManagerSetOneShotRecoveryResponse = ();
9781
9782 pub struct BootManagerFlushResponse<T0> {
9784 pub status: T0,
9785 }
9786
9787 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BootManagerFlushResponse, ___E>
9788 for BootManagerFlushResponse<T0>
9789 where
9790 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9791 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9792 {
9793 #[inline]
9794 fn encode(
9795 self,
9796 encoder_: &mut ___E,
9797 out_: &mut ::core::mem::MaybeUninit<crate::wire::BootManagerFlushResponse>,
9798 _: (),
9799 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9800 ::fidl_next::munge! {
9801 let crate::wire::BootManagerFlushResponse {
9802 status,
9803
9804 } = out_;
9805 }
9806
9807 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
9808
9809 Ok(())
9810 }
9811 }
9812
9813 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::BootManagerFlushResponse, ___E>
9814 for &'a BootManagerFlushResponse<T0>
9815 where
9816 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9817 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9818 {
9819 #[inline]
9820 fn encode(
9821 self,
9822 encoder_: &mut ___E,
9823 out_: &mut ::core::mem::MaybeUninit<crate::wire::BootManagerFlushResponse>,
9824 _: (),
9825 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9826 ::fidl_next::munge! {
9827 let crate::wire::BootManagerFlushResponse {
9828 status,
9829
9830 } = out_;
9831 }
9832
9833 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
9834
9835 Ok(())
9836 }
9837 }
9838
9839 pub struct DataSinkReadAssetRequest<T0, T1> {
9841 pub configuration: T0,
9842
9843 pub asset: T1,
9844 }
9845
9846 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DataSinkReadAssetRequest, ___E>
9847 for DataSinkReadAssetRequest<T0, T1>
9848 where
9849 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9850 T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9851 T1: ::fidl_next::Encode<crate::wire::Asset, ___E>,
9852 {
9853 #[inline]
9854 fn encode(
9855 self,
9856 encoder_: &mut ___E,
9857 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkReadAssetRequest>,
9858 _: (),
9859 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9860 ::fidl_next::munge! {
9861 let crate::wire::DataSinkReadAssetRequest {
9862 configuration,
9863 asset,
9864
9865 } = out_;
9866 }
9867
9868 ::fidl_next::Encode::encode(self.configuration, encoder_, configuration, ())?;
9869
9870 ::fidl_next::Encode::encode(self.asset, encoder_, asset, ())?;
9871
9872 Ok(())
9873 }
9874 }
9875
9876 unsafe impl<'a, ___E, T0, T1> ::fidl_next::Encode<crate::wire::DataSinkReadAssetRequest, ___E>
9877 for &'a DataSinkReadAssetRequest<T0, T1>
9878 where
9879 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9880 &'a T0: ::fidl_next::Encode<crate::wire::Configuration, ___E>,
9881 &'a T1: ::fidl_next::Encode<crate::wire::Asset, ___E>,
9882 {
9883 #[inline]
9884 fn encode(
9885 self,
9886 encoder_: &mut ___E,
9887 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkReadAssetRequest>,
9888 _: (),
9889 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9890 ::fidl_next::munge! {
9891 let crate::wire::DataSinkReadAssetRequest {
9892 configuration,
9893 asset,
9894
9895 } = out_;
9896 }
9897
9898 ::fidl_next::Encode::encode(&self.configuration, encoder_, configuration, ())?;
9899
9900 ::fidl_next::Encode::encode(&self.asset, encoder_, asset, ())?;
9901
9902 Ok(())
9903 }
9904 }
9905
9906 pub struct DataSinkWriteAssetResponse<T0> {
9908 pub status: T0,
9909 }
9910
9911 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DataSinkWriteAssetResponse, ___E>
9912 for DataSinkWriteAssetResponse<T0>
9913 where
9914 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9915 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9916 {
9917 #[inline]
9918 fn encode(
9919 self,
9920 encoder_: &mut ___E,
9921 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteAssetResponse>,
9922 _: (),
9923 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9924 ::fidl_next::munge! {
9925 let crate::wire::DataSinkWriteAssetResponse {
9926 status,
9927
9928 } = out_;
9929 }
9930
9931 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
9932
9933 Ok(())
9934 }
9935 }
9936
9937 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::DataSinkWriteAssetResponse, ___E>
9938 for &'a DataSinkWriteAssetResponse<T0>
9939 where
9940 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9941 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
9942 {
9943 #[inline]
9944 fn encode(
9945 self,
9946 encoder_: &mut ___E,
9947 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteAssetResponse>,
9948 _: (),
9949 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9950 ::fidl_next::munge! {
9951 let crate::wire::DataSinkWriteAssetResponse {
9952 status,
9953
9954 } = out_;
9955 }
9956
9957 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
9958
9959 Ok(())
9960 }
9961 }
9962
9963 pub struct DataSinkWriteFirmwareResponse<T0> {
9965 pub result: T0,
9966 }
9967
9968 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DataSinkWriteFirmwareResponse, ___E>
9969 for DataSinkWriteFirmwareResponse<T0>
9970 where
9971 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9972 T0: ::fidl_next::Encode<crate::wire::WriteFirmwareResult, ___E>,
9973 {
9974 #[inline]
9975 fn encode(
9976 self,
9977 encoder_: &mut ___E,
9978 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteFirmwareResponse>,
9979 _: (),
9980 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9981 ::fidl_next::munge! {
9982 let crate::wire::DataSinkWriteFirmwareResponse {
9983 result,
9984
9985 } = out_;
9986 }
9987
9988 ::fidl_next::Encode::encode(self.result, encoder_, result, ())?;
9989
9990 Ok(())
9991 }
9992 }
9993
9994 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::DataSinkWriteFirmwareResponse, ___E>
9995 for &'a DataSinkWriteFirmwareResponse<T0>
9996 where
9997 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9998 &'a T0: ::fidl_next::Encode<crate::wire::WriteFirmwareResult, ___E>,
9999 {
10000 #[inline]
10001 fn encode(
10002 self,
10003 encoder_: &mut ___E,
10004 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkWriteFirmwareResponse>,
10005 _: (),
10006 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10007 ::fidl_next::munge! {
10008 let crate::wire::DataSinkWriteFirmwareResponse {
10009 result,
10010
10011 } = out_;
10012 }
10013
10014 ::fidl_next::Encode::encode(&self.result, encoder_, result, ())?;
10015
10016 Ok(())
10017 }
10018 }
10019
10020 pub type DataSinkWriteOpaqueVolumeResponse = ();
10022
10023 pub type DataSinkWriteSparseVolumeResponse = ();
10025
10026 pub struct DataSinkFlushResponse<T0> {
10028 pub status: T0,
10029 }
10030
10031 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DataSinkFlushResponse, ___E>
10032 for DataSinkFlushResponse<T0>
10033 where
10034 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10035 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10036 {
10037 #[inline]
10038 fn encode(
10039 self,
10040 encoder_: &mut ___E,
10041 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkFlushResponse>,
10042 _: (),
10043 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10044 ::fidl_next::munge! {
10045 let crate::wire::DataSinkFlushResponse {
10046 status,
10047
10048 } = out_;
10049 }
10050
10051 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
10052
10053 Ok(())
10054 }
10055 }
10056
10057 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::DataSinkFlushResponse, ___E>
10058 for &'a DataSinkFlushResponse<T0>
10059 where
10060 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10061 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10062 {
10063 #[inline]
10064 fn encode(
10065 self,
10066 encoder_: &mut ___E,
10067 out_: &mut ::core::mem::MaybeUninit<crate::wire::DataSinkFlushResponse>,
10068 _: (),
10069 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10070 ::fidl_next::munge! {
10071 let crate::wire::DataSinkFlushResponse {
10072 status,
10073
10074 } = out_;
10075 }
10076
10077 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
10078
10079 Ok(())
10080 }
10081 }
10082
10083 pub struct DynamicDataSinkInitializePartitionTablesResponse<T0> {
10085 pub status: T0,
10086 }
10087
10088 unsafe impl<___E, T0>
10089 ::fidl_next::Encode<crate::wire::DynamicDataSinkInitializePartitionTablesResponse, ___E>
10090 for DynamicDataSinkInitializePartitionTablesResponse<T0>
10091 where
10092 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10093 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10094 {
10095 #[inline]
10096 fn encode(
10097 self,
10098 encoder_: &mut ___E,
10099 out_: &mut ::core::mem::MaybeUninit<
10100 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
10101 >,
10102 _: (),
10103 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10104 ::fidl_next::munge! {
10105 let crate::wire::DynamicDataSinkInitializePartitionTablesResponse {
10106 status,
10107
10108 } = out_;
10109 }
10110
10111 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
10112
10113 Ok(())
10114 }
10115 }
10116
10117 unsafe impl<'a, ___E, T0>
10118 ::fidl_next::Encode<crate::wire::DynamicDataSinkInitializePartitionTablesResponse, ___E>
10119 for &'a DynamicDataSinkInitializePartitionTablesResponse<T0>
10120 where
10121 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10122 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10123 {
10124 #[inline]
10125 fn encode(
10126 self,
10127 encoder_: &mut ___E,
10128 out_: &mut ::core::mem::MaybeUninit<
10129 crate::wire::DynamicDataSinkInitializePartitionTablesResponse,
10130 >,
10131 _: (),
10132 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10133 ::fidl_next::munge! {
10134 let crate::wire::DynamicDataSinkInitializePartitionTablesResponse {
10135 status,
10136
10137 } = out_;
10138 }
10139
10140 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
10141
10142 Ok(())
10143 }
10144 }
10145
10146 pub struct DynamicDataSinkWipePartitionTablesResponse<T0> {
10148 pub status: T0,
10149 }
10150
10151 unsafe impl<___E, T0>
10152 ::fidl_next::Encode<crate::wire::DynamicDataSinkWipePartitionTablesResponse, ___E>
10153 for DynamicDataSinkWipePartitionTablesResponse<T0>
10154 where
10155 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10156 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10157 {
10158 #[inline]
10159 fn encode(
10160 self,
10161 encoder_: &mut ___E,
10162 out_: &mut ::core::mem::MaybeUninit<
10163 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
10164 >,
10165 _: (),
10166 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10167 ::fidl_next::munge! {
10168 let crate::wire::DynamicDataSinkWipePartitionTablesResponse {
10169 status,
10170
10171 } = out_;
10172 }
10173
10174 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
10175
10176 Ok(())
10177 }
10178 }
10179
10180 unsafe impl<'a, ___E, T0>
10181 ::fidl_next::Encode<crate::wire::DynamicDataSinkWipePartitionTablesResponse, ___E>
10182 for &'a DynamicDataSinkWipePartitionTablesResponse<T0>
10183 where
10184 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10185 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10186 {
10187 #[inline]
10188 fn encode(
10189 self,
10190 encoder_: &mut ___E,
10191 out_: &mut ::core::mem::MaybeUninit<
10192 crate::wire::DynamicDataSinkWipePartitionTablesResponse,
10193 >,
10194 _: (),
10195 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10196 ::fidl_next::munge! {
10197 let crate::wire::DynamicDataSinkWipePartitionTablesResponse {
10198 status,
10199
10200 } = out_;
10201 }
10202
10203 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
10204
10205 Ok(())
10206 }
10207 }
10208
10209 pub struct PartitionIoGetPartitionSizeRequest<T0> {
10211 pub partition: T0,
10212 }
10213
10214 unsafe impl<___E, T0>
10215 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeRequest<'static>, ___E>
10216 for PartitionIoGetPartitionSizeRequest<T0>
10217 where
10218 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10219 ___E: ::fidl_next::Encoder,
10220 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10221 {
10222 #[inline]
10223 fn encode(
10224 self,
10225 encoder_: &mut ___E,
10226 out_: &mut ::core::mem::MaybeUninit<
10227 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
10228 >,
10229 _: (),
10230 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10231 ::fidl_next::munge! {
10232 let crate::wire::PartitionIoGetPartitionSizeRequest {
10233 partition,
10234
10235 } = out_;
10236 }
10237
10238 ::fidl_next::Encode::encode(self.partition, encoder_, partition, 128)?;
10239
10240 Ok(())
10241 }
10242 }
10243
10244 unsafe impl<'a, ___E, T0>
10245 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeRequest<'static>, ___E>
10246 for &'a PartitionIoGetPartitionSizeRequest<T0>
10247 where
10248 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10249 ___E: ::fidl_next::Encoder,
10250 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10251 {
10252 #[inline]
10253 fn encode(
10254 self,
10255 encoder_: &mut ___E,
10256 out_: &mut ::core::mem::MaybeUninit<
10257 crate::wire::PartitionIoGetPartitionSizeRequest<'static>,
10258 >,
10259 _: (),
10260 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10261 ::fidl_next::munge! {
10262 let crate::wire::PartitionIoGetPartitionSizeRequest {
10263 partition,
10264
10265 } = out_;
10266 }
10267
10268 ::fidl_next::Encode::encode(&self.partition, encoder_, partition, 128)?;
10269
10270 Ok(())
10271 }
10272 }
10273
10274 pub struct PartitionIoGetPartitionSizeResponse<T0> {
10276 pub size: T0,
10277 }
10278
10279 unsafe impl<___E, T0>
10280 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeResponse, ___E>
10281 for PartitionIoGetPartitionSizeResponse<T0>
10282 where
10283 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10284 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10285 {
10286 #[inline]
10287 fn encode(
10288 self,
10289 encoder_: &mut ___E,
10290 out_: &mut ::core::mem::MaybeUninit<crate::wire::PartitionIoGetPartitionSizeResponse>,
10291 _: (),
10292 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10293 ::fidl_next::munge! {
10294 let crate::wire::PartitionIoGetPartitionSizeResponse {
10295 size,
10296
10297 } = out_;
10298 }
10299
10300 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10301
10302 Ok(())
10303 }
10304 }
10305
10306 unsafe impl<'a, ___E, T0>
10307 ::fidl_next::Encode<crate::wire::PartitionIoGetPartitionSizeResponse, ___E>
10308 for &'a PartitionIoGetPartitionSizeResponse<T0>
10309 where
10310 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10311 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10312 {
10313 #[inline]
10314 fn encode(
10315 self,
10316 encoder_: &mut ___E,
10317 out_: &mut ::core::mem::MaybeUninit<crate::wire::PartitionIoGetPartitionSizeResponse>,
10318 _: (),
10319 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10320 ::fidl_next::munge! {
10321 let crate::wire::PartitionIoGetPartitionSizeResponse {
10322 size,
10323
10324 } = out_;
10325 }
10326
10327 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
10328
10329 Ok(())
10330 }
10331 }
10332
10333 pub struct PartitionIoReadPartitionRequest<T0, T1, T2> {
10335 pub partition: T0,
10336
10337 pub offset: T1,
10338
10339 pub size: T2,
10340 }
10341
10342 unsafe impl<___E, T0, T1, T2>
10343 ::fidl_next::Encode<crate::wire::PartitionIoReadPartitionRequest<'static>, ___E>
10344 for PartitionIoReadPartitionRequest<T0, T1, T2>
10345 where
10346 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10347 ___E: ::fidl_next::Encoder,
10348 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10349 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10350 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10351 {
10352 #[inline]
10353 fn encode(
10354 self,
10355 encoder_: &mut ___E,
10356 out_: &mut ::core::mem::MaybeUninit<
10357 crate::wire::PartitionIoReadPartitionRequest<'static>,
10358 >,
10359 _: (),
10360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10361 ::fidl_next::munge! {
10362 let crate::wire::PartitionIoReadPartitionRequest {
10363 partition,
10364 offset,
10365 size,
10366
10367 } = out_;
10368 }
10369
10370 ::fidl_next::Encode::encode(self.partition, encoder_, partition, 128)?;
10371
10372 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10373
10374 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10375
10376 Ok(())
10377 }
10378 }
10379
10380 unsafe impl<'a, ___E, T0, T1, T2>
10381 ::fidl_next::Encode<crate::wire::PartitionIoReadPartitionRequest<'static>, ___E>
10382 for &'a PartitionIoReadPartitionRequest<T0, T1, T2>
10383 where
10384 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10385 ___E: ::fidl_next::Encoder,
10386 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
10387 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10388 &'a T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10389 {
10390 #[inline]
10391 fn encode(
10392 self,
10393 encoder_: &mut ___E,
10394 out_: &mut ::core::mem::MaybeUninit<
10395 crate::wire::PartitionIoReadPartitionRequest<'static>,
10396 >,
10397 _: (),
10398 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10399 ::fidl_next::munge! {
10400 let crate::wire::PartitionIoReadPartitionRequest {
10401 partition,
10402 offset,
10403 size,
10404
10405 } = out_;
10406 }
10407
10408 ::fidl_next::Encode::encode(&self.partition, encoder_, partition, 128)?;
10409
10410 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
10411
10412 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
10413
10414 Ok(())
10415 }
10416 }
10417
10418 pub type PartitionIoWritePartitionResponse = ();
10420
10421 pub type PartitionIoFlushResponse = ();
10423
10424 pub struct ReadInfo<T0, T1> {
10426 pub offset: T0,
10427
10428 pub size: T1,
10429 }
10430
10431 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ReadInfo, ___E> for ReadInfo<T0, T1>
10432 where
10433 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10434 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10435 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10436 {
10437 #[inline]
10438 fn encode(
10439 self,
10440 encoder_: &mut ___E,
10441 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadInfo>,
10442 _: (),
10443 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10444 ::fidl_next::munge! {
10445 let crate::wire::ReadInfo {
10446 offset,
10447 size,
10448
10449 } = out_;
10450 }
10451
10452 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
10453
10454 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10455
10456 Ok(())
10457 }
10458 }
10459
10460 unsafe impl<'a, ___E, T0, T1> ::fidl_next::Encode<crate::wire::ReadInfo, ___E>
10461 for &'a ReadInfo<T0, T1>
10462 where
10463 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10464 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10465 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10466 {
10467 #[inline]
10468 fn encode(
10469 self,
10470 encoder_: &mut ___E,
10471 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadInfo>,
10472 _: (),
10473 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10474 ::fidl_next::munge! {
10475 let crate::wire::ReadInfo {
10476 offset,
10477 size,
10478
10479 } = out_;
10480 }
10481
10482 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
10483
10484 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
10485
10486 Ok(())
10487 }
10488 }
10489
10490 pub struct SysconfigWriteResponse<T0> {
10492 pub status: T0,
10493 }
10494
10495 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SysconfigWriteResponse, ___E>
10496 for SysconfigWriteResponse<T0>
10497 where
10498 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10499 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10500 {
10501 #[inline]
10502 fn encode(
10503 self,
10504 encoder_: &mut ___E,
10505 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWriteResponse>,
10506 _: (),
10507 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10508 ::fidl_next::munge! {
10509 let crate::wire::SysconfigWriteResponse {
10510 status,
10511
10512 } = out_;
10513 }
10514
10515 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
10516
10517 Ok(())
10518 }
10519 }
10520
10521 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::SysconfigWriteResponse, ___E>
10522 for &'a SysconfigWriteResponse<T0>
10523 where
10524 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10525 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10526 {
10527 #[inline]
10528 fn encode(
10529 self,
10530 encoder_: &mut ___E,
10531 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWriteResponse>,
10532 _: (),
10533 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10534 ::fidl_next::munge! {
10535 let crate::wire::SysconfigWriteResponse {
10536 status,
10537
10538 } = out_;
10539 }
10540
10541 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
10542
10543 Ok(())
10544 }
10545 }
10546
10547 pub struct SysconfigGetPartitionSizeResponse<T0> {
10549 pub size: T0,
10550 }
10551
10552 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SysconfigGetPartitionSizeResponse, ___E>
10553 for SysconfigGetPartitionSizeResponse<T0>
10554 where
10555 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10556 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10557 {
10558 #[inline]
10559 fn encode(
10560 self,
10561 encoder_: &mut ___E,
10562 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigGetPartitionSizeResponse>,
10563 _: (),
10564 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10565 ::fidl_next::munge! {
10566 let crate::wire::SysconfigGetPartitionSizeResponse {
10567 size,
10568
10569 } = out_;
10570 }
10571
10572 ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;
10573
10574 Ok(())
10575 }
10576 }
10577
10578 unsafe impl<'a, ___E, T0>
10579 ::fidl_next::Encode<crate::wire::SysconfigGetPartitionSizeResponse, ___E>
10580 for &'a SysconfigGetPartitionSizeResponse<T0>
10581 where
10582 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10583 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
10584 {
10585 #[inline]
10586 fn encode(
10587 self,
10588 encoder_: &mut ___E,
10589 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigGetPartitionSizeResponse>,
10590 _: (),
10591 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10592 ::fidl_next::munge! {
10593 let crate::wire::SysconfigGetPartitionSizeResponse {
10594 size,
10595
10596 } = out_;
10597 }
10598
10599 ::fidl_next::Encode::encode(&self.size, encoder_, size, ())?;
10600
10601 Ok(())
10602 }
10603 }
10604
10605 pub struct SysconfigFlushResponse<T0> {
10607 pub status: T0,
10608 }
10609
10610 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SysconfigFlushResponse, ___E>
10611 for SysconfigFlushResponse<T0>
10612 where
10613 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10614 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10615 {
10616 #[inline]
10617 fn encode(
10618 self,
10619 encoder_: &mut ___E,
10620 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigFlushResponse>,
10621 _: (),
10622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10623 ::fidl_next::munge! {
10624 let crate::wire::SysconfigFlushResponse {
10625 status,
10626
10627 } = out_;
10628 }
10629
10630 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
10631
10632 Ok(())
10633 }
10634 }
10635
10636 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::SysconfigFlushResponse, ___E>
10637 for &'a SysconfigFlushResponse<T0>
10638 where
10639 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10640 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10641 {
10642 #[inline]
10643 fn encode(
10644 self,
10645 encoder_: &mut ___E,
10646 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigFlushResponse>,
10647 _: (),
10648 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10649 ::fidl_next::munge! {
10650 let crate::wire::SysconfigFlushResponse {
10651 status,
10652
10653 } = out_;
10654 }
10655
10656 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
10657
10658 Ok(())
10659 }
10660 }
10661
10662 pub struct SysconfigWipeResponse<T0> {
10664 pub status: T0,
10665 }
10666
10667 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SysconfigWipeResponse, ___E>
10668 for SysconfigWipeResponse<T0>
10669 where
10670 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10671 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10672 {
10673 #[inline]
10674 fn encode(
10675 self,
10676 encoder_: &mut ___E,
10677 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWipeResponse>,
10678 _: (),
10679 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10680 ::fidl_next::munge! {
10681 let crate::wire::SysconfigWipeResponse {
10682 status,
10683
10684 } = out_;
10685 }
10686
10687 ::fidl_next::Encode::encode(self.status, encoder_, status, ())?;
10688
10689 Ok(())
10690 }
10691 }
10692
10693 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::SysconfigWipeResponse, ___E>
10694 for &'a SysconfigWipeResponse<T0>
10695 where
10696 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10697 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
10698 {
10699 #[inline]
10700 fn encode(
10701 self,
10702 encoder_: &mut ___E,
10703 out_: &mut ::core::mem::MaybeUninit<crate::wire::SysconfigWipeResponse>,
10704 _: (),
10705 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10706 ::fidl_next::munge! {
10707 let crate::wire::SysconfigWipeResponse {
10708 status,
10709
10710 } = out_;
10711 }
10712
10713 ::fidl_next::Encode::encode(&self.status, encoder_, status, ())?;
10714
10715 Ok(())
10716 }
10717 }
10718}
10719
10720pub use self::natural::*;
10721
10722#[doc = " Protocol for managing boot configurations.\n\n All functions will first check the A/B/R metadata and reset it to the default state if it\'s\n invalid.\n\n Operations which change the configuration are applied transactionally and will not be persisted\n to storage until Flush() is called, at which point they will *all* be applied (or none at all).\n If any of the operations fail (which is generally unexpected), the current set of changes may be\n discarded.\n\n The connection will be immediately closed with an epitaph of `ZX_ERR_NOT_SUPPORTED` if A/B/R is\n not supported.\n"]
10724#[derive(PartialEq, Debug)]
10725pub struct BootManager;
10726
10727#[cfg(target_os = "fuchsia")]
10728impl ::fidl_next::HasTransport for BootManager {
10729 type Transport = ::fidl_next::fuchsia::zx::Channel;
10730}
10731
10732pub mod boot_manager {
10733 pub mod prelude {
10734 pub use crate::{
10735 BootManager, BootManagerClientHandler, BootManagerLocalClientHandler,
10736 BootManagerLocalServerHandler, BootManagerServerHandler, boot_manager,
10737 };
10738
10739 pub use crate::natural::BootManagerFlushResponse;
10740
10741 pub use crate::natural::BootManagerQueryConfigurationStatusAndBootAttemptsRequest;
10742
10743 pub use crate::natural::BootManagerQueryConfigurationStatusRequest;
10744
10745 pub use crate::natural::BootManagerSetConfigurationActiveRequest;
10746
10747 pub use crate::natural::BootManagerSetConfigurationActiveResponse;
10748
10749 pub use crate::natural::BootManagerSetConfigurationHealthyRequest;
10750
10751 pub use crate::natural::BootManagerSetConfigurationHealthyResponse;
10752
10753 pub use crate::natural::BootManagerSetConfigurationUnbootableRequest;
10754
10755 pub use crate::natural::BootManagerSetConfigurationUnbootableResponse;
10756
10757 pub use crate::natural::BootManagerQueryActiveConfigurationResponse;
10758
10759 pub use crate::natural::BootManagerQueryConfigurationLastSetActiveResponse;
10760
10761 pub use crate::natural::BootManagerQueryConfigurationStatusAndBootAttemptsResponse;
10762
10763 pub use crate::natural::BootManagerQueryConfigurationStatusResponse;
10764
10765 pub use crate::natural::BootManagerQueryCurrentConfigurationResponse;
10766
10767 pub use crate::natural::BootManagerSetOneShotRecoveryResponse;
10768 }
10769
10770 pub struct QueryCurrentConfiguration;
10771
10772 impl ::fidl_next::Method for QueryCurrentConfiguration {
10773 const ORDINAL: u64 = 874035434522002289;
10774 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10775 ::fidl_next::protocol::Flexibility::Strict;
10776
10777 type Protocol = crate::BootManager;
10778
10779 type Request = ::fidl_next::wire::EmptyMessageBody;
10780 }
10781
10782 impl ::fidl_next::TwoWayMethod for QueryCurrentConfiguration {
10783 type Response = ::fidl_next::wire::Result<
10784 'static,
10785 crate::wire::BootManagerQueryCurrentConfigurationResponse,
10786 ::fidl_next::wire::fuchsia::Status,
10787 >;
10788 }
10789
10790 impl<___R> ::fidl_next::Respond<___R> for QueryCurrentConfiguration {
10791 type Output = ::core::result::Result<
10792 crate::generic::BootManagerQueryCurrentConfigurationResponse<___R>,
10793 ::fidl_next::never::Never,
10794 >;
10795
10796 fn respond(response: ___R) -> Self::Output {
10797 ::core::result::Result::Ok(
10798 crate::generic::BootManagerQueryCurrentConfigurationResponse {
10799 configuration: response,
10800 },
10801 )
10802 }
10803 }
10804
10805 impl<___R> ::fidl_next::RespondErr<___R> for QueryCurrentConfiguration {
10806 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10807
10808 fn respond_err(response: ___R) -> Self::Output {
10809 ::core::result::Result::Err(response)
10810 }
10811 }
10812
10813 pub struct QueryActiveConfiguration;
10814
10815 impl ::fidl_next::Method for QueryActiveConfiguration {
10816 const ORDINAL: u64 = 8202509360402352036;
10817 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10818 ::fidl_next::protocol::Flexibility::Strict;
10819
10820 type Protocol = crate::BootManager;
10821
10822 type Request = ::fidl_next::wire::EmptyMessageBody;
10823 }
10824
10825 impl ::fidl_next::TwoWayMethod for QueryActiveConfiguration {
10826 type Response = ::fidl_next::wire::Result<
10827 'static,
10828 crate::wire::BootManagerQueryActiveConfigurationResponse,
10829 ::fidl_next::wire::fuchsia::Status,
10830 >;
10831 }
10832
10833 impl<___R> ::fidl_next::Respond<___R> for QueryActiveConfiguration {
10834 type Output = ::core::result::Result<
10835 crate::generic::BootManagerQueryActiveConfigurationResponse<___R>,
10836 ::fidl_next::never::Never,
10837 >;
10838
10839 fn respond(response: ___R) -> Self::Output {
10840 ::core::result::Result::Ok(
10841 crate::generic::BootManagerQueryActiveConfigurationResponse {
10842 configuration: response,
10843 },
10844 )
10845 }
10846 }
10847
10848 impl<___R> ::fidl_next::RespondErr<___R> for QueryActiveConfiguration {
10849 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10850
10851 fn respond_err(response: ___R) -> Self::Output {
10852 ::core::result::Result::Err(response)
10853 }
10854 }
10855
10856 pub struct QueryConfigurationLastSetActive;
10857
10858 impl ::fidl_next::Method for QueryConfigurationLastSetActive {
10859 const ORDINAL: u64 = 485453656005227333;
10860 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10861 ::fidl_next::protocol::Flexibility::Strict;
10862
10863 type Protocol = crate::BootManager;
10864
10865 type Request = ::fidl_next::wire::EmptyMessageBody;
10866 }
10867
10868 impl ::fidl_next::TwoWayMethod for QueryConfigurationLastSetActive {
10869 type Response = ::fidl_next::wire::Result<
10870 'static,
10871 crate::wire::BootManagerQueryConfigurationLastSetActiveResponse,
10872 ::fidl_next::wire::fuchsia::Status,
10873 >;
10874 }
10875
10876 impl<___R> ::fidl_next::Respond<___R> for QueryConfigurationLastSetActive {
10877 type Output = ::core::result::Result<
10878 crate::generic::BootManagerQueryConfigurationLastSetActiveResponse<___R>,
10879 ::fidl_next::never::Never,
10880 >;
10881
10882 fn respond(response: ___R) -> Self::Output {
10883 ::core::result::Result::Ok(
10884 crate::generic::BootManagerQueryConfigurationLastSetActiveResponse {
10885 configuration: response,
10886 },
10887 )
10888 }
10889 }
10890
10891 impl<___R> ::fidl_next::RespondErr<___R> for QueryConfigurationLastSetActive {
10892 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10893
10894 fn respond_err(response: ___R) -> Self::Output {
10895 ::core::result::Result::Err(response)
10896 }
10897 }
10898
10899 pub struct QueryConfigurationStatus;
10900
10901 impl ::fidl_next::Method for QueryConfigurationStatus {
10902 const ORDINAL: u64 = 4648326873156727194;
10903 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10904 ::fidl_next::protocol::Flexibility::Strict;
10905
10906 type Protocol = crate::BootManager;
10907
10908 type Request = crate::wire::BootManagerQueryConfigurationStatusRequest;
10909 }
10910
10911 impl ::fidl_next::TwoWayMethod for QueryConfigurationStatus {
10912 type Response = ::fidl_next::wire::Result<
10913 'static,
10914 crate::wire::BootManagerQueryConfigurationStatusResponse,
10915 ::fidl_next::wire::fuchsia::Status,
10916 >;
10917 }
10918
10919 impl<___R> ::fidl_next::Respond<___R> for QueryConfigurationStatus {
10920 type Output = ::core::result::Result<
10921 crate::generic::BootManagerQueryConfigurationStatusResponse<___R>,
10922 ::fidl_next::never::Never,
10923 >;
10924
10925 fn respond(response: ___R) -> Self::Output {
10926 ::core::result::Result::Ok(
10927 crate::generic::BootManagerQueryConfigurationStatusResponse { status: response },
10928 )
10929 }
10930 }
10931
10932 impl<___R> ::fidl_next::RespondErr<___R> for QueryConfigurationStatus {
10933 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10934
10935 fn respond_err(response: ___R) -> Self::Output {
10936 ::core::result::Result::Err(response)
10937 }
10938 }
10939
10940 pub struct QueryConfigurationStatusAndBootAttempts;
10941
10942 impl ::fidl_next::Method for QueryConfigurationStatusAndBootAttempts {
10943 const ORDINAL: u64 = 2880141939131087677;
10944 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10945 ::fidl_next::protocol::Flexibility::Strict;
10946
10947 type Protocol = crate::BootManager;
10948
10949 type Request = crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest;
10950 }
10951
10952 impl ::fidl_next::TwoWayMethod for QueryConfigurationStatusAndBootAttempts {
10953 type Response = ::fidl_next::wire::Result<
10954 'static,
10955 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsResponse<'static>,
10956 ::fidl_next::wire::fuchsia::Status,
10957 >;
10958 }
10959
10960 impl<___R> ::fidl_next::Respond<___R> for QueryConfigurationStatusAndBootAttempts {
10961 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10962
10963 fn respond(response: ___R) -> Self::Output {
10964 ::core::result::Result::Ok(response)
10965 }
10966 }
10967
10968 impl<___R> ::fidl_next::RespondErr<___R> for QueryConfigurationStatusAndBootAttempts {
10969 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10970
10971 fn respond_err(response: ___R) -> Self::Output {
10972 ::core::result::Result::Err(response)
10973 }
10974 }
10975
10976 pub struct SetConfigurationActive;
10977
10978 impl ::fidl_next::Method for SetConfigurationActive {
10979 const ORDINAL: u64 = 1496954797270473343;
10980 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10981 ::fidl_next::protocol::Flexibility::Strict;
10982
10983 type Protocol = crate::BootManager;
10984
10985 type Request = crate::wire::BootManagerSetConfigurationActiveRequest;
10986 }
10987
10988 impl ::fidl_next::TwoWayMethod for SetConfigurationActive {
10989 type Response =
10990 ::fidl_next::wire::Strict<crate::wire::BootManagerSetConfigurationActiveResponse>;
10991 }
10992
10993 impl<___R> ::fidl_next::Respond<___R> for SetConfigurationActive {
10994 type Output =
10995 ::fidl_next::Strict<crate::generic::BootManagerSetConfigurationActiveResponse<___R>>;
10996
10997 fn respond(response: ___R) -> Self::Output {
10998 ::fidl_next::Strict(crate::generic::BootManagerSetConfigurationActiveResponse {
10999 status: response,
11000 })
11001 }
11002 }
11003
11004 pub struct SetConfigurationUnbootable;
11005
11006 impl ::fidl_next::Method for SetConfigurationUnbootable {
11007 const ORDINAL: u64 = 8036417070472960383;
11008 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11009 ::fidl_next::protocol::Flexibility::Strict;
11010
11011 type Protocol = crate::BootManager;
11012
11013 type Request = crate::wire::BootManagerSetConfigurationUnbootableRequest;
11014 }
11015
11016 impl ::fidl_next::TwoWayMethod for SetConfigurationUnbootable {
11017 type Response =
11018 ::fidl_next::wire::Strict<crate::wire::BootManagerSetConfigurationUnbootableResponse>;
11019 }
11020
11021 impl<___R> ::fidl_next::Respond<___R> for SetConfigurationUnbootable {
11022 type Output = ::fidl_next::Strict<
11023 crate::generic::BootManagerSetConfigurationUnbootableResponse<___R>,
11024 >;
11025
11026 fn respond(response: ___R) -> Self::Output {
11027 ::fidl_next::Strict(crate::generic::BootManagerSetConfigurationUnbootableResponse {
11028 status: response,
11029 })
11030 }
11031 }
11032
11033 pub struct SetConfigurationHealthy;
11034
11035 impl ::fidl_next::Method for SetConfigurationHealthy {
11036 const ORDINAL: u64 = 6772905252297295038;
11037 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11038 ::fidl_next::protocol::Flexibility::Strict;
11039
11040 type Protocol = crate::BootManager;
11041
11042 type Request = crate::wire::BootManagerSetConfigurationHealthyRequest;
11043 }
11044
11045 impl ::fidl_next::TwoWayMethod for SetConfigurationHealthy {
11046 type Response =
11047 ::fidl_next::wire::Strict<crate::wire::BootManagerSetConfigurationHealthyResponse>;
11048 }
11049
11050 impl<___R> ::fidl_next::Respond<___R> for SetConfigurationHealthy {
11051 type Output =
11052 ::fidl_next::Strict<crate::generic::BootManagerSetConfigurationHealthyResponse<___R>>;
11053
11054 fn respond(response: ___R) -> Self::Output {
11055 ::fidl_next::Strict(crate::generic::BootManagerSetConfigurationHealthyResponse {
11056 status: response,
11057 })
11058 }
11059 }
11060
11061 pub struct SetOneShotRecovery;
11062
11063 impl ::fidl_next::Method for SetOneShotRecovery {
11064 const ORDINAL: u64 = 8816623801309917773;
11065 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11066 ::fidl_next::protocol::Flexibility::Strict;
11067
11068 type Protocol = crate::BootManager;
11069
11070 type Request = ::fidl_next::wire::EmptyMessageBody;
11071 }
11072
11073 impl ::fidl_next::TwoWayMethod for SetOneShotRecovery {
11074 type Response = ::fidl_next::wire::Result<
11075 'static,
11076 crate::wire::BootManagerSetOneShotRecoveryResponse,
11077 ::fidl_next::wire::fuchsia::Status,
11078 >;
11079 }
11080
11081 impl<___R> ::fidl_next::Respond<___R> for SetOneShotRecovery {
11082 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11083
11084 fn respond(response: ___R) -> Self::Output {
11085 ::core::result::Result::Ok(response)
11086 }
11087 }
11088
11089 impl<___R> ::fidl_next::RespondErr<___R> for SetOneShotRecovery {
11090 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11091
11092 fn respond_err(response: ___R) -> Self::Output {
11093 ::core::result::Result::Err(response)
11094 }
11095 }
11096
11097 pub struct Flush;
11098
11099 impl ::fidl_next::Method for Flush {
11100 const ORDINAL: u64 = 3398507029480222014;
11101 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11102 ::fidl_next::protocol::Flexibility::Strict;
11103
11104 type Protocol = crate::BootManager;
11105
11106 type Request = ::fidl_next::wire::EmptyMessageBody;
11107 }
11108
11109 impl ::fidl_next::TwoWayMethod for Flush {
11110 type Response = ::fidl_next::wire::Strict<crate::wire::BootManagerFlushResponse>;
11111 }
11112
11113 impl<___R> ::fidl_next::Respond<___R> for Flush {
11114 type Output = ::fidl_next::Strict<crate::generic::BootManagerFlushResponse<___R>>;
11115
11116 fn respond(response: ___R) -> Self::Output {
11117 ::fidl_next::Strict(crate::generic::BootManagerFlushResponse { status: response })
11118 }
11119 }
11120
11121 mod ___detail {
11122 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::BootManager
11123 where
11124 ___T: ::fidl_next::Transport,
11125 {
11126 type Client = BootManagerClient<___T>;
11127 type Server = BootManagerServer<___T>;
11128 }
11129
11130 #[repr(transparent)]
11132 pub struct BootManagerClient<___T: ::fidl_next::Transport> {
11133 #[allow(dead_code)]
11134 client: ::fidl_next::protocol::Client<___T>,
11135 }
11136
11137 impl<___T> BootManagerClient<___T>
11138 where
11139 ___T: ::fidl_next::Transport,
11140 {
11141 #[doc = " Queries the configuration the system is currently running.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the `zvb.current_slot` boot argument cannot be read\n or is an unexpected value.\n"]
11142 pub fn query_current_configuration(
11143 &self,
11144 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryCurrentConfiguration, ___T> {
11145 ::fidl_next::TwoWayFuture::from_untyped(
11146 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11147 874035434522002289,
11148 <super::QueryCurrentConfiguration as ::fidl_next::Method>::FLEXIBILITY,
11149 (),
11150 ),
11151 )
11152 }
11153
11154 #[doc = " Queries the configuration which will be used as the default boot choice on a normal cold\n boot, which may differ from the currently running configuration. `Configuration::RECOVERY`\n should never be active.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if `Configuration.RECOVERY` is active.\n"]
11155 pub fn query_active_configuration(
11156 &self,
11157 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryActiveConfiguration, ___T> {
11158 ::fidl_next::TwoWayFuture::from_untyped(
11159 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11160 8202509360402352036,
11161 <super::QueryActiveConfiguration as ::fidl_next::Method>::FLEXIBILITY,
11162 (),
11163 ),
11164 )
11165 }
11166
11167 #[doc = " Queries the configuration that was last explicitly marked as active by\n SetConfigurationActive(). The result is not affected by the current status of the slot.\n\n A newly updated slot is typically marked as active immediately. Therefore this interface\n can be used as a way to identify the newest slot.\n\n Returns `ZX_ERR_IO` if fail to load abr metadata. Returns `ZX_ERR_INTERNAL` if invalid\n slot index is returned by libabr routine.\n"]
11168 pub fn query_configuration_last_set_active(
11169 &self,
11170 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryConfigurationLastSetActive, ___T>
11171 {
11172 ::fidl_next::TwoWayFuture::from_untyped(
11173 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11174 485453656005227333,
11175 <super::QueryConfigurationLastSetActive as ::fidl_next::Method>::FLEXIBILITY,
11176 (),
11177 )
11178 )
11179 }
11180
11181 #[doc = " Queries status of `configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11182 pub fn query_configuration_status(
11183 &self,
11184
11185 configuration: impl ::fidl_next::Encode<
11186 crate::wire::Configuration,
11187 <___T as ::fidl_next::Transport>::SendBuffer,
11188 >,
11189 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryConfigurationStatus, ___T>
11190 where
11191 <___T as ::fidl_next::Transport>::SendBuffer:
11192 ::fidl_next::encoder::InternalHandleEncoder,
11193 {
11194 self.query_configuration_status_with(
11195 crate::generic::BootManagerQueryConfigurationStatusRequest { configuration },
11196 )
11197 }
11198
11199 #[doc = " Queries status of `configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11200 pub fn query_configuration_status_with<___R>(
11201 &self,
11202 request: ___R,
11203 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryConfigurationStatus, ___T>
11204 where
11205 ___R: ::fidl_next::Encode<
11206 crate::wire::BootManagerQueryConfigurationStatusRequest,
11207 <___T as ::fidl_next::Transport>::SendBuffer,
11208 >,
11209 {
11210 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11211 4648326873156727194,
11212 <super::QueryConfigurationStatus as ::fidl_next::Method>::FLEXIBILITY,
11213 request,
11214 ))
11215 }
11216
11217 #[doc = " Queries status of `configuration`.\n\n The returned table contains:\n\n * `status`: the current `ConfigurationStatus`\n\n * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of\n times this configuration has attempted to boot, including the current attempt. For any\n other `status` this value will not be provided.\n\n If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates\n the configuration was just set active and has not attempted any boots yet, and\n `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.\n\n * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the\n reported reason for why the configuration is unbootable. For any other `status` this value\n will not be provided.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11218 pub fn query_configuration_status_and_boot_attempts(
11219 &self,
11220
11221 configuration: impl ::fidl_next::Encode<
11222 crate::wire::Configuration,
11223 <___T as ::fidl_next::Transport>::SendBuffer,
11224 >,
11225 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryConfigurationStatusAndBootAttempts, ___T>
11226 where
11227 <___T as ::fidl_next::Transport>::SendBuffer:
11228 ::fidl_next::encoder::InternalHandleEncoder,
11229 {
11230 self.query_configuration_status_and_boot_attempts_with(
11231 crate::generic::BootManagerQueryConfigurationStatusAndBootAttemptsRequest {
11232 configuration,
11233 },
11234 )
11235 }
11236
11237 #[doc = " Queries status of `configuration`.\n\n The returned table contains:\n\n * `status`: the current `ConfigurationStatus`\n\n * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of\n times this configuration has attempted to boot, including the current attempt. For any\n other `status` this value will not be provided.\n\n If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates\n the configuration was just set active and has not attempted any boots yet, and\n `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.\n\n * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the\n reported reason for why the configuration is unbootable. For any other `status` this value\n will not be provided.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11238 pub fn query_configuration_status_and_boot_attempts_with<___R>(
11239 &self,
11240 request: ___R,
11241 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryConfigurationStatusAndBootAttempts, ___T>
11242 where
11243 ___R: ::fidl_next::Encode<
11244 crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
11245 <___T as ::fidl_next::Transport>::SendBuffer,
11246 >,
11247 {
11248 ::fidl_next::TwoWayFuture::from_untyped(
11249 self.client.send_two_way(
11250 2880141939131087677,
11251 <super::QueryConfigurationStatusAndBootAttempts as ::fidl_next::Method>::FLEXIBILITY,
11252 request,
11253 )
11254 )
11255 }
11256
11257 #[doc = " Updates persistent metadata identifying which configuration should be selected as \'primary\'\n for booting purposes. Should only be called after `KERNEL` as well as optional\n `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.\n\n Also resets the boot attempts count for the given `Configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11258 pub fn set_configuration_active(
11259 &self,
11260
11261 configuration: impl ::fidl_next::Encode<
11262 crate::wire::Configuration,
11263 <___T as ::fidl_next::Transport>::SendBuffer,
11264 >,
11265 ) -> ::fidl_next::TwoWayFuture<'_, super::SetConfigurationActive, ___T>
11266 where
11267 <___T as ::fidl_next::Transport>::SendBuffer:
11268 ::fidl_next::encoder::InternalHandleEncoder,
11269 {
11270 self.set_configuration_active_with(
11271 crate::generic::BootManagerSetConfigurationActiveRequest { configuration },
11272 )
11273 }
11274
11275 #[doc = " Updates persistent metadata identifying which configuration should be selected as \'primary\'\n for booting purposes. Should only be called after `KERNEL` as well as optional\n `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.\n\n Also resets the boot attempts count for the given `Configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11276 pub fn set_configuration_active_with<___R>(
11277 &self,
11278 request: ___R,
11279 ) -> ::fidl_next::TwoWayFuture<'_, super::SetConfigurationActive, ___T>
11280 where
11281 ___R: ::fidl_next::Encode<
11282 crate::wire::BootManagerSetConfigurationActiveRequest,
11283 <___T as ::fidl_next::Transport>::SendBuffer,
11284 >,
11285 {
11286 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11287 1496954797270473343,
11288 <super::SetConfigurationActive as ::fidl_next::Method>::FLEXIBILITY,
11289 request,
11290 ))
11291 }
11292
11293 #[doc = " Updates persistent metadata identifying whether `configuration` is bootable.\n Should only be called in the following situations:\n * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified\n `configuration` are written.\n * After successfully booting from a new configuration and marking it healthy. This method\n would be then called on the old configuration.\n * After \"successfully\" booting from a new configuration, but encountering an unrecoverable\n error during health check. This method would be then called on the new configuration.\n\n If the configuration is unbootable, no action is taken.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11294 pub fn set_configuration_unbootable(
11295 &self,
11296
11297 configuration: impl ::fidl_next::Encode<
11298 crate::wire::Configuration,
11299 <___T as ::fidl_next::Transport>::SendBuffer,
11300 >,
11301 ) -> ::fidl_next::TwoWayFuture<'_, super::SetConfigurationUnbootable, ___T>
11302 where
11303 <___T as ::fidl_next::Transport>::SendBuffer:
11304 ::fidl_next::encoder::InternalHandleEncoder,
11305 {
11306 self.set_configuration_unbootable_with(
11307 crate::generic::BootManagerSetConfigurationUnbootableRequest { configuration },
11308 )
11309 }
11310
11311 #[doc = " Updates persistent metadata identifying whether `configuration` is bootable.\n Should only be called in the following situations:\n * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified\n `configuration` are written.\n * After successfully booting from a new configuration and marking it healthy. This method\n would be then called on the old configuration.\n * After \"successfully\" booting from a new configuration, but encountering an unrecoverable\n error during health check. This method would be then called on the new configuration.\n\n If the configuration is unbootable, no action is taken.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11312 pub fn set_configuration_unbootable_with<___R>(
11313 &self,
11314 request: ___R,
11315 ) -> ::fidl_next::TwoWayFuture<'_, super::SetConfigurationUnbootable, ___T>
11316 where
11317 ___R: ::fidl_next::Encode<
11318 crate::wire::BootManagerSetConfigurationUnbootableRequest,
11319 <___T as ::fidl_next::Transport>::SendBuffer,
11320 >,
11321 {
11322 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11323 8036417070472960383,
11324 <super::SetConfigurationUnbootable as ::fidl_next::Method>::FLEXIBILITY,
11325 request,
11326 ))
11327 }
11328
11329 #[doc = " Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]\n as successful.\n\n This function is typically used by the OS update system after having\n confirmed that the configuration works as intended and the \"rollback to\n previous slot\" logic is not needed anymore.\n\n Compatibility between the newly successful configuration and the other\n configuration is unknown. Even if the other configuration was\n successful at one point, it may no longer be. This function adds a\n success mark to the given configuration but also removes any success\n mark on the other.\n\n If `configuration` is unbootable or is\n [`fuchsia.paver/Configuration.RECOVERY`], `response` will be\n `ZX_ERR_INVALID_ARGS`.\n\n + request `configuration` the `Configuration` to mark as healthy. Must\n not be `RECOVERY`.\n - response `status` a zx_status value indicating success or failure.\n"]
11330 pub fn set_configuration_healthy(
11331 &self,
11332
11333 configuration: impl ::fidl_next::Encode<
11334 crate::wire::Configuration,
11335 <___T as ::fidl_next::Transport>::SendBuffer,
11336 >,
11337 ) -> ::fidl_next::TwoWayFuture<'_, super::SetConfigurationHealthy, ___T>
11338 where
11339 <___T as ::fidl_next::Transport>::SendBuffer:
11340 ::fidl_next::encoder::InternalHandleEncoder,
11341 {
11342 self.set_configuration_healthy_with(
11343 crate::generic::BootManagerSetConfigurationHealthyRequest { configuration },
11344 )
11345 }
11346
11347 #[doc = " Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]\n as successful.\n\n This function is typically used by the OS update system after having\n confirmed that the configuration works as intended and the \"rollback to\n previous slot\" logic is not needed anymore.\n\n Compatibility between the newly successful configuration and the other\n configuration is unknown. Even if the other configuration was\n successful at one point, it may no longer be. This function adds a\n success mark to the given configuration but also removes any success\n mark on the other.\n\n If `configuration` is unbootable or is\n [`fuchsia.paver/Configuration.RECOVERY`], `response` will be\n `ZX_ERR_INVALID_ARGS`.\n\n + request `configuration` the `Configuration` to mark as healthy. Must\n not be `RECOVERY`.\n - response `status` a zx_status value indicating success or failure.\n"]
11348 pub fn set_configuration_healthy_with<___R>(
11349 &self,
11350 request: ___R,
11351 ) -> ::fidl_next::TwoWayFuture<'_, super::SetConfigurationHealthy, ___T>
11352 where
11353 ___R: ::fidl_next::Encode<
11354 crate::wire::BootManagerSetConfigurationHealthyRequest,
11355 <___T as ::fidl_next::Transport>::SendBuffer,
11356 >,
11357 {
11358 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11359 6772905252297295038,
11360 <super::SetConfigurationHealthy as ::fidl_next::Method>::FLEXIBILITY,
11361 request,
11362 ))
11363 }
11364
11365 #[doc = " Force device to boot to recovery in the next reboot/power cycle. This will only be\n triggered once and will be reset after the reboot. State of A/B configuration slot will not\n be affected.\n"]
11366 pub fn set_one_shot_recovery(
11367 &self,
11368 ) -> ::fidl_next::TwoWayFuture<'_, super::SetOneShotRecovery, ___T> {
11369 ::fidl_next::TwoWayFuture::from_untyped(
11370 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11371 8816623801309917773,
11372 <super::SetOneShotRecovery as ::fidl_next::Method>::FLEXIBILITY,
11373 (),
11374 ),
11375 )
11376 }
11377
11378 #[doc = " Flush all previously buffered writes to persistent storage.\n"]
11379 pub fn flush(&self) -> ::fidl_next::TwoWayFuture<'_, super::Flush, ___T> {
11380 ::fidl_next::TwoWayFuture::from_untyped(
11381 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11382 3398507029480222014,
11383 <super::Flush as ::fidl_next::Method>::FLEXIBILITY,
11384 (),
11385 ),
11386 )
11387 }
11388 }
11389
11390 #[repr(transparent)]
11392 pub struct BootManagerServer<___T: ::fidl_next::Transport> {
11393 server: ::fidl_next::protocol::Server<___T>,
11394 }
11395
11396 impl<___T> BootManagerServer<___T> where ___T: ::fidl_next::Transport {}
11397 }
11398}
11399
11400#[diagnostic::on_unimplemented(
11401 note = "If {Self} implements the non-local BootManagerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
11402)]
11403
11404pub trait BootManagerLocalClientHandler<
11408 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11409 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11410>
11411{
11412}
11413
11414impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for BootManager
11415where
11416 ___H: BootManagerLocalClientHandler<___T>,
11417 ___T: ::fidl_next::Transport,
11418{
11419 async fn on_event(
11420 handler: &mut ___H,
11421 mut message: ::fidl_next::Message<___T>,
11422 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11423 match *message.header().ordinal {
11424 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11425 }
11426 }
11427}
11428
11429#[diagnostic::on_unimplemented(
11430 note = "If {Self} implements the non-local BootManagerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
11431)]
11432
11433pub trait BootManagerLocalServerHandler<
11437 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11438 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11439>
11440{
11441 #[doc = " Queries the configuration the system is currently running.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the `zvb.current_slot` boot argument cannot be read\n or is an unexpected value.\n"]
11442 fn query_current_configuration(
11443 &mut self,
11444
11445 responder: ::fidl_next::Responder<boot_manager::QueryCurrentConfiguration, ___T>,
11446 ) -> impl ::core::future::Future<Output = ()>;
11447
11448 #[doc = " Queries the configuration which will be used as the default boot choice on a normal cold\n boot, which may differ from the currently running configuration. `Configuration::RECOVERY`\n should never be active.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if `Configuration.RECOVERY` is active.\n"]
11449 fn query_active_configuration(
11450 &mut self,
11451
11452 responder: ::fidl_next::Responder<boot_manager::QueryActiveConfiguration, ___T>,
11453 ) -> impl ::core::future::Future<Output = ()>;
11454
11455 #[doc = " Queries the configuration that was last explicitly marked as active by\n SetConfigurationActive(). The result is not affected by the current status of the slot.\n\n A newly updated slot is typically marked as active immediately. Therefore this interface\n can be used as a way to identify the newest slot.\n\n Returns `ZX_ERR_IO` if fail to load abr metadata. Returns `ZX_ERR_INTERNAL` if invalid\n slot index is returned by libabr routine.\n"]
11456 fn query_configuration_last_set_active(
11457 &mut self,
11458
11459 responder: ::fidl_next::Responder<boot_manager::QueryConfigurationLastSetActive, ___T>,
11460 ) -> impl ::core::future::Future<Output = ()>;
11461
11462 #[doc = " Queries status of `configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11463 fn query_configuration_status(
11464 &mut self,
11465
11466 request: ::fidl_next::Request<boot_manager::QueryConfigurationStatus, ___T>,
11467
11468 responder: ::fidl_next::Responder<boot_manager::QueryConfigurationStatus, ___T>,
11469 ) -> impl ::core::future::Future<Output = ()>;
11470
11471 #[doc = " Queries status of `configuration`.\n\n The returned table contains:\n\n * `status`: the current `ConfigurationStatus`\n\n * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of\n times this configuration has attempted to boot, including the current attempt. For any\n other `status` this value will not be provided.\n\n If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates\n the configuration was just set active and has not attempted any boots yet, and\n `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.\n\n * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the\n reported reason for why the configuration is unbootable. For any other `status` this value\n will not be provided.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11472 fn query_configuration_status_and_boot_attempts(
11473 &mut self,
11474
11475 request: ::fidl_next::Request<boot_manager::QueryConfigurationStatusAndBootAttempts, ___T>,
11476
11477 responder: ::fidl_next::Responder<
11478 boot_manager::QueryConfigurationStatusAndBootAttempts,
11479 ___T,
11480 >,
11481 ) -> impl ::core::future::Future<Output = ()>;
11482
11483 #[doc = " Updates persistent metadata identifying which configuration should be selected as \'primary\'\n for booting purposes. Should only be called after `KERNEL` as well as optional\n `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.\n\n Also resets the boot attempts count for the given `Configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11484 fn set_configuration_active(
11485 &mut self,
11486
11487 request: ::fidl_next::Request<boot_manager::SetConfigurationActive, ___T>,
11488
11489 responder: ::fidl_next::Responder<boot_manager::SetConfigurationActive, ___T>,
11490 ) -> impl ::core::future::Future<Output = ()>;
11491
11492 #[doc = " Updates persistent metadata identifying whether `configuration` is bootable.\n Should only be called in the following situations:\n * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified\n `configuration` are written.\n * After successfully booting from a new configuration and marking it healthy. This method\n would be then called on the old configuration.\n * After \"successfully\" booting from a new configuration, but encountering an unrecoverable\n error during health check. This method would be then called on the new configuration.\n\n If the configuration is unbootable, no action is taken.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11493 fn set_configuration_unbootable(
11494 &mut self,
11495
11496 request: ::fidl_next::Request<boot_manager::SetConfigurationUnbootable, ___T>,
11497
11498 responder: ::fidl_next::Responder<boot_manager::SetConfigurationUnbootable, ___T>,
11499 ) -> impl ::core::future::Future<Output = ()>;
11500
11501 #[doc = " Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]\n as successful.\n\n This function is typically used by the OS update system after having\n confirmed that the configuration works as intended and the \"rollback to\n previous slot\" logic is not needed anymore.\n\n Compatibility between the newly successful configuration and the other\n configuration is unknown. Even if the other configuration was\n successful at one point, it may no longer be. This function adds a\n success mark to the given configuration but also removes any success\n mark on the other.\n\n If `configuration` is unbootable or is\n [`fuchsia.paver/Configuration.RECOVERY`], `response` will be\n `ZX_ERR_INVALID_ARGS`.\n\n + request `configuration` the `Configuration` to mark as healthy. Must\n not be `RECOVERY`.\n - response `status` a zx_status value indicating success or failure.\n"]
11502 fn set_configuration_healthy(
11503 &mut self,
11504
11505 request: ::fidl_next::Request<boot_manager::SetConfigurationHealthy, ___T>,
11506
11507 responder: ::fidl_next::Responder<boot_manager::SetConfigurationHealthy, ___T>,
11508 ) -> impl ::core::future::Future<Output = ()>;
11509
11510 #[doc = " Force device to boot to recovery in the next reboot/power cycle. This will only be\n triggered once and will be reset after the reboot. State of A/B configuration slot will not\n be affected.\n"]
11511 fn set_one_shot_recovery(
11512 &mut self,
11513
11514 responder: ::fidl_next::Responder<boot_manager::SetOneShotRecovery, ___T>,
11515 ) -> impl ::core::future::Future<Output = ()>;
11516
11517 #[doc = " Flush all previously buffered writes to persistent storage.\n"]
11518 fn flush(
11519 &mut self,
11520
11521 responder: ::fidl_next::Responder<boot_manager::Flush, ___T>,
11522 ) -> impl ::core::future::Future<Output = ()>;
11523}
11524
11525impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for BootManager
11526where
11527 ___H: BootManagerLocalServerHandler<___T> ,
11528 ___T: ::fidl_next::Transport,
11529
11530
11531
11532
11533
11534
11535
11536
11537 for<'de> crate::wire::BootManagerQueryConfigurationStatusRequest: ::fidl_next::Decode<
11538 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11539 Constraint = (),
11540 >,
11541
11542
11543
11544 for<'de> crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest: ::fidl_next::Decode<
11545 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11546 Constraint = (),
11547 >,
11548
11549
11550
11551 for<'de> crate::wire::BootManagerSetConfigurationActiveRequest: ::fidl_next::Decode<
11552 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11553 Constraint = (),
11554 >,
11555
11556
11557
11558 for<'de> crate::wire::BootManagerSetConfigurationUnbootableRequest: ::fidl_next::Decode<
11559 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11560 Constraint = (),
11561 >,
11562
11563
11564
11565 for<'de> crate::wire::BootManagerSetConfigurationHealthyRequest: ::fidl_next::Decode<
11566 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11567 Constraint = (),
11568 >,
11569
11570
11571
11572
11573
11574
11575{
11576 async fn on_one_way(
11577 handler: &mut ___H,
11578 mut message: ::fidl_next::Message<___T>,
11579 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>> {
11580 match *message.header().ordinal {
11581
11582
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
11610
11611
11612 ordinal => {
11613
11614 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11615
11616 }
11617 }
11618 }
11619
11620 async fn on_two_way(
11621 handler: &mut ___H,
11622 mut message: ::fidl_next::Message<___T>,
11623 responder: ::fidl_next::protocol::Responder<___T>,
11624 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>> {
11625 match *message.header().ordinal {
11626
11627
11628
11629 874035434522002289 => {
11630 let responder = ::fidl_next::Responder::from_untyped(responder);
11631
11632 handler.query_current_configuration(responder).await;
11633 Ok(())
11634
11635 }
11636
11637
11638
11639
11640 8202509360402352036 => {
11641 let responder = ::fidl_next::Responder::from_untyped(responder);
11642
11643 handler.query_active_configuration(responder).await;
11644 Ok(())
11645
11646 }
11647
11648
11649
11650
11651 485453656005227333 => {
11652 let responder = ::fidl_next::Responder::from_untyped(responder);
11653
11654 handler.query_configuration_last_set_active(responder).await;
11655 Ok(())
11656
11657 }
11658
11659
11660
11661
11662 4648326873156727194 => {
11663 let responder = ::fidl_next::Responder::from_untyped(responder);
11664
11665 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11666 Ok(decoded) => {
11667 handler.query_configuration_status(::fidl_next::Request::from_decoded(decoded), responder).await;
11668 Ok(())
11669 }
11670 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11671 ordinal: 4648326873156727194,
11672 error,
11673 }),
11674 }
11675
11676 }
11677
11678
11679
11680
11681 2880141939131087677 => {
11682 let responder = ::fidl_next::Responder::from_untyped(responder);
11683
11684 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11685 Ok(decoded) => {
11686 handler.query_configuration_status_and_boot_attempts(::fidl_next::Request::from_decoded(decoded), responder).await;
11687 Ok(())
11688 }
11689 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11690 ordinal: 2880141939131087677,
11691 error,
11692 }),
11693 }
11694
11695 }
11696
11697
11698
11699
11700 1496954797270473343 => {
11701 let responder = ::fidl_next::Responder::from_untyped(responder);
11702
11703 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11704 Ok(decoded) => {
11705 handler.set_configuration_active(::fidl_next::Request::from_decoded(decoded), responder).await;
11706 Ok(())
11707 }
11708 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11709 ordinal: 1496954797270473343,
11710 error,
11711 }),
11712 }
11713
11714 }
11715
11716
11717
11718
11719 8036417070472960383 => {
11720 let responder = ::fidl_next::Responder::from_untyped(responder);
11721
11722 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11723 Ok(decoded) => {
11724 handler.set_configuration_unbootable(::fidl_next::Request::from_decoded(decoded), responder).await;
11725 Ok(())
11726 }
11727 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11728 ordinal: 8036417070472960383,
11729 error,
11730 }),
11731 }
11732
11733 }
11734
11735
11736
11737
11738 6772905252297295038 => {
11739 let responder = ::fidl_next::Responder::from_untyped(responder);
11740
11741 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11742 Ok(decoded) => {
11743 handler.set_configuration_healthy(::fidl_next::Request::from_decoded(decoded), responder).await;
11744 Ok(())
11745 }
11746 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11747 ordinal: 6772905252297295038,
11748 error,
11749 }),
11750 }
11751
11752 }
11753
11754
11755
11756
11757 8816623801309917773 => {
11758 let responder = ::fidl_next::Responder::from_untyped(responder);
11759
11760 handler.set_one_shot_recovery(responder).await;
11761 Ok(())
11762
11763 }
11764
11765
11766
11767
11768 3398507029480222014 => {
11769 let responder = ::fidl_next::Responder::from_untyped(responder);
11770
11771 handler.flush(responder).await;
11772 Ok(())
11773
11774 }
11775
11776
11777 ordinal => {
11778
11779 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11780
11781 }
11782 }
11783 }
11784}
11785
11786pub trait BootManagerClientHandler<
11790 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11791 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11792>
11793{
11794}
11795
11796impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for BootManager
11797where
11798 ___H: BootManagerClientHandler<___T> + ::core::marker::Send,
11799 ___T: ::fidl_next::Transport,
11800{
11801 async fn on_event(
11802 handler: &mut ___H,
11803 mut message: ::fidl_next::Message<___T>,
11804 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11805 match *message.header().ordinal {
11806 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11807 }
11808 }
11809}
11810
11811pub trait BootManagerServerHandler<
11815 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11816 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11817>
11818{
11819 #[doc = " Queries the configuration the system is currently running.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the `zvb.current_slot` boot argument cannot be read\n or is an unexpected value.\n"]
11820 fn query_current_configuration(
11821 &mut self,
11822
11823 responder: ::fidl_next::Responder<boot_manager::QueryCurrentConfiguration, ___T>,
11824 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11825
11826 #[doc = " Queries the configuration which will be used as the default boot choice on a normal cold\n boot, which may differ from the currently running configuration. `Configuration::RECOVERY`\n should never be active.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if `Configuration.RECOVERY` is active.\n"]
11827 fn query_active_configuration(
11828 &mut self,
11829
11830 responder: ::fidl_next::Responder<boot_manager::QueryActiveConfiguration, ___T>,
11831 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11832
11833 #[doc = " Queries the configuration that was last explicitly marked as active by\n SetConfigurationActive(). The result is not affected by the current status of the slot.\n\n A newly updated slot is typically marked as active immediately. Therefore this interface\n can be used as a way to identify the newest slot.\n\n Returns `ZX_ERR_IO` if fail to load abr metadata. Returns `ZX_ERR_INTERNAL` if invalid\n slot index is returned by libabr routine.\n"]
11834 fn query_configuration_last_set_active(
11835 &mut self,
11836
11837 responder: ::fidl_next::Responder<boot_manager::QueryConfigurationLastSetActive, ___T>,
11838 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11839
11840 #[doc = " Queries status of `configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11841 fn query_configuration_status(
11842 &mut self,
11843
11844 request: ::fidl_next::Request<boot_manager::QueryConfigurationStatus, ___T>,
11845
11846 responder: ::fidl_next::Responder<boot_manager::QueryConfigurationStatus, ___T>,
11847 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11848
11849 #[doc = " Queries status of `configuration`.\n\n The returned table contains:\n\n * `status`: the current `ConfigurationStatus`\n\n * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of\n times this configuration has attempted to boot, including the current attempt. For any\n other `status` this value will not be provided.\n\n If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates\n the configuration was just set active and has not attempted any boots yet, and\n `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.\n\n * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the\n reported reason for why the configuration is unbootable. For any other `status` this value\n will not be provided.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11850 fn query_configuration_status_and_boot_attempts(
11851 &mut self,
11852
11853 request: ::fidl_next::Request<boot_manager::QueryConfigurationStatusAndBootAttempts, ___T>,
11854
11855 responder: ::fidl_next::Responder<
11856 boot_manager::QueryConfigurationStatusAndBootAttempts,
11857 ___T,
11858 >,
11859 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11860
11861 #[doc = " Updates persistent metadata identifying which configuration should be selected as \'primary\'\n for booting purposes. Should only be called after `KERNEL` as well as optional\n `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.\n\n Also resets the boot attempts count for the given `Configuration`.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11862 fn set_configuration_active(
11863 &mut self,
11864
11865 request: ::fidl_next::Request<boot_manager::SetConfigurationActive, ___T>,
11866
11867 responder: ::fidl_next::Responder<boot_manager::SetConfigurationActive, ___T>,
11868 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11869
11870 #[doc = " Updates persistent metadata identifying whether `configuration` is bootable.\n Should only be called in the following situations:\n * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified\n `configuration` are written.\n * After successfully booting from a new configuration and marking it healthy. This method\n would be then called on the old configuration.\n * After \"successfully\" booting from a new configuration, but encountering an unrecoverable\n error during health check. This method would be then called on the new configuration.\n\n If the configuration is unbootable, no action is taken.\n\n Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.\n"]
11871 fn set_configuration_unbootable(
11872 &mut self,
11873
11874 request: ::fidl_next::Request<boot_manager::SetConfigurationUnbootable, ___T>,
11875
11876 responder: ::fidl_next::Responder<boot_manager::SetConfigurationUnbootable, ___T>,
11877 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11878
11879 #[doc = " Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]\n as successful.\n\n This function is typically used by the OS update system after having\n confirmed that the configuration works as intended and the \"rollback to\n previous slot\" logic is not needed anymore.\n\n Compatibility between the newly successful configuration and the other\n configuration is unknown. Even if the other configuration was\n successful at one point, it may no longer be. This function adds a\n success mark to the given configuration but also removes any success\n mark on the other.\n\n If `configuration` is unbootable or is\n [`fuchsia.paver/Configuration.RECOVERY`], `response` will be\n `ZX_ERR_INVALID_ARGS`.\n\n + request `configuration` the `Configuration` to mark as healthy. Must\n not be `RECOVERY`.\n - response `status` a zx_status value indicating success or failure.\n"]
11880 fn set_configuration_healthy(
11881 &mut self,
11882
11883 request: ::fidl_next::Request<boot_manager::SetConfigurationHealthy, ___T>,
11884
11885 responder: ::fidl_next::Responder<boot_manager::SetConfigurationHealthy, ___T>,
11886 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11887
11888 #[doc = " Force device to boot to recovery in the next reboot/power cycle. This will only be\n triggered once and will be reset after the reboot. State of A/B configuration slot will not\n be affected.\n"]
11889 fn set_one_shot_recovery(
11890 &mut self,
11891
11892 responder: ::fidl_next::Responder<boot_manager::SetOneShotRecovery, ___T>,
11893 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11894
11895 #[doc = " Flush all previously buffered writes to persistent storage.\n"]
11896 fn flush(
11897 &mut self,
11898
11899 responder: ::fidl_next::Responder<boot_manager::Flush, ___T>,
11900 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11901}
11902
11903impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for BootManager
11904where
11905 ___H: BootManagerServerHandler<___T> + ::core::marker::Send,
11906 ___T: ::fidl_next::Transport,
11907
11908
11909
11910
11911
11912
11913
11914
11915 for<'de> crate::wire::BootManagerQueryConfigurationStatusRequest: ::fidl_next::Decode<
11916 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11917 Constraint = (),
11918 >,
11919
11920
11921
11922 for<'de> crate::wire::BootManagerQueryConfigurationStatusAndBootAttemptsRequest: ::fidl_next::Decode<
11923 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11924 Constraint = (),
11925 >,
11926
11927
11928
11929 for<'de> crate::wire::BootManagerSetConfigurationActiveRequest: ::fidl_next::Decode<
11930 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11931 Constraint = (),
11932 >,
11933
11934
11935
11936 for<'de> crate::wire::BootManagerSetConfigurationUnbootableRequest: ::fidl_next::Decode<
11937 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11938 Constraint = (),
11939 >,
11940
11941
11942
11943 for<'de> crate::wire::BootManagerSetConfigurationHealthyRequest: ::fidl_next::Decode<
11944 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11945 Constraint = (),
11946 >,
11947
11948
11949
11950
11951
11952
11953{
11954 async fn on_one_way(
11955 handler: &mut ___H,
11956 mut message: ::fidl_next::Message<___T>,
11957 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>> {
11958 match *message.header().ordinal {
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990 ordinal => {
11991
11992 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11993
11994 }
11995 }
11996 }
11997
11998 async fn on_two_way(
11999 handler: &mut ___H,
12000 mut message: ::fidl_next::Message<___T>,
12001 responder: ::fidl_next::protocol::Responder<___T>,
12002 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>> {
12003 match *message.header().ordinal {
12004
12005
12006
12007 874035434522002289 => {
12008 let responder = ::fidl_next::Responder::from_untyped(responder);
12009
12010 handler.query_current_configuration(responder).await;
12011 Ok(())
12012
12013 }
12014
12015
12016
12017
12018 8202509360402352036 => {
12019 let responder = ::fidl_next::Responder::from_untyped(responder);
12020
12021 handler.query_active_configuration(responder).await;
12022 Ok(())
12023
12024 }
12025
12026
12027
12028
12029 485453656005227333 => {
12030 let responder = ::fidl_next::Responder::from_untyped(responder);
12031
12032 handler.query_configuration_last_set_active(responder).await;
12033 Ok(())
12034
12035 }
12036
12037
12038
12039
12040 4648326873156727194 => {
12041 let responder = ::fidl_next::Responder::from_untyped(responder);
12042
12043 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12044 Ok(decoded) => {
12045 handler.query_configuration_status(::fidl_next::Request::from_decoded(decoded), responder).await;
12046 Ok(())
12047 }
12048 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12049 ordinal: 4648326873156727194,
12050 error,
12051 }),
12052 }
12053
12054 }
12055
12056
12057
12058
12059 2880141939131087677 => {
12060 let responder = ::fidl_next::Responder::from_untyped(responder);
12061
12062 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12063 Ok(decoded) => {
12064 handler.query_configuration_status_and_boot_attempts(::fidl_next::Request::from_decoded(decoded), responder).await;
12065 Ok(())
12066 }
12067 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12068 ordinal: 2880141939131087677,
12069 error,
12070 }),
12071 }
12072
12073 }
12074
12075
12076
12077
12078 1496954797270473343 => {
12079 let responder = ::fidl_next::Responder::from_untyped(responder);
12080
12081 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12082 Ok(decoded) => {
12083 handler.set_configuration_active(::fidl_next::Request::from_decoded(decoded), responder).await;
12084 Ok(())
12085 }
12086 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12087 ordinal: 1496954797270473343,
12088 error,
12089 }),
12090 }
12091
12092 }
12093
12094
12095
12096
12097 8036417070472960383 => {
12098 let responder = ::fidl_next::Responder::from_untyped(responder);
12099
12100 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12101 Ok(decoded) => {
12102 handler.set_configuration_unbootable(::fidl_next::Request::from_decoded(decoded), responder).await;
12103 Ok(())
12104 }
12105 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12106 ordinal: 8036417070472960383,
12107 error,
12108 }),
12109 }
12110
12111 }
12112
12113
12114
12115
12116 6772905252297295038 => {
12117 let responder = ::fidl_next::Responder::from_untyped(responder);
12118
12119 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12120 Ok(decoded) => {
12121 handler.set_configuration_healthy(::fidl_next::Request::from_decoded(decoded), responder).await;
12122 Ok(())
12123 }
12124 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12125 ordinal: 6772905252297295038,
12126 error,
12127 }),
12128 }
12129
12130 }
12131
12132
12133
12134
12135 8816623801309917773 => {
12136 let responder = ::fidl_next::Responder::from_untyped(responder);
12137
12138 handler.set_one_shot_recovery(responder).await;
12139 Ok(())
12140
12141 }
12142
12143
12144
12145
12146 3398507029480222014 => {
12147 let responder = ::fidl_next::Responder::from_untyped(responder);
12148
12149 handler.flush(responder).await;
12150 Ok(())
12151
12152 }
12153
12154
12155 ordinal => {
12156
12157 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12158
12159 }
12160 }
12161 }
12162}
12163
12164impl<___T> BootManagerClientHandler<___T> for ::fidl_next::IgnoreEvents where
12165 ___T: ::fidl_next::Transport
12166{
12167}
12168
12169impl<___H, ___T> BootManagerLocalClientHandler<___T> for ::fidl_next::Local<___H>
12170where
12171 ___H: BootManagerClientHandler<___T>,
12172 ___T: ::fidl_next::Transport,
12173{
12174}
12175
12176impl<___H, ___T> BootManagerLocalServerHandler<___T> for ::fidl_next::Local<___H>
12177where
12178 ___H: BootManagerServerHandler<___T>,
12179 ___T: ::fidl_next::Transport,
12180{
12181 async fn query_current_configuration(
12182 &mut self,
12183
12184 responder: ::fidl_next::Responder<boot_manager::QueryCurrentConfiguration, ___T>,
12185 ) {
12186 ___H::query_current_configuration(&mut self.0, responder).await
12187 }
12188
12189 async fn query_active_configuration(
12190 &mut self,
12191
12192 responder: ::fidl_next::Responder<boot_manager::QueryActiveConfiguration, ___T>,
12193 ) {
12194 ___H::query_active_configuration(&mut self.0, responder).await
12195 }
12196
12197 async fn query_configuration_last_set_active(
12198 &mut self,
12199
12200 responder: ::fidl_next::Responder<boot_manager::QueryConfigurationLastSetActive, ___T>,
12201 ) {
12202 ___H::query_configuration_last_set_active(&mut self.0, responder).await
12203 }
12204
12205 async fn query_configuration_status(
12206 &mut self,
12207
12208 request: ::fidl_next::Request<boot_manager::QueryConfigurationStatus, ___T>,
12209
12210 responder: ::fidl_next::Responder<boot_manager::QueryConfigurationStatus, ___T>,
12211 ) {
12212 ___H::query_configuration_status(&mut self.0, request, responder).await
12213 }
12214
12215 async fn query_configuration_status_and_boot_attempts(
12216 &mut self,
12217
12218 request: ::fidl_next::Request<boot_manager::QueryConfigurationStatusAndBootAttempts, ___T>,
12219
12220 responder: ::fidl_next::Responder<
12221 boot_manager::QueryConfigurationStatusAndBootAttempts,
12222 ___T,
12223 >,
12224 ) {
12225 ___H::query_configuration_status_and_boot_attempts(&mut self.0, request, responder).await
12226 }
12227
12228 async fn set_configuration_active(
12229 &mut self,
12230
12231 request: ::fidl_next::Request<boot_manager::SetConfigurationActive, ___T>,
12232
12233 responder: ::fidl_next::Responder<boot_manager::SetConfigurationActive, ___T>,
12234 ) {
12235 ___H::set_configuration_active(&mut self.0, request, responder).await
12236 }
12237
12238 async fn set_configuration_unbootable(
12239 &mut self,
12240
12241 request: ::fidl_next::Request<boot_manager::SetConfigurationUnbootable, ___T>,
12242
12243 responder: ::fidl_next::Responder<boot_manager::SetConfigurationUnbootable, ___T>,
12244 ) {
12245 ___H::set_configuration_unbootable(&mut self.0, request, responder).await
12246 }
12247
12248 async fn set_configuration_healthy(
12249 &mut self,
12250
12251 request: ::fidl_next::Request<boot_manager::SetConfigurationHealthy, ___T>,
12252
12253 responder: ::fidl_next::Responder<boot_manager::SetConfigurationHealthy, ___T>,
12254 ) {
12255 ___H::set_configuration_healthy(&mut self.0, request, responder).await
12256 }
12257
12258 async fn set_one_shot_recovery(
12259 &mut self,
12260
12261 responder: ::fidl_next::Responder<boot_manager::SetOneShotRecovery, ___T>,
12262 ) {
12263 ___H::set_one_shot_recovery(&mut self.0, responder).await
12264 }
12265
12266 async fn flush(&mut self, responder: ::fidl_next::Responder<boot_manager::Flush, ___T>) {
12267 ___H::flush(&mut self.0, responder).await
12268 }
12269}
12270
12271pub const MAX_FIRMWARE_TYPE_LENGTH: u32 = 256 as u32;
12272
12273#[doc = " The maximum string length for the `partition` name parameter.\n"]
12274pub const MAX_PARTITION_NAME_LENGTH: u32 = 128 as u32;
12275
12276#[doc = " The maximum number of times the firmware will attempt to boot into a `PENDING` configuration.\n\n If the boot attempts are all exhausted without the configuration being updated to `HEALTHY`,\n the configuration will switch to `UNBOOTABLE` which will cause the next boot to fall back to\n the next usable slot.\n\n `HEALTHY` and `UNBOOTABLE` configurations do not count boot attempts; it is assumed that once a\n device is in these states it will remain so until the configuration is manually modified.\n"]
12277pub const MAX_PENDING_BOOT_ATTEMPTS: u8 = 7 as u8;