1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_boot::natural::*;
8
9 #[doc = " Refers to a VMO that has been created from the big bootfs VMO.\n"]
10 #[derive(Debug, PartialEq)]
11 #[repr(C)]
12 pub struct BootfsFileVmo {
13 pub offset: u32,
14
15 pub contents: ::fidl_next::fuchsia::zx::Vmo,
16 }
17
18 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BootfsFileVmo, ___E> for BootfsFileVmo
19 where
20 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
21 ___E: ::fidl_next::fuchsia::HandleEncoder,
22 {
23 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::BootfsFileVmo> = unsafe {
24 ::fidl_next::CopyOptimization::enable_if(
25 true
26
27 && <
28 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
29 >::COPY_OPTIMIZATION.is_enabled()
30
31 && <
32 ::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>
33 >::COPY_OPTIMIZATION.is_enabled()
34
35 )
36 };
37
38 #[inline]
39 fn encode(
40 self,
41 encoder_: &mut ___E,
42 out_: &mut ::core::mem::MaybeUninit<crate::wire::BootfsFileVmo>,
43 _: (),
44 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
45 ::fidl_next::munge! {
46 let crate::wire::BootfsFileVmo {
47 offset,
48 contents,
49
50 } = out_;
51 }
52
53 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
54
55 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
56
57 ::fidl_next::Encode::encode(self.contents, encoder_, contents, ())?;
58
59 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(contents.as_mut_ptr()) };
60
61 Ok(())
62 }
63 }
64
65 unsafe impl<___E>
66 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::BootfsFileVmo>, ___E>
67 for BootfsFileVmo
68 where
69 ___E: ::fidl_next::Encoder + ?Sized,
70 BootfsFileVmo: ::fidl_next::Encode<crate::wire::BootfsFileVmo, ___E>,
71 {
72 #[inline]
73 fn encode_option(
74 this: ::core::option::Option<Self>,
75 encoder: &mut ___E,
76 out: &mut ::core::mem::MaybeUninit<
77 ::fidl_next::wire::Box<'static, crate::wire::BootfsFileVmo>,
78 >,
79 _: (),
80 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
81 if let Some(inner) = this {
82 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
83 ::fidl_next::wire::Box::encode_present(out);
84 } else {
85 ::fidl_next::wire::Box::encode_absent(out);
86 }
87
88 Ok(())
89 }
90 }
91
92 impl ::fidl_next::FromWire<crate::wire::BootfsFileVmo> for BootfsFileVmo {
93 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::BootfsFileVmo, Self> = unsafe {
94 ::fidl_next::CopyOptimization::enable_if(
95 true
96 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
97 .is_enabled()
98 && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
99 ::fidl_next::wire::fuchsia::Vmo,
100 >>::COPY_OPTIMIZATION
101 .is_enabled(),
102 )
103 };
104
105 #[inline]
106 fn from_wire(wire: crate::wire::BootfsFileVmo) -> Self {
107 Self {
108 offset: ::fidl_next::FromWire::from_wire(wire.offset),
109
110 contents: ::fidl_next::FromWire::from_wire(wire.contents),
111 }
112 }
113 }
114
115 #[derive(Debug, PartialEq)]
116 #[repr(C)]
117 pub struct FactoryItemsGetResponse {
118 pub payload: ::core::option::Option<::fidl_next::fuchsia::zx::Vmo>,
119
120 pub length: u32,
121 }
122
123 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FactoryItemsGetResponse, ___E>
124 for FactoryItemsGetResponse
125 where
126 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
127 ___E: ::fidl_next::fuchsia::HandleEncoder,
128 {
129 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
130 Self,
131 crate::wire::FactoryItemsGetResponse,
132 > = unsafe {
133 ::fidl_next::CopyOptimization::enable_if(
134 true
135
136 && <
137 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>
138 >::COPY_OPTIMIZATION.is_enabled()
139
140 && <
141 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
142 >::COPY_OPTIMIZATION.is_enabled()
143
144 )
145 };
146
147 #[inline]
148 fn encode(
149 self,
150 encoder_: &mut ___E,
151 out_: &mut ::core::mem::MaybeUninit<crate::wire::FactoryItemsGetResponse>,
152 _: (),
153 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
154 ::fidl_next::munge! {
155 let crate::wire::FactoryItemsGetResponse {
156 payload,
157 length,
158
159 } = out_;
160 }
161
162 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
163
164 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(payload.as_mut_ptr()) };
165
166 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
167
168 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
169
170 Ok(())
171 }
172 }
173
174 unsafe impl<___E>
175 ::fidl_next::EncodeOption<
176 ::fidl_next::wire::Box<'static, crate::wire::FactoryItemsGetResponse>,
177 ___E,
178 > for FactoryItemsGetResponse
179 where
180 ___E: ::fidl_next::Encoder + ?Sized,
181 FactoryItemsGetResponse: ::fidl_next::Encode<crate::wire::FactoryItemsGetResponse, ___E>,
182 {
183 #[inline]
184 fn encode_option(
185 this: ::core::option::Option<Self>,
186 encoder: &mut ___E,
187 out: &mut ::core::mem::MaybeUninit<
188 ::fidl_next::wire::Box<'static, crate::wire::FactoryItemsGetResponse>,
189 >,
190 _: (),
191 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
192 if let Some(inner) = this {
193 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
194 ::fidl_next::wire::Box::encode_present(out);
195 } else {
196 ::fidl_next::wire::Box::encode_absent(out);
197 }
198
199 Ok(())
200 }
201 }
202
203 impl ::fidl_next::FromWire<crate::wire::FactoryItemsGetResponse> for FactoryItemsGetResponse {
204 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
205 crate::wire::FactoryItemsGetResponse,
206 Self,
207 > = unsafe {
208 ::fidl_next::CopyOptimization::enable_if(
209 true
210
211 && <
212 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalVmo>
213 >::COPY_OPTIMIZATION.is_enabled()
214
215 && <
216 u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>
217 >::COPY_OPTIMIZATION.is_enabled()
218
219 )
220 };
221
222 #[inline]
223 fn from_wire(wire: crate::wire::FactoryItemsGetResponse) -> Self {
224 Self {
225 payload: ::fidl_next::FromWire::from_wire(wire.payload),
226
227 length: ::fidl_next::FromWire::from_wire(wire.length),
228 }
229 }
230 }
231
232 #[derive(Debug, PartialEq)]
233 #[repr(C)]
234 pub struct ItemsGetResponse {
235 pub payload: ::core::option::Option<::fidl_next::fuchsia::zx::Vmo>,
236
237 pub length: u32,
238 }
239
240 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ItemsGetResponse, ___E> for ItemsGetResponse
241 where
242 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
243 ___E: ::fidl_next::fuchsia::HandleEncoder,
244 {
245 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
246 Self,
247 crate::wire::ItemsGetResponse,
248 > = unsafe {
249 ::fidl_next::CopyOptimization::enable_if(
250 true
251
252 && <
253 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>
254 >::COPY_OPTIMIZATION.is_enabled()
255
256 && <
257 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
258 >::COPY_OPTIMIZATION.is_enabled()
259
260 )
261 };
262
263 #[inline]
264 fn encode(
265 self,
266 encoder_: &mut ___E,
267 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGetResponse>,
268 _: (),
269 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
270 ::fidl_next::munge! {
271 let crate::wire::ItemsGetResponse {
272 payload,
273 length,
274
275 } = out_;
276 }
277
278 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
279
280 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(payload.as_mut_ptr()) };
281
282 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
283
284 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
285
286 Ok(())
287 }
288 }
289
290 unsafe impl<___E>
291 ::fidl_next::EncodeOption<
292 ::fidl_next::wire::Box<'static, crate::wire::ItemsGetResponse>,
293 ___E,
294 > for ItemsGetResponse
295 where
296 ___E: ::fidl_next::Encoder + ?Sized,
297 ItemsGetResponse: ::fidl_next::Encode<crate::wire::ItemsGetResponse, ___E>,
298 {
299 #[inline]
300 fn encode_option(
301 this: ::core::option::Option<Self>,
302 encoder: &mut ___E,
303 out: &mut ::core::mem::MaybeUninit<
304 ::fidl_next::wire::Box<'static, crate::wire::ItemsGetResponse>,
305 >,
306 _: (),
307 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
308 if let Some(inner) = this {
309 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
310 ::fidl_next::wire::Box::encode_present(out);
311 } else {
312 ::fidl_next::wire::Box::encode_absent(out);
313 }
314
315 Ok(())
316 }
317 }
318
319 impl ::fidl_next::FromWire<crate::wire::ItemsGetResponse> for ItemsGetResponse {
320 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
321 crate::wire::ItemsGetResponse,
322 Self,
323 > = unsafe {
324 ::fidl_next::CopyOptimization::enable_if(
325 true
326
327 && <
328 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalVmo>
329 >::COPY_OPTIMIZATION.is_enabled()
330
331 && <
332 u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>
333 >::COPY_OPTIMIZATION.is_enabled()
334
335 )
336 };
337
338 #[inline]
339 fn from_wire(wire: crate::wire::ItemsGetResponse) -> Self {
340 Self {
341 payload: ::fidl_next::FromWire::from_wire(wire.payload),
342
343 length: ::fidl_next::FromWire::from_wire(wire.length),
344 }
345 }
346 }
347
348 #[derive(Debug, PartialEq)]
349 #[repr(C)]
350 pub struct RetrievedItems {
351 pub payload: ::fidl_next::fuchsia::zx::Vmo,
352
353 pub length: u32,
354
355 pub extra: u32,
356 }
357
358 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RetrievedItems, ___E> for RetrievedItems
359 where
360 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
361 ___E: ::fidl_next::fuchsia::HandleEncoder,
362 {
363 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::RetrievedItems> = unsafe {
364 ::fidl_next::CopyOptimization::enable_if(
365 true
366
367 && <
368 ::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>
369 >::COPY_OPTIMIZATION.is_enabled()
370
371 && <
372 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
373 >::COPY_OPTIMIZATION.is_enabled()
374
375 && <
376 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
377 >::COPY_OPTIMIZATION.is_enabled()
378
379 )
380 };
381
382 #[inline]
383 fn encode(
384 self,
385 encoder_: &mut ___E,
386 out_: &mut ::core::mem::MaybeUninit<crate::wire::RetrievedItems>,
387 _: (),
388 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
389 ::fidl_next::munge! {
390 let crate::wire::RetrievedItems {
391 payload,
392 length,
393 extra,
394
395 } = out_;
396 }
397
398 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
399
400 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(payload.as_mut_ptr()) };
401
402 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
403
404 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
405
406 ::fidl_next::Encode::encode(self.extra, encoder_, extra, ())?;
407
408 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(extra.as_mut_ptr()) };
409
410 Ok(())
411 }
412 }
413
414 unsafe impl<___E>
415 ::fidl_next::EncodeOption<
416 ::fidl_next::wire::Box<'static, crate::wire::RetrievedItems>,
417 ___E,
418 > for RetrievedItems
419 where
420 ___E: ::fidl_next::Encoder + ?Sized,
421 RetrievedItems: ::fidl_next::Encode<crate::wire::RetrievedItems, ___E>,
422 {
423 #[inline]
424 fn encode_option(
425 this: ::core::option::Option<Self>,
426 encoder: &mut ___E,
427 out: &mut ::core::mem::MaybeUninit<
428 ::fidl_next::wire::Box<'static, crate::wire::RetrievedItems>,
429 >,
430 _: (),
431 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
432 if let Some(inner) = this {
433 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
434 ::fidl_next::wire::Box::encode_present(out);
435 } else {
436 ::fidl_next::wire::Box::encode_absent(out);
437 }
438
439 Ok(())
440 }
441 }
442
443 impl ::fidl_next::FromWire<crate::wire::RetrievedItems> for RetrievedItems {
444 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::RetrievedItems, Self> = unsafe {
445 ::fidl_next::CopyOptimization::enable_if(
446 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
447 ::fidl_next::wire::fuchsia::Vmo,
448 >>::COPY_OPTIMIZATION
449 .is_enabled()
450 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
451 .is_enabled()
452 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
453 .is_enabled(),
454 )
455 };
456
457 #[inline]
458 fn from_wire(wire: crate::wire::RetrievedItems) -> Self {
459 Self {
460 payload: ::fidl_next::FromWire::from_wire(wire.payload),
461
462 length: ::fidl_next::FromWire::from_wire(wire.length),
463
464 extra: ::fidl_next::FromWire::from_wire(wire.extra),
465 }
466 }
467 }
468
469 #[derive(Debug, PartialEq)]
470 pub struct ItemsGet2Response {
471 pub retrieved_items: ::std::vec::Vec<crate::natural::RetrievedItems>,
472 }
473
474 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ItemsGet2Response<'static>, ___E>
475 for ItemsGet2Response
476 where
477 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
478 ___E: ::fidl_next::Encoder,
479 ___E: ::fidl_next::fuchsia::HandleEncoder,
480 {
481 #[inline]
482 fn encode(
483 self,
484 encoder_: &mut ___E,
485 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGet2Response<'static>>,
486 _: (),
487 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
488 ::fidl_next::munge! {
489 let crate::wire::ItemsGet2Response {
490 retrieved_items,
491
492 } = out_;
493 }
494
495 ::fidl_next::Encode::encode(
496 self.retrieved_items,
497 encoder_,
498 retrieved_items,
499 (4294967295, ()),
500 )?;
501
502 let mut _field =
503 unsafe { ::fidl_next::Slot::new_unchecked(retrieved_items.as_mut_ptr()) };
504 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
505
506 Ok(())
507 }
508 }
509
510 unsafe impl<___E>
511 ::fidl_next::EncodeOption<
512 ::fidl_next::wire::Box<'static, crate::wire::ItemsGet2Response<'static>>,
513 ___E,
514 > for ItemsGet2Response
515 where
516 ___E: ::fidl_next::Encoder + ?Sized,
517 ItemsGet2Response: ::fidl_next::Encode<crate::wire::ItemsGet2Response<'static>, ___E>,
518 {
519 #[inline]
520 fn encode_option(
521 this: ::core::option::Option<Self>,
522 encoder: &mut ___E,
523 out: &mut ::core::mem::MaybeUninit<
524 ::fidl_next::wire::Box<'static, crate::wire::ItemsGet2Response<'static>>,
525 >,
526 _: (),
527 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
528 if let Some(inner) = this {
529 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
530 ::fidl_next::wire::Box::encode_present(out);
531 } else {
532 ::fidl_next::wire::Box::encode_absent(out);
533 }
534
535 Ok(())
536 }
537 }
538
539 impl<'de> ::fidl_next::FromWire<crate::wire::ItemsGet2Response<'de>> for ItemsGet2Response {
540 #[inline]
541 fn from_wire(wire: crate::wire::ItemsGet2Response<'de>) -> Self {
542 Self { retrieved_items: ::fidl_next::FromWire::from_wire(wire.retrieved_items) }
543 }
544 }
545
546 #[derive(Debug, PartialEq)]
547 #[repr(C)]
548 pub struct ItemsGetBootloaderFileResponse {
549 pub payload: ::core::option::Option<::fidl_next::fuchsia::zx::Vmo>,
550 }
551
552 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ItemsGetBootloaderFileResponse, ___E>
553 for ItemsGetBootloaderFileResponse
554 where
555 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
556 ___E: ::fidl_next::fuchsia::HandleEncoder,
557 {
558 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
559 Self,
560 crate::wire::ItemsGetBootloaderFileResponse,
561 > = unsafe {
562 ::fidl_next::CopyOptimization::enable_if(
563 true
564
565 && <
566 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>
567 >::COPY_OPTIMIZATION.is_enabled()
568
569 )
570 };
571
572 #[inline]
573 fn encode(
574 self,
575 encoder_: &mut ___E,
576 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGetBootloaderFileResponse>,
577 _: (),
578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
579 ::fidl_next::munge! {
580 let crate::wire::ItemsGetBootloaderFileResponse {
581 payload,
582
583 } = out_;
584 }
585
586 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
587
588 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(payload.as_mut_ptr()) };
589
590 Ok(())
591 }
592 }
593
594 unsafe impl<___E>
595 ::fidl_next::EncodeOption<
596 ::fidl_next::wire::Box<'static, crate::wire::ItemsGetBootloaderFileResponse>,
597 ___E,
598 > for ItemsGetBootloaderFileResponse
599 where
600 ___E: ::fidl_next::Encoder + ?Sized,
601 ItemsGetBootloaderFileResponse:
602 ::fidl_next::Encode<crate::wire::ItemsGetBootloaderFileResponse, ___E>,
603 {
604 #[inline]
605 fn encode_option(
606 this: ::core::option::Option<Self>,
607 encoder: &mut ___E,
608 out: &mut ::core::mem::MaybeUninit<
609 ::fidl_next::wire::Box<'static, crate::wire::ItemsGetBootloaderFileResponse>,
610 >,
611 _: (),
612 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
613 if let Some(inner) = this {
614 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
615 ::fidl_next::wire::Box::encode_present(out);
616 } else {
617 ::fidl_next::wire::Box::encode_absent(out);
618 }
619
620 Ok(())
621 }
622 }
623
624 impl ::fidl_next::FromWire<crate::wire::ItemsGetBootloaderFileResponse>
625 for ItemsGetBootloaderFileResponse
626 {
627 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
628 crate::wire::ItemsGetBootloaderFileResponse,
629 Self,
630 > = unsafe {
631 ::fidl_next::CopyOptimization::enable_if(
632 true
633
634 && <
635 ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalVmo>
636 >::COPY_OPTIMIZATION.is_enabled()
637
638 )
639 };
640
641 #[inline]
642 fn from_wire(wire: crate::wire::ItemsGetBootloaderFileResponse) -> Self {
643 Self { payload: ::fidl_next::FromWire::from_wire(wire.payload) }
644 }
645 }
646
647 #[derive(Debug, PartialEq)]
648 #[repr(C)]
649 pub struct ReadOnlyLogGetResponse {
650 pub log: ::fidl_next::fuchsia::zx::DebugLog,
651 }
652
653 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadOnlyLogGetResponse, ___E>
654 for ReadOnlyLogGetResponse
655 where
656 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
657 ___E: ::fidl_next::fuchsia::HandleEncoder,
658 {
659 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
660 Self,
661 crate::wire::ReadOnlyLogGetResponse,
662 > = unsafe {
663 ::fidl_next::CopyOptimization::enable_if(
664 true && <::fidl_next::fuchsia::zx::DebugLog as ::fidl_next::Encode<
665 ::fidl_next::wire::fuchsia::DebugLog,
666 ___E,
667 >>::COPY_OPTIMIZATION
668 .is_enabled(),
669 )
670 };
671
672 #[inline]
673 fn encode(
674 self,
675 encoder_: &mut ___E,
676 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadOnlyLogGetResponse>,
677 _: (),
678 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
679 ::fidl_next::munge! {
680 let crate::wire::ReadOnlyLogGetResponse {
681 log,
682
683 } = out_;
684 }
685
686 ::fidl_next::Encode::encode(self.log, encoder_, log, ())?;
687
688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(log.as_mut_ptr()) };
689
690 Ok(())
691 }
692 }
693
694 unsafe impl<___E>
695 ::fidl_next::EncodeOption<
696 ::fidl_next::wire::Box<'static, crate::wire::ReadOnlyLogGetResponse>,
697 ___E,
698 > for ReadOnlyLogGetResponse
699 where
700 ___E: ::fidl_next::Encoder + ?Sized,
701 ReadOnlyLogGetResponse: ::fidl_next::Encode<crate::wire::ReadOnlyLogGetResponse, ___E>,
702 {
703 #[inline]
704 fn encode_option(
705 this: ::core::option::Option<Self>,
706 encoder: &mut ___E,
707 out: &mut ::core::mem::MaybeUninit<
708 ::fidl_next::wire::Box<'static, crate::wire::ReadOnlyLogGetResponse>,
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::ReadOnlyLogGetResponse> for ReadOnlyLogGetResponse {
724 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
725 crate::wire::ReadOnlyLogGetResponse,
726 Self,
727 > = unsafe {
728 ::fidl_next::CopyOptimization::enable_if(
729 true && <::fidl_next::fuchsia::zx::DebugLog as ::fidl_next::FromWire<
730 ::fidl_next::wire::fuchsia::DebugLog,
731 >>::COPY_OPTIMIZATION
732 .is_enabled(),
733 )
734 };
735
736 #[inline]
737 fn from_wire(wire: crate::wire::ReadOnlyLogGetResponse) -> Self {
738 Self { log: ::fidl_next::FromWire::from_wire(wire.log) }
739 }
740 }
741
742 #[derive(Debug, PartialEq)]
743 #[repr(C)]
744 pub struct SvcStashStoreRequest {
745 pub svc_endpoint: ::fidl_next::ServerEnd<
746 ::fidl_next_fuchsia_io::Directory,
747 ::fidl_next::fuchsia::zx::Channel,
748 >,
749 }
750
751 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SvcStashStoreRequest, ___E>
752 for SvcStashStoreRequest
753 where
754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
755 ___E: ::fidl_next::fuchsia::HandleEncoder,
756 {
757 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
758 Self,
759 crate::wire::SvcStashStoreRequest,
760 > = unsafe {
761 ::fidl_next::CopyOptimization::enable_if(
762 true && <::fidl_next::ServerEnd<
763 ::fidl_next_fuchsia_io::Directory,
764 ::fidl_next::fuchsia::zx::Channel,
765 > as ::fidl_next::Encode<
766 ::fidl_next::ServerEnd<
767 ::fidl_next_fuchsia_io::Directory,
768 ::fidl_next::wire::fuchsia::Channel,
769 >,
770 ___E,
771 >>::COPY_OPTIMIZATION
772 .is_enabled(),
773 )
774 };
775
776 #[inline]
777 fn encode(
778 self,
779 encoder_: &mut ___E,
780 out_: &mut ::core::mem::MaybeUninit<crate::wire::SvcStashStoreRequest>,
781 _: (),
782 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
783 ::fidl_next::munge! {
784 let crate::wire::SvcStashStoreRequest {
785 svc_endpoint,
786
787 } = out_;
788 }
789
790 ::fidl_next::Encode::encode(self.svc_endpoint, encoder_, svc_endpoint, ())?;
791
792 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(svc_endpoint.as_mut_ptr()) };
793
794 Ok(())
795 }
796 }
797
798 unsafe impl<___E>
799 ::fidl_next::EncodeOption<
800 ::fidl_next::wire::Box<'static, crate::wire::SvcStashStoreRequest>,
801 ___E,
802 > for SvcStashStoreRequest
803 where
804 ___E: ::fidl_next::Encoder + ?Sized,
805 SvcStashStoreRequest: ::fidl_next::Encode<crate::wire::SvcStashStoreRequest, ___E>,
806 {
807 #[inline]
808 fn encode_option(
809 this: ::core::option::Option<Self>,
810 encoder: &mut ___E,
811 out: &mut ::core::mem::MaybeUninit<
812 ::fidl_next::wire::Box<'static, crate::wire::SvcStashStoreRequest>,
813 >,
814 _: (),
815 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
816 if let Some(inner) = this {
817 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
818 ::fidl_next::wire::Box::encode_present(out);
819 } else {
820 ::fidl_next::wire::Box::encode_absent(out);
821 }
822
823 Ok(())
824 }
825 }
826
827 impl ::fidl_next::FromWire<crate::wire::SvcStashStoreRequest> for SvcStashStoreRequest {
828 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
829 crate::wire::SvcStashStoreRequest,
830 Self,
831 > = unsafe {
832 ::fidl_next::CopyOptimization::enable_if(
833 true && <::fidl_next::ServerEnd<
834 ::fidl_next_fuchsia_io::Directory,
835 ::fidl_next::fuchsia::zx::Channel,
836 > as ::fidl_next::FromWire<
837 ::fidl_next::ServerEnd<
838 ::fidl_next_fuchsia_io::Directory,
839 ::fidl_next::wire::fuchsia::Channel,
840 >,
841 >>::COPY_OPTIMIZATION
842 .is_enabled(),
843 )
844 };
845
846 #[inline]
847 fn from_wire(wire: crate::wire::SvcStashStoreRequest) -> Self {
848 Self { svc_endpoint: ::fidl_next::FromWire::from_wire(wire.svc_endpoint) }
849 }
850 }
851
852 #[derive(Debug, PartialEq)]
853 #[repr(C)]
854 pub struct SvcStashProviderGetResponse {
855 pub resource: ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::fuchsia::zx::Channel>,
856 }
857
858 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SvcStashProviderGetResponse, ___E>
859 for SvcStashProviderGetResponse
860 where
861 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
862 ___E: ::fidl_next::fuchsia::HandleEncoder,
863 {
864 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
865 Self,
866 crate::wire::SvcStashProviderGetResponse,
867 > = unsafe {
868 ::fidl_next::CopyOptimization::enable_if(
869 true
870
871 && <
872 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>, ___E>
873 >::COPY_OPTIMIZATION.is_enabled()
874
875 )
876 };
877
878 #[inline]
879 fn encode(
880 self,
881 encoder_: &mut ___E,
882 out_: &mut ::core::mem::MaybeUninit<crate::wire::SvcStashProviderGetResponse>,
883 _: (),
884 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
885 ::fidl_next::munge! {
886 let crate::wire::SvcStashProviderGetResponse {
887 resource,
888
889 } = out_;
890 }
891
892 ::fidl_next::Encode::encode(self.resource, encoder_, resource, ())?;
893
894 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(resource.as_mut_ptr()) };
895
896 Ok(())
897 }
898 }
899
900 unsafe impl<___E>
901 ::fidl_next::EncodeOption<
902 ::fidl_next::wire::Box<'static, crate::wire::SvcStashProviderGetResponse>,
903 ___E,
904 > for SvcStashProviderGetResponse
905 where
906 ___E: ::fidl_next::Encoder + ?Sized,
907 SvcStashProviderGetResponse:
908 ::fidl_next::Encode<crate::wire::SvcStashProviderGetResponse, ___E>,
909 {
910 #[inline]
911 fn encode_option(
912 this: ::core::option::Option<Self>,
913 encoder: &mut ___E,
914 out: &mut ::core::mem::MaybeUninit<
915 ::fidl_next::wire::Box<'static, crate::wire::SvcStashProviderGetResponse>,
916 >,
917 _: (),
918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
919 if let Some(inner) = this {
920 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
921 ::fidl_next::wire::Box::encode_present(out);
922 } else {
923 ::fidl_next::wire::Box::encode_absent(out);
924 }
925
926 Ok(())
927 }
928 }
929
930 impl ::fidl_next::FromWire<crate::wire::SvcStashProviderGetResponse>
931 for SvcStashProviderGetResponse
932 {
933 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
934 crate::wire::SvcStashProviderGetResponse,
935 Self,
936 > = unsafe {
937 ::fidl_next::CopyOptimization::enable_if(
938 true
939
940 && <
941 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>>
942 >::COPY_OPTIMIZATION.is_enabled()
943
944 )
945 };
946
947 #[inline]
948 fn from_wire(wire: crate::wire::SvcStashProviderGetResponse) -> Self {
949 Self { resource: ::fidl_next::FromWire::from_wire(wire.resource) }
950 }
951 }
952
953 #[derive(Debug, PartialEq)]
954 pub struct UserbootPostBootfsFilesRequest {
955 pub files: ::std::vec::Vec<crate::natural::BootfsFileVmo>,
956 }
957
958 unsafe impl<___E>
959 ::fidl_next::Encode<crate::wire::UserbootPostBootfsFilesRequest<'static>, ___E>
960 for UserbootPostBootfsFilesRequest
961 where
962 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
963 ___E: ::fidl_next::Encoder,
964 ___E: ::fidl_next::fuchsia::HandleEncoder,
965 {
966 #[inline]
967 fn encode(
968 self,
969 encoder_: &mut ___E,
970 out_: &mut ::core::mem::MaybeUninit<
971 crate::wire::UserbootPostBootfsFilesRequest<'static>,
972 >,
973 _: (),
974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
975 ::fidl_next::munge! {
976 let crate::wire::UserbootPostBootfsFilesRequest {
977 files,
978
979 } = out_;
980 }
981
982 ::fidl_next::Encode::encode(self.files, encoder_, files, (64, ()))?;
983
984 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(files.as_mut_ptr()) };
985 ::fidl_next::Constrained::validate(_field, (64, ()))?;
986
987 Ok(())
988 }
989 }
990
991 unsafe impl<___E>
992 ::fidl_next::EncodeOption<
993 ::fidl_next::wire::Box<'static, crate::wire::UserbootPostBootfsFilesRequest<'static>>,
994 ___E,
995 > for UserbootPostBootfsFilesRequest
996 where
997 ___E: ::fidl_next::Encoder + ?Sized,
998 UserbootPostBootfsFilesRequest:
999 ::fidl_next::Encode<crate::wire::UserbootPostBootfsFilesRequest<'static>, ___E>,
1000 {
1001 #[inline]
1002 fn encode_option(
1003 this: ::core::option::Option<Self>,
1004 encoder: &mut ___E,
1005 out: &mut ::core::mem::MaybeUninit<
1006 ::fidl_next::wire::Box<
1007 'static,
1008 crate::wire::UserbootPostBootfsFilesRequest<'static>,
1009 >,
1010 >,
1011 _: (),
1012 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1013 if let Some(inner) = this {
1014 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1015 ::fidl_next::wire::Box::encode_present(out);
1016 } else {
1017 ::fidl_next::wire::Box::encode_absent(out);
1018 }
1019
1020 Ok(())
1021 }
1022 }
1023
1024 impl<'de> ::fidl_next::FromWire<crate::wire::UserbootPostBootfsFilesRequest<'de>>
1025 for UserbootPostBootfsFilesRequest
1026 {
1027 #[inline]
1028 fn from_wire(wire: crate::wire::UserbootPostBootfsFilesRequest<'de>) -> Self {
1029 Self { files: ::fidl_next::FromWire::from_wire(wire.files) }
1030 }
1031 }
1032
1033 #[derive(Debug, PartialEq)]
1034 #[repr(C)]
1035 pub struct UserbootPostStashSvcRequest {
1036 pub stash_svc_endpoint:
1037 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::fuchsia::zx::Channel>,
1038 }
1039
1040 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UserbootPostStashSvcRequest, ___E>
1041 for UserbootPostStashSvcRequest
1042 where
1043 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1044 ___E: ::fidl_next::fuchsia::HandleEncoder,
1045 {
1046 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1047 Self,
1048 crate::wire::UserbootPostStashSvcRequest,
1049 > = unsafe {
1050 ::fidl_next::CopyOptimization::enable_if(
1051 true
1052
1053 && <
1054 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>, ___E>
1055 >::COPY_OPTIMIZATION.is_enabled()
1056
1057 )
1058 };
1059
1060 #[inline]
1061 fn encode(
1062 self,
1063 encoder_: &mut ___E,
1064 out_: &mut ::core::mem::MaybeUninit<crate::wire::UserbootPostStashSvcRequest>,
1065 _: (),
1066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1067 ::fidl_next::munge! {
1068 let crate::wire::UserbootPostStashSvcRequest {
1069 stash_svc_endpoint,
1070
1071 } = out_;
1072 }
1073
1074 ::fidl_next::Encode::encode(self.stash_svc_endpoint, encoder_, stash_svc_endpoint, ())?;
1075
1076 let mut _field =
1077 unsafe { ::fidl_next::Slot::new_unchecked(stash_svc_endpoint.as_mut_ptr()) };
1078
1079 Ok(())
1080 }
1081 }
1082
1083 unsafe impl<___E>
1084 ::fidl_next::EncodeOption<
1085 ::fidl_next::wire::Box<'static, crate::wire::UserbootPostStashSvcRequest>,
1086 ___E,
1087 > for UserbootPostStashSvcRequest
1088 where
1089 ___E: ::fidl_next::Encoder + ?Sized,
1090 UserbootPostStashSvcRequest:
1091 ::fidl_next::Encode<crate::wire::UserbootPostStashSvcRequest, ___E>,
1092 {
1093 #[inline]
1094 fn encode_option(
1095 this: ::core::option::Option<Self>,
1096 encoder: &mut ___E,
1097 out: &mut ::core::mem::MaybeUninit<
1098 ::fidl_next::wire::Box<'static, crate::wire::UserbootPostStashSvcRequest>,
1099 >,
1100 _: (),
1101 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1102 if let Some(inner) = this {
1103 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1104 ::fidl_next::wire::Box::encode_present(out);
1105 } else {
1106 ::fidl_next::wire::Box::encode_absent(out);
1107 }
1108
1109 Ok(())
1110 }
1111 }
1112
1113 impl ::fidl_next::FromWire<crate::wire::UserbootPostStashSvcRequest>
1114 for UserbootPostStashSvcRequest
1115 {
1116 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1117 crate::wire::UserbootPostStashSvcRequest,
1118 Self,
1119 > = unsafe {
1120 ::fidl_next::CopyOptimization::enable_if(
1121 true
1122
1123 && <
1124 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>>
1125 >::COPY_OPTIMIZATION.is_enabled()
1126
1127 )
1128 };
1129
1130 #[inline]
1131 fn from_wire(wire: crate::wire::UserbootPostStashSvcRequest) -> Self {
1132 Self { stash_svc_endpoint: ::fidl_next::FromWire::from_wire(wire.stash_svc_endpoint) }
1133 }
1134 }
1135
1136 #[derive(Debug, PartialEq)]
1137 #[repr(C)]
1138 pub struct WriteOnlyLogGetResponse {
1139 pub log: ::fidl_next::fuchsia::zx::DebugLog,
1140 }
1141
1142 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WriteOnlyLogGetResponse, ___E>
1143 for WriteOnlyLogGetResponse
1144 where
1145 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1146 ___E: ::fidl_next::fuchsia::HandleEncoder,
1147 {
1148 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1149 Self,
1150 crate::wire::WriteOnlyLogGetResponse,
1151 > = unsafe {
1152 ::fidl_next::CopyOptimization::enable_if(
1153 true && <::fidl_next::fuchsia::zx::DebugLog as ::fidl_next::Encode<
1154 ::fidl_next::wire::fuchsia::DebugLog,
1155 ___E,
1156 >>::COPY_OPTIMIZATION
1157 .is_enabled(),
1158 )
1159 };
1160
1161 #[inline]
1162 fn encode(
1163 self,
1164 encoder_: &mut ___E,
1165 out_: &mut ::core::mem::MaybeUninit<crate::wire::WriteOnlyLogGetResponse>,
1166 _: (),
1167 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1168 ::fidl_next::munge! {
1169 let crate::wire::WriteOnlyLogGetResponse {
1170 log,
1171
1172 } = out_;
1173 }
1174
1175 ::fidl_next::Encode::encode(self.log, encoder_, log, ())?;
1176
1177 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(log.as_mut_ptr()) };
1178
1179 Ok(())
1180 }
1181 }
1182
1183 unsafe impl<___E>
1184 ::fidl_next::EncodeOption<
1185 ::fidl_next::wire::Box<'static, crate::wire::WriteOnlyLogGetResponse>,
1186 ___E,
1187 > for WriteOnlyLogGetResponse
1188 where
1189 ___E: ::fidl_next::Encoder + ?Sized,
1190 WriteOnlyLogGetResponse: ::fidl_next::Encode<crate::wire::WriteOnlyLogGetResponse, ___E>,
1191 {
1192 #[inline]
1193 fn encode_option(
1194 this: ::core::option::Option<Self>,
1195 encoder: &mut ___E,
1196 out: &mut ::core::mem::MaybeUninit<
1197 ::fidl_next::wire::Box<'static, crate::wire::WriteOnlyLogGetResponse>,
1198 >,
1199 _: (),
1200 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1201 if let Some(inner) = this {
1202 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1203 ::fidl_next::wire::Box::encode_present(out);
1204 } else {
1205 ::fidl_next::wire::Box::encode_absent(out);
1206 }
1207
1208 Ok(())
1209 }
1210 }
1211
1212 impl ::fidl_next::FromWire<crate::wire::WriteOnlyLogGetResponse> for WriteOnlyLogGetResponse {
1213 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1214 crate::wire::WriteOnlyLogGetResponse,
1215 Self,
1216 > = unsafe {
1217 ::fidl_next::CopyOptimization::enable_if(
1218 true && <::fidl_next::fuchsia::zx::DebugLog as ::fidl_next::FromWire<
1219 ::fidl_next::wire::fuchsia::DebugLog,
1220 >>::COPY_OPTIMIZATION
1221 .is_enabled(),
1222 )
1223 };
1224
1225 #[inline]
1226 fn from_wire(wire: crate::wire::WriteOnlyLogGetResponse) -> Self {
1227 Self { log: ::fidl_next::FromWire::from_wire(wire.log) }
1228 }
1229 }
1230}
1231
1232pub mod wire {
1233
1234 pub use fidl_next_common_fuchsia_boot::wire::*;
1235
1236 #[derive(Debug)]
1238 #[repr(C)]
1239 pub struct BootfsFileVmo {
1240 pub offset: ::fidl_next::wire::Uint32,
1241
1242 pub contents: ::fidl_next::wire::fuchsia::Vmo,
1243 }
1244
1245 static_assertions::const_assert_eq!(std::mem::size_of::<BootfsFileVmo>(), 8);
1246 static_assertions::const_assert_eq!(std::mem::align_of::<BootfsFileVmo>(), 4);
1247
1248 static_assertions::const_assert_eq!(std::mem::offset_of!(BootfsFileVmo, offset), 0);
1249
1250 static_assertions::const_assert_eq!(std::mem::offset_of!(BootfsFileVmo, contents), 4);
1251
1252 impl ::fidl_next::Constrained for BootfsFileVmo {
1253 type Constraint = ();
1254
1255 fn validate(
1256 _: ::fidl_next::Slot<'_, Self>,
1257 _: Self::Constraint,
1258 ) -> Result<(), ::fidl_next::ValidationError> {
1259 Ok(())
1260 }
1261 }
1262
1263 unsafe impl ::fidl_next::Wire for BootfsFileVmo {
1264 type Narrowed<'de> = BootfsFileVmo;
1265
1266 #[inline]
1267 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1268 ::fidl_next::munge! {
1269 let Self {
1270 offset,
1271 contents,
1272
1273 } = &mut *out_;
1274 }
1275
1276 ::fidl_next::Wire::zero_padding(offset);
1277
1278 ::fidl_next::Wire::zero_padding(contents);
1279 }
1280 }
1281
1282 unsafe impl<___D> ::fidl_next::Decode<___D> for BootfsFileVmo
1283 where
1284 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1285 ___D: ::fidl_next::fuchsia::HandleDecoder,
1286 {
1287 fn decode(
1288 slot_: ::fidl_next::Slot<'_, Self>,
1289 decoder_: &mut ___D,
1290 _: (),
1291 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1292 ::fidl_next::munge! {
1293 let Self {
1294 mut offset,
1295 mut contents,
1296
1297 } = slot_;
1298 }
1299
1300 let _field = offset.as_mut();
1301
1302 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
1303
1304 let _field = contents.as_mut();
1305
1306 ::fidl_next::Decode::decode(contents.as_mut(), decoder_, ())?;
1307
1308 Ok(())
1309 }
1310 }
1311
1312 impl ::fidl_next::IntoNatural for BootfsFileVmo {
1313 type Natural = crate::natural::BootfsFileVmo;
1314 }
1315
1316 #[derive(Debug)]
1318 #[repr(C)]
1319 pub struct FactoryItemsGetResponse {
1320 pub payload: ::fidl_next::wire::fuchsia::OptionalVmo,
1321
1322 pub length: ::fidl_next::wire::Uint32,
1323 }
1324
1325 static_assertions::const_assert_eq!(std::mem::size_of::<FactoryItemsGetResponse>(), 8);
1326 static_assertions::const_assert_eq!(std::mem::align_of::<FactoryItemsGetResponse>(), 4);
1327
1328 static_assertions::const_assert_eq!(std::mem::offset_of!(FactoryItemsGetResponse, payload), 0);
1329
1330 static_assertions::const_assert_eq!(std::mem::offset_of!(FactoryItemsGetResponse, length), 4);
1331
1332 impl ::fidl_next::Constrained for FactoryItemsGetResponse {
1333 type Constraint = ();
1334
1335 fn validate(
1336 _: ::fidl_next::Slot<'_, Self>,
1337 _: Self::Constraint,
1338 ) -> Result<(), ::fidl_next::ValidationError> {
1339 Ok(())
1340 }
1341 }
1342
1343 unsafe impl ::fidl_next::Wire for FactoryItemsGetResponse {
1344 type Narrowed<'de> = FactoryItemsGetResponse;
1345
1346 #[inline]
1347 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1348 ::fidl_next::munge! {
1349 let Self {
1350 payload,
1351 length,
1352
1353 } = &mut *out_;
1354 }
1355
1356 ::fidl_next::Wire::zero_padding(payload);
1357
1358 ::fidl_next::Wire::zero_padding(length);
1359 }
1360 }
1361
1362 unsafe impl<___D> ::fidl_next::Decode<___D> for FactoryItemsGetResponse
1363 where
1364 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1365 ___D: ::fidl_next::fuchsia::HandleDecoder,
1366 {
1367 fn decode(
1368 slot_: ::fidl_next::Slot<'_, Self>,
1369 decoder_: &mut ___D,
1370 _: (),
1371 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1372 ::fidl_next::munge! {
1373 let Self {
1374 mut payload,
1375 mut length,
1376
1377 } = slot_;
1378 }
1379
1380 let _field = payload.as_mut();
1381
1382 ::fidl_next::Decode::decode(payload.as_mut(), decoder_, ())?;
1383
1384 let _field = length.as_mut();
1385
1386 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
1387
1388 Ok(())
1389 }
1390 }
1391
1392 impl ::fidl_next::IntoNatural for FactoryItemsGetResponse {
1393 type Natural = crate::natural::FactoryItemsGetResponse;
1394 }
1395
1396 #[derive(Debug)]
1398 #[repr(C)]
1399 pub struct ItemsGetResponse {
1400 pub payload: ::fidl_next::wire::fuchsia::OptionalVmo,
1401
1402 pub length: ::fidl_next::wire::Uint32,
1403 }
1404
1405 static_assertions::const_assert_eq!(std::mem::size_of::<ItemsGetResponse>(), 8);
1406 static_assertions::const_assert_eq!(std::mem::align_of::<ItemsGetResponse>(), 4);
1407
1408 static_assertions::const_assert_eq!(std::mem::offset_of!(ItemsGetResponse, payload), 0);
1409
1410 static_assertions::const_assert_eq!(std::mem::offset_of!(ItemsGetResponse, length), 4);
1411
1412 impl ::fidl_next::Constrained for ItemsGetResponse {
1413 type Constraint = ();
1414
1415 fn validate(
1416 _: ::fidl_next::Slot<'_, Self>,
1417 _: Self::Constraint,
1418 ) -> Result<(), ::fidl_next::ValidationError> {
1419 Ok(())
1420 }
1421 }
1422
1423 unsafe impl ::fidl_next::Wire for ItemsGetResponse {
1424 type Narrowed<'de> = ItemsGetResponse;
1425
1426 #[inline]
1427 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1428 ::fidl_next::munge! {
1429 let Self {
1430 payload,
1431 length,
1432
1433 } = &mut *out_;
1434 }
1435
1436 ::fidl_next::Wire::zero_padding(payload);
1437
1438 ::fidl_next::Wire::zero_padding(length);
1439 }
1440 }
1441
1442 unsafe impl<___D> ::fidl_next::Decode<___D> for ItemsGetResponse
1443 where
1444 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1445 ___D: ::fidl_next::fuchsia::HandleDecoder,
1446 {
1447 fn decode(
1448 slot_: ::fidl_next::Slot<'_, Self>,
1449 decoder_: &mut ___D,
1450 _: (),
1451 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1452 ::fidl_next::munge! {
1453 let Self {
1454 mut payload,
1455 mut length,
1456
1457 } = slot_;
1458 }
1459
1460 let _field = payload.as_mut();
1461
1462 ::fidl_next::Decode::decode(payload.as_mut(), decoder_, ())?;
1463
1464 let _field = length.as_mut();
1465
1466 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
1467
1468 Ok(())
1469 }
1470 }
1471
1472 impl ::fidl_next::IntoNatural for ItemsGetResponse {
1473 type Natural = crate::natural::ItemsGetResponse;
1474 }
1475
1476 #[derive(Debug)]
1478 #[repr(C)]
1479 pub struct RetrievedItems {
1480 pub payload: ::fidl_next::wire::fuchsia::Vmo,
1481
1482 pub length: ::fidl_next::wire::Uint32,
1483
1484 pub extra: ::fidl_next::wire::Uint32,
1485 }
1486
1487 static_assertions::const_assert_eq!(std::mem::size_of::<RetrievedItems>(), 12);
1488 static_assertions::const_assert_eq!(std::mem::align_of::<RetrievedItems>(), 4);
1489
1490 static_assertions::const_assert_eq!(std::mem::offset_of!(RetrievedItems, payload), 0);
1491
1492 static_assertions::const_assert_eq!(std::mem::offset_of!(RetrievedItems, length), 4);
1493
1494 static_assertions::const_assert_eq!(std::mem::offset_of!(RetrievedItems, extra), 8);
1495
1496 impl ::fidl_next::Constrained for RetrievedItems {
1497 type Constraint = ();
1498
1499 fn validate(
1500 _: ::fidl_next::Slot<'_, Self>,
1501 _: Self::Constraint,
1502 ) -> Result<(), ::fidl_next::ValidationError> {
1503 Ok(())
1504 }
1505 }
1506
1507 unsafe impl ::fidl_next::Wire for RetrievedItems {
1508 type Narrowed<'de> = RetrievedItems;
1509
1510 #[inline]
1511 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1512 ::fidl_next::munge! {
1513 let Self {
1514 payload,
1515 length,
1516 extra,
1517
1518 } = &mut *out_;
1519 }
1520
1521 ::fidl_next::Wire::zero_padding(payload);
1522
1523 ::fidl_next::Wire::zero_padding(length);
1524
1525 ::fidl_next::Wire::zero_padding(extra);
1526 }
1527 }
1528
1529 unsafe impl<___D> ::fidl_next::Decode<___D> for RetrievedItems
1530 where
1531 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1532 ___D: ::fidl_next::fuchsia::HandleDecoder,
1533 {
1534 fn decode(
1535 slot_: ::fidl_next::Slot<'_, Self>,
1536 decoder_: &mut ___D,
1537 _: (),
1538 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1539 ::fidl_next::munge! {
1540 let Self {
1541 mut payload,
1542 mut length,
1543 mut extra,
1544
1545 } = slot_;
1546 }
1547
1548 let _field = payload.as_mut();
1549
1550 ::fidl_next::Decode::decode(payload.as_mut(), decoder_, ())?;
1551
1552 let _field = length.as_mut();
1553
1554 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
1555
1556 let _field = extra.as_mut();
1557
1558 ::fidl_next::Decode::decode(extra.as_mut(), decoder_, ())?;
1559
1560 Ok(())
1561 }
1562 }
1563
1564 impl ::fidl_next::IntoNatural for RetrievedItems {
1565 type Natural = crate::natural::RetrievedItems;
1566 }
1567
1568 #[derive(Debug)]
1570 #[repr(C)]
1571 pub struct ItemsGet2Response<'de> {
1572 pub retrieved_items: ::fidl_next::wire::Vector<'de, crate::wire::RetrievedItems>,
1573 }
1574
1575 static_assertions::const_assert_eq!(std::mem::size_of::<ItemsGet2Response<'_>>(), 16);
1576 static_assertions::const_assert_eq!(std::mem::align_of::<ItemsGet2Response<'_>>(), 8);
1577
1578 static_assertions::const_assert_eq!(
1579 std::mem::offset_of!(ItemsGet2Response<'_>, retrieved_items),
1580 0
1581 );
1582
1583 impl ::fidl_next::Constrained for ItemsGet2Response<'_> {
1584 type Constraint = ();
1585
1586 fn validate(
1587 _: ::fidl_next::Slot<'_, Self>,
1588 _: Self::Constraint,
1589 ) -> Result<(), ::fidl_next::ValidationError> {
1590 Ok(())
1591 }
1592 }
1593
1594 unsafe impl ::fidl_next::Wire for ItemsGet2Response<'static> {
1595 type Narrowed<'de> = ItemsGet2Response<'de>;
1596
1597 #[inline]
1598 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1599 ::fidl_next::munge! {
1600 let Self {
1601 retrieved_items,
1602
1603 } = &mut *out_;
1604 }
1605
1606 ::fidl_next::Wire::zero_padding(retrieved_items);
1607 }
1608 }
1609
1610 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ItemsGet2Response<'de>
1611 where
1612 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1613 ___D: ::fidl_next::Decoder<'de>,
1614 ___D: ::fidl_next::fuchsia::HandleDecoder,
1615 {
1616 fn decode(
1617 slot_: ::fidl_next::Slot<'_, Self>,
1618 decoder_: &mut ___D,
1619 _: (),
1620 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1621 ::fidl_next::munge! {
1622 let Self {
1623 mut retrieved_items,
1624
1625 } = slot_;
1626 }
1627
1628 let _field = retrieved_items.as_mut();
1629 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1630 ::fidl_next::Decode::decode(retrieved_items.as_mut(), decoder_, (4294967295, ()))?;
1631
1632 Ok(())
1633 }
1634 }
1635
1636 impl<'de> ::fidl_next::IntoNatural for ItemsGet2Response<'de> {
1637 type Natural = crate::natural::ItemsGet2Response;
1638 }
1639
1640 #[derive(Debug)]
1642 #[repr(C)]
1643 pub struct ItemsGetBootloaderFileResponse {
1644 pub payload: ::fidl_next::wire::fuchsia::OptionalVmo,
1645 }
1646
1647 static_assertions::const_assert_eq!(std::mem::size_of::<ItemsGetBootloaderFileResponse>(), 4);
1648 static_assertions::const_assert_eq!(std::mem::align_of::<ItemsGetBootloaderFileResponse>(), 4);
1649
1650 static_assertions::const_assert_eq!(
1651 std::mem::offset_of!(ItemsGetBootloaderFileResponse, payload),
1652 0
1653 );
1654
1655 impl ::fidl_next::Constrained for ItemsGetBootloaderFileResponse {
1656 type Constraint = ();
1657
1658 fn validate(
1659 _: ::fidl_next::Slot<'_, Self>,
1660 _: Self::Constraint,
1661 ) -> Result<(), ::fidl_next::ValidationError> {
1662 Ok(())
1663 }
1664 }
1665
1666 unsafe impl ::fidl_next::Wire for ItemsGetBootloaderFileResponse {
1667 type Narrowed<'de> = ItemsGetBootloaderFileResponse;
1668
1669 #[inline]
1670 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1671 ::fidl_next::munge! {
1672 let Self {
1673 payload,
1674
1675 } = &mut *out_;
1676 }
1677
1678 ::fidl_next::Wire::zero_padding(payload);
1679 }
1680 }
1681
1682 unsafe impl<___D> ::fidl_next::Decode<___D> for ItemsGetBootloaderFileResponse
1683 where
1684 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1685 ___D: ::fidl_next::fuchsia::HandleDecoder,
1686 {
1687 fn decode(
1688 slot_: ::fidl_next::Slot<'_, Self>,
1689 decoder_: &mut ___D,
1690 _: (),
1691 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1692 ::fidl_next::munge! {
1693 let Self {
1694 mut payload,
1695
1696 } = slot_;
1697 }
1698
1699 let _field = payload.as_mut();
1700
1701 ::fidl_next::Decode::decode(payload.as_mut(), decoder_, ())?;
1702
1703 Ok(())
1704 }
1705 }
1706
1707 impl ::fidl_next::IntoNatural for ItemsGetBootloaderFileResponse {
1708 type Natural = crate::natural::ItemsGetBootloaderFileResponse;
1709 }
1710
1711 #[derive(Debug)]
1713 #[repr(C)]
1714 pub struct ReadOnlyLogGetResponse {
1715 pub log: ::fidl_next::wire::fuchsia::DebugLog,
1716 }
1717
1718 static_assertions::const_assert_eq!(std::mem::size_of::<ReadOnlyLogGetResponse>(), 4);
1719 static_assertions::const_assert_eq!(std::mem::align_of::<ReadOnlyLogGetResponse>(), 4);
1720
1721 static_assertions::const_assert_eq!(std::mem::offset_of!(ReadOnlyLogGetResponse, log), 0);
1722
1723 impl ::fidl_next::Constrained for ReadOnlyLogGetResponse {
1724 type Constraint = ();
1725
1726 fn validate(
1727 _: ::fidl_next::Slot<'_, Self>,
1728 _: Self::Constraint,
1729 ) -> Result<(), ::fidl_next::ValidationError> {
1730 Ok(())
1731 }
1732 }
1733
1734 unsafe impl ::fidl_next::Wire for ReadOnlyLogGetResponse {
1735 type Narrowed<'de> = ReadOnlyLogGetResponse;
1736
1737 #[inline]
1738 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1739 ::fidl_next::munge! {
1740 let Self {
1741 log,
1742
1743 } = &mut *out_;
1744 }
1745
1746 ::fidl_next::Wire::zero_padding(log);
1747 }
1748 }
1749
1750 unsafe impl<___D> ::fidl_next::Decode<___D> for ReadOnlyLogGetResponse
1751 where
1752 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1753 ___D: ::fidl_next::fuchsia::HandleDecoder,
1754 {
1755 fn decode(
1756 slot_: ::fidl_next::Slot<'_, Self>,
1757 decoder_: &mut ___D,
1758 _: (),
1759 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1760 ::fidl_next::munge! {
1761 let Self {
1762 mut log,
1763
1764 } = slot_;
1765 }
1766
1767 let _field = log.as_mut();
1768
1769 ::fidl_next::Decode::decode(log.as_mut(), decoder_, ())?;
1770
1771 Ok(())
1772 }
1773 }
1774
1775 impl ::fidl_next::IntoNatural for ReadOnlyLogGetResponse {
1776 type Natural = crate::natural::ReadOnlyLogGetResponse;
1777 }
1778
1779 #[derive(Debug)]
1781 #[repr(C)]
1782 pub struct SvcStashStoreRequest {
1783 pub svc_endpoint: ::fidl_next::ServerEnd<
1784 ::fidl_next_fuchsia_io::Directory,
1785 ::fidl_next::wire::fuchsia::Channel,
1786 >,
1787 }
1788
1789 static_assertions::const_assert_eq!(std::mem::size_of::<SvcStashStoreRequest>(), 4);
1790 static_assertions::const_assert_eq!(std::mem::align_of::<SvcStashStoreRequest>(), 4);
1791
1792 static_assertions::const_assert_eq!(
1793 std::mem::offset_of!(SvcStashStoreRequest, svc_endpoint),
1794 0
1795 );
1796
1797 impl ::fidl_next::Constrained for SvcStashStoreRequest {
1798 type Constraint = ();
1799
1800 fn validate(
1801 _: ::fidl_next::Slot<'_, Self>,
1802 _: Self::Constraint,
1803 ) -> Result<(), ::fidl_next::ValidationError> {
1804 Ok(())
1805 }
1806 }
1807
1808 unsafe impl ::fidl_next::Wire for SvcStashStoreRequest {
1809 type Narrowed<'de> = SvcStashStoreRequest;
1810
1811 #[inline]
1812 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1813 ::fidl_next::munge! {
1814 let Self {
1815 svc_endpoint,
1816
1817 } = &mut *out_;
1818 }
1819
1820 ::fidl_next::Wire::zero_padding(svc_endpoint);
1821 }
1822 }
1823
1824 unsafe impl<___D> ::fidl_next::Decode<___D> for SvcStashStoreRequest
1825 where
1826 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1827 ___D: ::fidl_next::fuchsia::HandleDecoder,
1828 {
1829 fn decode(
1830 slot_: ::fidl_next::Slot<'_, Self>,
1831 decoder_: &mut ___D,
1832 _: (),
1833 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1834 ::fidl_next::munge! {
1835 let Self {
1836 mut svc_endpoint,
1837
1838 } = slot_;
1839 }
1840
1841 let _field = svc_endpoint.as_mut();
1842
1843 ::fidl_next::Decode::decode(svc_endpoint.as_mut(), decoder_, ())?;
1844
1845 Ok(())
1846 }
1847 }
1848
1849 impl ::fidl_next::IntoNatural for SvcStashStoreRequest {
1850 type Natural = crate::natural::SvcStashStoreRequest;
1851 }
1852
1853 #[derive(Debug)]
1855 #[repr(C)]
1856 pub struct SvcStashProviderGetResponse {
1857 pub resource: ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>,
1858 }
1859
1860 static_assertions::const_assert_eq!(std::mem::size_of::<SvcStashProviderGetResponse>(), 4);
1861 static_assertions::const_assert_eq!(std::mem::align_of::<SvcStashProviderGetResponse>(), 4);
1862
1863 static_assertions::const_assert_eq!(
1864 std::mem::offset_of!(SvcStashProviderGetResponse, resource),
1865 0
1866 );
1867
1868 impl ::fidl_next::Constrained for SvcStashProviderGetResponse {
1869 type Constraint = ();
1870
1871 fn validate(
1872 _: ::fidl_next::Slot<'_, Self>,
1873 _: Self::Constraint,
1874 ) -> Result<(), ::fidl_next::ValidationError> {
1875 Ok(())
1876 }
1877 }
1878
1879 unsafe impl ::fidl_next::Wire for SvcStashProviderGetResponse {
1880 type Narrowed<'de> = SvcStashProviderGetResponse;
1881
1882 #[inline]
1883 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1884 ::fidl_next::munge! {
1885 let Self {
1886 resource,
1887
1888 } = &mut *out_;
1889 }
1890
1891 ::fidl_next::Wire::zero_padding(resource);
1892 }
1893 }
1894
1895 unsafe impl<___D> ::fidl_next::Decode<___D> for SvcStashProviderGetResponse
1896 where
1897 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1898 ___D: ::fidl_next::fuchsia::HandleDecoder,
1899 {
1900 fn decode(
1901 slot_: ::fidl_next::Slot<'_, Self>,
1902 decoder_: &mut ___D,
1903 _: (),
1904 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1905 ::fidl_next::munge! {
1906 let Self {
1907 mut resource,
1908
1909 } = slot_;
1910 }
1911
1912 let _field = resource.as_mut();
1913
1914 ::fidl_next::Decode::decode(resource.as_mut(), decoder_, ())?;
1915
1916 Ok(())
1917 }
1918 }
1919
1920 impl ::fidl_next::IntoNatural for SvcStashProviderGetResponse {
1921 type Natural = crate::natural::SvcStashProviderGetResponse;
1922 }
1923
1924 #[derive(Debug)]
1926 #[repr(C)]
1927 pub struct UserbootPostBootfsFilesRequest<'de> {
1928 pub files: ::fidl_next::wire::Vector<'de, crate::wire::BootfsFileVmo>,
1929 }
1930
1931 static_assertions::const_assert_eq!(
1932 std::mem::size_of::<UserbootPostBootfsFilesRequest<'_>>(),
1933 16
1934 );
1935 static_assertions::const_assert_eq!(
1936 std::mem::align_of::<UserbootPostBootfsFilesRequest<'_>>(),
1937 8
1938 );
1939
1940 static_assertions::const_assert_eq!(
1941 std::mem::offset_of!(UserbootPostBootfsFilesRequest<'_>, files),
1942 0
1943 );
1944
1945 impl ::fidl_next::Constrained for UserbootPostBootfsFilesRequest<'_> {
1946 type Constraint = ();
1947
1948 fn validate(
1949 _: ::fidl_next::Slot<'_, Self>,
1950 _: Self::Constraint,
1951 ) -> Result<(), ::fidl_next::ValidationError> {
1952 Ok(())
1953 }
1954 }
1955
1956 unsafe impl ::fidl_next::Wire for UserbootPostBootfsFilesRequest<'static> {
1957 type Narrowed<'de> = UserbootPostBootfsFilesRequest<'de>;
1958
1959 #[inline]
1960 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1961 ::fidl_next::munge! {
1962 let Self {
1963 files,
1964
1965 } = &mut *out_;
1966 }
1967
1968 ::fidl_next::Wire::zero_padding(files);
1969 }
1970 }
1971
1972 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UserbootPostBootfsFilesRequest<'de>
1973 where
1974 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1975 ___D: ::fidl_next::Decoder<'de>,
1976 ___D: ::fidl_next::fuchsia::HandleDecoder,
1977 {
1978 fn decode(
1979 slot_: ::fidl_next::Slot<'_, Self>,
1980 decoder_: &mut ___D,
1981 _: (),
1982 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1983 ::fidl_next::munge! {
1984 let Self {
1985 mut files,
1986
1987 } = slot_;
1988 }
1989
1990 let _field = files.as_mut();
1991 ::fidl_next::Constrained::validate(_field, (64, ()))?;
1992 ::fidl_next::Decode::decode(files.as_mut(), decoder_, (64, ()))?;
1993
1994 let files = unsafe { files.deref_unchecked() };
1995
1996 if files.len() > 64 {
1997 return Err(::fidl_next::DecodeError::VectorTooLong {
1998 size: files.len() as u64,
1999 limit: 64,
2000 });
2001 }
2002
2003 Ok(())
2004 }
2005 }
2006
2007 impl<'de> ::fidl_next::IntoNatural for UserbootPostBootfsFilesRequest<'de> {
2008 type Natural = crate::natural::UserbootPostBootfsFilesRequest;
2009 }
2010
2011 #[derive(Debug)]
2013 #[repr(C)]
2014 pub struct UserbootPostStashSvcRequest {
2015 pub stash_svc_endpoint:
2016 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>,
2017 }
2018
2019 static_assertions::const_assert_eq!(std::mem::size_of::<UserbootPostStashSvcRequest>(), 4);
2020 static_assertions::const_assert_eq!(std::mem::align_of::<UserbootPostStashSvcRequest>(), 4);
2021
2022 static_assertions::const_assert_eq!(
2023 std::mem::offset_of!(UserbootPostStashSvcRequest, stash_svc_endpoint),
2024 0
2025 );
2026
2027 impl ::fidl_next::Constrained for UserbootPostStashSvcRequest {
2028 type Constraint = ();
2029
2030 fn validate(
2031 _: ::fidl_next::Slot<'_, Self>,
2032 _: Self::Constraint,
2033 ) -> Result<(), ::fidl_next::ValidationError> {
2034 Ok(())
2035 }
2036 }
2037
2038 unsafe impl ::fidl_next::Wire for UserbootPostStashSvcRequest {
2039 type Narrowed<'de> = UserbootPostStashSvcRequest;
2040
2041 #[inline]
2042 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2043 ::fidl_next::munge! {
2044 let Self {
2045 stash_svc_endpoint,
2046
2047 } = &mut *out_;
2048 }
2049
2050 ::fidl_next::Wire::zero_padding(stash_svc_endpoint);
2051 }
2052 }
2053
2054 unsafe impl<___D> ::fidl_next::Decode<___D> for UserbootPostStashSvcRequest
2055 where
2056 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2057 ___D: ::fidl_next::fuchsia::HandleDecoder,
2058 {
2059 fn decode(
2060 slot_: ::fidl_next::Slot<'_, Self>,
2061 decoder_: &mut ___D,
2062 _: (),
2063 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2064 ::fidl_next::munge! {
2065 let Self {
2066 mut stash_svc_endpoint,
2067
2068 } = slot_;
2069 }
2070
2071 let _field = stash_svc_endpoint.as_mut();
2072
2073 ::fidl_next::Decode::decode(stash_svc_endpoint.as_mut(), decoder_, ())?;
2074
2075 Ok(())
2076 }
2077 }
2078
2079 impl ::fidl_next::IntoNatural for UserbootPostStashSvcRequest {
2080 type Natural = crate::natural::UserbootPostStashSvcRequest;
2081 }
2082
2083 #[derive(Debug)]
2085 #[repr(C)]
2086 pub struct WriteOnlyLogGetResponse {
2087 pub log: ::fidl_next::wire::fuchsia::DebugLog,
2088 }
2089
2090 static_assertions::const_assert_eq!(std::mem::size_of::<WriteOnlyLogGetResponse>(), 4);
2091 static_assertions::const_assert_eq!(std::mem::align_of::<WriteOnlyLogGetResponse>(), 4);
2092
2093 static_assertions::const_assert_eq!(std::mem::offset_of!(WriteOnlyLogGetResponse, log), 0);
2094
2095 impl ::fidl_next::Constrained for WriteOnlyLogGetResponse {
2096 type Constraint = ();
2097
2098 fn validate(
2099 _: ::fidl_next::Slot<'_, Self>,
2100 _: Self::Constraint,
2101 ) -> Result<(), ::fidl_next::ValidationError> {
2102 Ok(())
2103 }
2104 }
2105
2106 unsafe impl ::fidl_next::Wire for WriteOnlyLogGetResponse {
2107 type Narrowed<'de> = WriteOnlyLogGetResponse;
2108
2109 #[inline]
2110 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2111 ::fidl_next::munge! {
2112 let Self {
2113 log,
2114
2115 } = &mut *out_;
2116 }
2117
2118 ::fidl_next::Wire::zero_padding(log);
2119 }
2120 }
2121
2122 unsafe impl<___D> ::fidl_next::Decode<___D> for WriteOnlyLogGetResponse
2123 where
2124 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2125 ___D: ::fidl_next::fuchsia::HandleDecoder,
2126 {
2127 fn decode(
2128 slot_: ::fidl_next::Slot<'_, Self>,
2129 decoder_: &mut ___D,
2130 _: (),
2131 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2132 ::fidl_next::munge! {
2133 let Self {
2134 mut log,
2135
2136 } = slot_;
2137 }
2138
2139 let _field = log.as_mut();
2140
2141 ::fidl_next::Decode::decode(log.as_mut(), decoder_, ())?;
2142
2143 Ok(())
2144 }
2145 }
2146
2147 impl ::fidl_next::IntoNatural for WriteOnlyLogGetResponse {
2148 type Natural = crate::natural::WriteOnlyLogGetResponse;
2149 }
2150}
2151
2152pub mod wire_optional {
2153
2154 pub use fidl_next_common_fuchsia_boot::wire_optional::*;
2155}
2156
2157pub mod generic {
2158
2159 pub use fidl_next_common_fuchsia_boot::generic::*;
2160
2161 pub struct BootfsFileVmo<T0, T1> {
2163 pub offset: T0,
2164
2165 pub contents: T1,
2166 }
2167
2168 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::BootfsFileVmo, ___E>
2169 for BootfsFileVmo<T0, T1>
2170 where
2171 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2172 ___E: ::fidl_next::fuchsia::HandleEncoder,
2173 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2174 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2175 {
2176 #[inline]
2177 fn encode(
2178 self,
2179 encoder_: &mut ___E,
2180 out_: &mut ::core::mem::MaybeUninit<crate::wire::BootfsFileVmo>,
2181 _: (),
2182 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2183 ::fidl_next::munge! {
2184 let crate::wire::BootfsFileVmo {
2185 offset,
2186 contents,
2187
2188 } = out_;
2189 }
2190
2191 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
2192
2193 ::fidl_next::Encode::encode(self.contents, encoder_, contents, ())?;
2194
2195 Ok(())
2196 }
2197 }
2198
2199 pub struct FactoryItemsGetResponse<T0, T1> {
2201 pub payload: T0,
2202
2203 pub length: T1,
2204 }
2205
2206 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FactoryItemsGetResponse, ___E>
2207 for FactoryItemsGetResponse<T0, T1>
2208 where
2209 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2210 ___E: ::fidl_next::fuchsia::HandleEncoder,
2211 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>,
2212 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2213 {
2214 #[inline]
2215 fn encode(
2216 self,
2217 encoder_: &mut ___E,
2218 out_: &mut ::core::mem::MaybeUninit<crate::wire::FactoryItemsGetResponse>,
2219 _: (),
2220 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2221 ::fidl_next::munge! {
2222 let crate::wire::FactoryItemsGetResponse {
2223 payload,
2224 length,
2225
2226 } = out_;
2227 }
2228
2229 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
2230
2231 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
2232
2233 Ok(())
2234 }
2235 }
2236
2237 pub struct ItemsGetResponse<T0, T1> {
2239 pub payload: T0,
2240
2241 pub length: T1,
2242 }
2243
2244 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ItemsGetResponse, ___E>
2245 for ItemsGetResponse<T0, T1>
2246 where
2247 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2248 ___E: ::fidl_next::fuchsia::HandleEncoder,
2249 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>,
2250 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2251 {
2252 #[inline]
2253 fn encode(
2254 self,
2255 encoder_: &mut ___E,
2256 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGetResponse>,
2257 _: (),
2258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2259 ::fidl_next::munge! {
2260 let crate::wire::ItemsGetResponse {
2261 payload,
2262 length,
2263
2264 } = out_;
2265 }
2266
2267 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
2268
2269 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
2270
2271 Ok(())
2272 }
2273 }
2274
2275 pub struct RetrievedItems<T0, T1, T2> {
2277 pub payload: T0,
2278
2279 pub length: T1,
2280
2281 pub extra: T2,
2282 }
2283
2284 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::RetrievedItems, ___E>
2285 for RetrievedItems<T0, T1, T2>
2286 where
2287 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2288 ___E: ::fidl_next::fuchsia::HandleEncoder,
2289 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
2290 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2291 T2: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
2292 {
2293 #[inline]
2294 fn encode(
2295 self,
2296 encoder_: &mut ___E,
2297 out_: &mut ::core::mem::MaybeUninit<crate::wire::RetrievedItems>,
2298 _: (),
2299 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2300 ::fidl_next::munge! {
2301 let crate::wire::RetrievedItems {
2302 payload,
2303 length,
2304 extra,
2305
2306 } = out_;
2307 }
2308
2309 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
2310
2311 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
2312
2313 ::fidl_next::Encode::encode(self.extra, encoder_, extra, ())?;
2314
2315 Ok(())
2316 }
2317 }
2318
2319 pub struct ItemsGet2Response<T0> {
2321 pub retrieved_items: T0,
2322 }
2323
2324 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ItemsGet2Response<'static>, ___E>
2325 for ItemsGet2Response<T0>
2326 where
2327 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2328 ___E: ::fidl_next::Encoder,
2329 ___E: ::fidl_next::fuchsia::HandleEncoder,
2330 T0: ::fidl_next::Encode<
2331 ::fidl_next::wire::Vector<'static, crate::wire::RetrievedItems>,
2332 ___E,
2333 >,
2334 {
2335 #[inline]
2336 fn encode(
2337 self,
2338 encoder_: &mut ___E,
2339 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGet2Response<'static>>,
2340 _: (),
2341 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2342 ::fidl_next::munge! {
2343 let crate::wire::ItemsGet2Response {
2344 retrieved_items,
2345
2346 } = out_;
2347 }
2348
2349 ::fidl_next::Encode::encode(
2350 self.retrieved_items,
2351 encoder_,
2352 retrieved_items,
2353 (4294967295, ()),
2354 )?;
2355
2356 Ok(())
2357 }
2358 }
2359
2360 pub struct ItemsGetBootloaderFileResponse<T0> {
2362 pub payload: T0,
2363 }
2364
2365 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ItemsGetBootloaderFileResponse, ___E>
2366 for ItemsGetBootloaderFileResponse<T0>
2367 where
2368 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2369 ___E: ::fidl_next::fuchsia::HandleEncoder,
2370 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalVmo, ___E>,
2371 {
2372 #[inline]
2373 fn encode(
2374 self,
2375 encoder_: &mut ___E,
2376 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGetBootloaderFileResponse>,
2377 _: (),
2378 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2379 ::fidl_next::munge! {
2380 let crate::wire::ItemsGetBootloaderFileResponse {
2381 payload,
2382
2383 } = out_;
2384 }
2385
2386 ::fidl_next::Encode::encode(self.payload, encoder_, payload, ())?;
2387
2388 Ok(())
2389 }
2390 }
2391
2392 pub struct ReadOnlyLogGetResponse<T0> {
2394 pub log: T0,
2395 }
2396
2397 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadOnlyLogGetResponse, ___E>
2398 for ReadOnlyLogGetResponse<T0>
2399 where
2400 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2401 ___E: ::fidl_next::fuchsia::HandleEncoder,
2402 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::DebugLog, ___E>,
2403 {
2404 #[inline]
2405 fn encode(
2406 self,
2407 encoder_: &mut ___E,
2408 out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadOnlyLogGetResponse>,
2409 _: (),
2410 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2411 ::fidl_next::munge! {
2412 let crate::wire::ReadOnlyLogGetResponse {
2413 log,
2414
2415 } = out_;
2416 }
2417
2418 ::fidl_next::Encode::encode(self.log, encoder_, log, ())?;
2419
2420 Ok(())
2421 }
2422 }
2423
2424 pub struct SvcStashStoreRequest<T0> {
2426 pub svc_endpoint: T0,
2427 }
2428
2429 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SvcStashStoreRequest, ___E>
2430 for SvcStashStoreRequest<T0>
2431 where
2432 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2433 ___E: ::fidl_next::fuchsia::HandleEncoder,
2434 T0: ::fidl_next::Encode<
2435 ::fidl_next::ServerEnd<
2436 ::fidl_next_fuchsia_io::Directory,
2437 ::fidl_next::wire::fuchsia::Channel,
2438 >,
2439 ___E,
2440 >,
2441 {
2442 #[inline]
2443 fn encode(
2444 self,
2445 encoder_: &mut ___E,
2446 out_: &mut ::core::mem::MaybeUninit<crate::wire::SvcStashStoreRequest>,
2447 _: (),
2448 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2449 ::fidl_next::munge! {
2450 let crate::wire::SvcStashStoreRequest {
2451 svc_endpoint,
2452
2453 } = out_;
2454 }
2455
2456 ::fidl_next::Encode::encode(self.svc_endpoint, encoder_, svc_endpoint, ())?;
2457
2458 Ok(())
2459 }
2460 }
2461
2462 pub struct SvcStashProviderGetResponse<T0> {
2464 pub resource: T0,
2465 }
2466
2467 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SvcStashProviderGetResponse, ___E>
2468 for SvcStashProviderGetResponse<T0>
2469 where
2470 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2471 ___E: ::fidl_next::fuchsia::HandleEncoder,
2472 T0: ::fidl_next::Encode<
2473 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>,
2474 ___E,
2475 >,
2476 {
2477 #[inline]
2478 fn encode(
2479 self,
2480 encoder_: &mut ___E,
2481 out_: &mut ::core::mem::MaybeUninit<crate::wire::SvcStashProviderGetResponse>,
2482 _: (),
2483 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2484 ::fidl_next::munge! {
2485 let crate::wire::SvcStashProviderGetResponse {
2486 resource,
2487
2488 } = out_;
2489 }
2490
2491 ::fidl_next::Encode::encode(self.resource, encoder_, resource, ())?;
2492
2493 Ok(())
2494 }
2495 }
2496
2497 pub struct UserbootPostBootfsFilesRequest<T0> {
2499 pub files: T0,
2500 }
2501
2502 unsafe impl<___E, T0>
2503 ::fidl_next::Encode<crate::wire::UserbootPostBootfsFilesRequest<'static>, ___E>
2504 for UserbootPostBootfsFilesRequest<T0>
2505 where
2506 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2507 ___E: ::fidl_next::Encoder,
2508 ___E: ::fidl_next::fuchsia::HandleEncoder,
2509 T0: ::fidl_next::Encode<
2510 ::fidl_next::wire::Vector<'static, crate::wire::BootfsFileVmo>,
2511 ___E,
2512 >,
2513 {
2514 #[inline]
2515 fn encode(
2516 self,
2517 encoder_: &mut ___E,
2518 out_: &mut ::core::mem::MaybeUninit<
2519 crate::wire::UserbootPostBootfsFilesRequest<'static>,
2520 >,
2521 _: (),
2522 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2523 ::fidl_next::munge! {
2524 let crate::wire::UserbootPostBootfsFilesRequest {
2525 files,
2526
2527 } = out_;
2528 }
2529
2530 ::fidl_next::Encode::encode(self.files, encoder_, files, (64, ()))?;
2531
2532 Ok(())
2533 }
2534 }
2535
2536 pub struct UserbootPostStashSvcRequest<T0> {
2538 pub stash_svc_endpoint: T0,
2539 }
2540
2541 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::UserbootPostStashSvcRequest, ___E>
2542 for UserbootPostStashSvcRequest<T0>
2543 where
2544 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2545 ___E: ::fidl_next::fuchsia::HandleEncoder,
2546 T0: ::fidl_next::Encode<
2547 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>,
2548 ___E,
2549 >,
2550 {
2551 #[inline]
2552 fn encode(
2553 self,
2554 encoder_: &mut ___E,
2555 out_: &mut ::core::mem::MaybeUninit<crate::wire::UserbootPostStashSvcRequest>,
2556 _: (),
2557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2558 ::fidl_next::munge! {
2559 let crate::wire::UserbootPostStashSvcRequest {
2560 stash_svc_endpoint,
2561
2562 } = out_;
2563 }
2564
2565 ::fidl_next::Encode::encode(self.stash_svc_endpoint, encoder_, stash_svc_endpoint, ())?;
2566
2567 Ok(())
2568 }
2569 }
2570
2571 pub struct WriteOnlyLogGetResponse<T0> {
2573 pub log: T0,
2574 }
2575
2576 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WriteOnlyLogGetResponse, ___E>
2577 for WriteOnlyLogGetResponse<T0>
2578 where
2579 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2580 ___E: ::fidl_next::fuchsia::HandleEncoder,
2581 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::DebugLog, ___E>,
2582 {
2583 #[inline]
2584 fn encode(
2585 self,
2586 encoder_: &mut ___E,
2587 out_: &mut ::core::mem::MaybeUninit<crate::wire::WriteOnlyLogGetResponse>,
2588 _: (),
2589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590 ::fidl_next::munge! {
2591 let crate::wire::WriteOnlyLogGetResponse {
2592 log,
2593
2594 } = out_;
2595 }
2596
2597 ::fidl_next::Encode::encode(self.log, encoder_, log, ())?;
2598
2599 Ok(())
2600 }
2601 }
2602}
2603
2604pub use self::natural::*;
2605
2606#[doc = " Protocol for retrieving factory boot item payloads.\n"]
2608#[derive(PartialEq, Debug)]
2609pub struct FactoryItems;
2610
2611impl ::fidl_next::Discoverable for FactoryItems {
2612 const PROTOCOL_NAME: &'static str = "fuchsia.boot.FactoryItems";
2613}
2614
2615#[cfg(target_os = "fuchsia")]
2616impl ::fidl_next::HasTransport for FactoryItems {
2617 type Transport = ::fidl_next::fuchsia::zx::Channel;
2618}
2619
2620pub mod factory_items {
2621 pub mod prelude {
2622 pub use crate::{
2623 FactoryItems, FactoryItemsClientHandler, FactoryItemsLocalClientHandler,
2624 FactoryItemsLocalServerHandler, FactoryItemsServerHandler, factory_items,
2625 };
2626
2627 pub use crate::natural::FactoryItemsGetRequest;
2628
2629 pub use crate::natural::FactoryItemsGetResponse;
2630 }
2631
2632 pub struct Get;
2633
2634 impl ::fidl_next::Method for Get {
2635 const ORDINAL: u64 = 3390589410134308569;
2636 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2637 ::fidl_next::protocol::Flexibility::Strict;
2638
2639 type Protocol = crate::FactoryItems;
2640
2641 type Request = crate::wire::FactoryItemsGetRequest;
2642 }
2643
2644 impl ::fidl_next::TwoWayMethod for Get {
2645 type Response = ::fidl_next::wire::Strict<crate::wire::FactoryItemsGetResponse>;
2646 }
2647
2648 impl<___R> ::fidl_next::Respond<___R> for Get {
2649 type Output = ::fidl_next::Strict<___R>;
2650
2651 fn respond(response: ___R) -> Self::Output {
2652 ::fidl_next::Strict(response)
2653 }
2654 }
2655
2656 mod ___detail {
2657 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::FactoryItems
2658 where
2659 ___T: ::fidl_next::Transport,
2660 {
2661 type Client = FactoryItemsClient<___T>;
2662 type Server = FactoryItemsServer<___T>;
2663 }
2664
2665 #[repr(transparent)]
2667 pub struct FactoryItemsClient<___T: ::fidl_next::Transport> {
2668 #[allow(dead_code)]
2669 client: ::fidl_next::protocol::Client<___T>,
2670 }
2671
2672 impl<___T> FactoryItemsClient<___T>
2673 where
2674 ___T: ::fidl_next::Transport,
2675 {
2676 #[doc = " Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with\n extra field set to `extra`.\n\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n"]
2677 pub fn get(
2678 &self,
2679
2680 extra: impl ::fidl_next::Encode<
2681 ::fidl_next::wire::Uint32,
2682 <___T as ::fidl_next::Transport>::SendBuffer,
2683 >,
2684 ) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T>
2685 where
2686 <___T as ::fidl_next::Transport>::SendBuffer:
2687 ::fidl_next::encoder::InternalHandleEncoder,
2688 {
2689 self.get_with(crate::generic::FactoryItemsGetRequest { extra })
2690 }
2691
2692 #[doc = " Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with\n extra field set to `extra`.\n\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n"]
2693 pub fn get_with<___R>(
2694 &self,
2695 request: ___R,
2696 ) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T>
2697 where
2698 ___R: ::fidl_next::Encode<
2699 crate::wire::FactoryItemsGetRequest,
2700 <___T as ::fidl_next::Transport>::SendBuffer,
2701 >,
2702 {
2703 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
2704 3390589410134308569,
2705 <super::Get as ::fidl_next::Method>::FLEXIBILITY,
2706 request,
2707 ))
2708 }
2709 }
2710
2711 #[repr(transparent)]
2713 pub struct FactoryItemsServer<___T: ::fidl_next::Transport> {
2714 server: ::fidl_next::protocol::Server<___T>,
2715 }
2716
2717 impl<___T> FactoryItemsServer<___T> where ___T: ::fidl_next::Transport {}
2718 }
2719}
2720
2721#[diagnostic::on_unimplemented(
2722 note = "If {Self} implements the non-local FactoryItemsClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
2723)]
2724
2725pub trait FactoryItemsLocalClientHandler<
2729 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2730 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2731>
2732{
2733}
2734
2735impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for FactoryItems
2736where
2737 ___H: FactoryItemsLocalClientHandler<___T>,
2738 ___T: ::fidl_next::Transport,
2739{
2740 async fn on_event(
2741 handler: &mut ___H,
2742 mut message: ::fidl_next::Message<___T>,
2743 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
2744 match *message.header().ordinal {
2745 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
2746 }
2747 }
2748}
2749
2750#[diagnostic::on_unimplemented(
2751 note = "If {Self} implements the non-local FactoryItemsServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
2752)]
2753
2754pub trait FactoryItemsLocalServerHandler<
2758 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2759 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2760>
2761{
2762 #[doc = " Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with\n extra field set to `extra`.\n\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n"]
2763 fn get(
2764 &mut self,
2765
2766 request: ::fidl_next::Request<factory_items::Get, ___T>,
2767
2768 responder: ::fidl_next::Responder<factory_items::Get, ___T>,
2769 ) -> impl ::core::future::Future<Output = ()>;
2770}
2771
2772impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for FactoryItems
2773where
2774 ___H: FactoryItemsLocalServerHandler<___T>,
2775 ___T: ::fidl_next::Transport,
2776 for<'de> crate::wire::FactoryItemsGetRequest: ::fidl_next::Decode<
2777 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
2778 Constraint = (),
2779 >,
2780{
2781 async fn on_one_way(
2782 handler: &mut ___H,
2783 mut message: ::fidl_next::Message<___T>,
2784 ) -> ::core::result::Result<
2785 (),
2786 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2787 > {
2788 match *message.header().ordinal {
2789 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
2790 }
2791 }
2792
2793 async fn on_two_way(
2794 handler: &mut ___H,
2795 mut message: ::fidl_next::Message<___T>,
2796 responder: ::fidl_next::protocol::Responder<___T>,
2797 ) -> ::core::result::Result<
2798 (),
2799 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2800 > {
2801 match *message.header().ordinal {
2802 3390589410134308569 => {
2803 let responder = ::fidl_next::Responder::from_untyped(responder);
2804
2805 match ::fidl_next::AsDecoderExt::into_decoded(message) {
2806 Ok(decoded) => {
2807 handler.get(::fidl_next::Request::from_decoded(decoded), responder).await;
2808 Ok(())
2809 }
2810 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
2811 ordinal: 3390589410134308569,
2812 error,
2813 }),
2814 }
2815 }
2816
2817 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
2818 }
2819 }
2820}
2821
2822pub trait FactoryItemsClientHandler<
2826 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2827 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2828>
2829{
2830}
2831
2832impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for FactoryItems
2833where
2834 ___H: FactoryItemsClientHandler<___T> + ::core::marker::Send,
2835 ___T: ::fidl_next::Transport,
2836{
2837 async fn on_event(
2838 handler: &mut ___H,
2839 mut message: ::fidl_next::Message<___T>,
2840 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
2841 match *message.header().ordinal {
2842 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
2843 }
2844 }
2845}
2846
2847pub trait FactoryItemsServerHandler<
2851 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2852 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2853>
2854{
2855 #[doc = " Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with\n extra field set to `extra`.\n\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n"]
2856 fn get(
2857 &mut self,
2858
2859 request: ::fidl_next::Request<factory_items::Get, ___T>,
2860
2861 responder: ::fidl_next::Responder<factory_items::Get, ___T>,
2862 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
2863}
2864
2865impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for FactoryItems
2866where
2867 ___H: FactoryItemsServerHandler<___T> + ::core::marker::Send,
2868 ___T: ::fidl_next::Transport,
2869 for<'de> crate::wire::FactoryItemsGetRequest: ::fidl_next::Decode<
2870 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
2871 Constraint = (),
2872 >,
2873{
2874 async fn on_one_way(
2875 handler: &mut ___H,
2876 mut message: ::fidl_next::Message<___T>,
2877 ) -> ::core::result::Result<
2878 (),
2879 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2880 > {
2881 match *message.header().ordinal {
2882 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
2883 }
2884 }
2885
2886 async fn on_two_way(
2887 handler: &mut ___H,
2888 mut message: ::fidl_next::Message<___T>,
2889 responder: ::fidl_next::protocol::Responder<___T>,
2890 ) -> ::core::result::Result<
2891 (),
2892 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2893 > {
2894 match *message.header().ordinal {
2895 3390589410134308569 => {
2896 let responder = ::fidl_next::Responder::from_untyped(responder);
2897
2898 match ::fidl_next::AsDecoderExt::into_decoded(message) {
2899 Ok(decoded) => {
2900 handler.get(::fidl_next::Request::from_decoded(decoded), responder).await;
2901 Ok(())
2902 }
2903 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
2904 ordinal: 3390589410134308569,
2905 error,
2906 }),
2907 }
2908 }
2909
2910 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
2911 }
2912 }
2913}
2914
2915impl<___T> FactoryItemsClientHandler<___T> for ::fidl_next::IgnoreEvents where
2916 ___T: ::fidl_next::Transport
2917{
2918}
2919
2920impl<___H, ___T> FactoryItemsLocalClientHandler<___T> for ::fidl_next::Local<___H>
2921where
2922 ___H: FactoryItemsClientHandler<___T>,
2923 ___T: ::fidl_next::Transport,
2924{
2925}
2926
2927impl<___H, ___T> FactoryItemsLocalServerHandler<___T> for ::fidl_next::Local<___H>
2928where
2929 ___H: FactoryItemsServerHandler<___T>,
2930 ___T: ::fidl_next::Transport,
2931{
2932 async fn get(
2933 &mut self,
2934
2935 request: ::fidl_next::Request<factory_items::Get, ___T>,
2936
2937 responder: ::fidl_next::Responder<factory_items::Get, ___T>,
2938 ) {
2939 ___H::get(&mut self.0, request, responder).await
2940 }
2941}
2942
2943#[doc = " Protocol for retrieving boot item payloads.\n"]
2945#[derive(PartialEq, Debug)]
2946pub struct Items;
2947
2948impl ::fidl_next::Discoverable for Items {
2949 const PROTOCOL_NAME: &'static str = "fuchsia.boot.Items";
2950}
2951
2952#[cfg(target_os = "fuchsia")]
2953impl ::fidl_next::HasTransport for Items {
2954 type Transport = ::fidl_next::fuchsia::zx::Channel;
2955}
2956
2957pub mod items {
2958 pub mod prelude {
2959 pub use crate::{
2960 Items, ItemsClientHandler, ItemsLocalClientHandler, ItemsLocalServerHandler,
2961 ItemsServerHandler, items,
2962 };
2963
2964 pub use crate::natural::ItemsGet2Request;
2965
2966 pub use crate::natural::ItemsGetBootloaderFileRequest;
2967
2968 pub use crate::natural::ItemsGetBootloaderFileResponse;
2969
2970 pub use crate::natural::ItemsGetRequest;
2971
2972 pub use crate::natural::ItemsGetResponse;
2973
2974 pub use crate::natural::ItemsGet2Response;
2975 }
2976
2977 pub struct Get;
2978
2979 impl ::fidl_next::Method for Get {
2980 const ORDINAL: u64 = 6065702122792689372;
2981 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2982 ::fidl_next::protocol::Flexibility::Strict;
2983
2984 type Protocol = crate::Items;
2985
2986 type Request = crate::wire::ItemsGetRequest;
2987 }
2988
2989 impl ::fidl_next::TwoWayMethod for Get {
2990 type Response = ::fidl_next::wire::Strict<crate::wire::ItemsGetResponse>;
2991 }
2992
2993 impl<___R> ::fidl_next::Respond<___R> for Get {
2994 type Output = ::fidl_next::Strict<___R>;
2995
2996 fn respond(response: ___R) -> Self::Output {
2997 ::fidl_next::Strict(response)
2998 }
2999 }
3000
3001 pub struct Get2;
3002
3003 impl ::fidl_next::Method for Get2 {
3004 const ORDINAL: u64 = 3054774473899786030;
3005 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3006 ::fidl_next::protocol::Flexibility::Strict;
3007
3008 type Protocol = crate::Items;
3009
3010 type Request = crate::wire::ItemsGet2Request<'static>;
3011 }
3012
3013 impl ::fidl_next::TwoWayMethod for Get2 {
3014 type Response = ::fidl_next::wire::Result<
3015 'static,
3016 crate::wire::ItemsGet2Response<'static>,
3017 ::fidl_next::wire::fuchsia::Status,
3018 >;
3019 }
3020
3021 impl<___R> ::fidl_next::Respond<___R> for Get2 {
3022 type Output = ::core::result::Result<
3023 crate::generic::ItemsGet2Response<___R>,
3024 ::fidl_next::never::Never,
3025 >;
3026
3027 fn respond(response: ___R) -> Self::Output {
3028 ::core::result::Result::Ok(crate::generic::ItemsGet2Response {
3029 retrieved_items: response,
3030 })
3031 }
3032 }
3033
3034 impl<___R> ::fidl_next::RespondErr<___R> for Get2 {
3035 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
3036
3037 fn respond_err(response: ___R) -> Self::Output {
3038 ::core::result::Result::Err(response)
3039 }
3040 }
3041
3042 pub struct GetBootloaderFile;
3043
3044 impl ::fidl_next::Method for GetBootloaderFile {
3045 const ORDINAL: u64 = 6485268897983860364;
3046 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3047 ::fidl_next::protocol::Flexibility::Strict;
3048
3049 type Protocol = crate::Items;
3050
3051 type Request = crate::wire::ItemsGetBootloaderFileRequest<'static>;
3052 }
3053
3054 impl ::fidl_next::TwoWayMethod for GetBootloaderFile {
3055 type Response = ::fidl_next::wire::Strict<crate::wire::ItemsGetBootloaderFileResponse>;
3056 }
3057
3058 impl<___R> ::fidl_next::Respond<___R> for GetBootloaderFile {
3059 type Output = ::fidl_next::Strict<crate::generic::ItemsGetBootloaderFileResponse<___R>>;
3060
3061 fn respond(response: ___R) -> Self::Output {
3062 ::fidl_next::Strict(crate::generic::ItemsGetBootloaderFileResponse {
3063 payload: response,
3064 })
3065 }
3066 }
3067
3068 mod ___detail {
3069 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Items
3070 where
3071 ___T: ::fidl_next::Transport,
3072 {
3073 type Client = ItemsClient<___T>;
3074 type Server = ItemsServer<___T>;
3075 }
3076
3077 #[repr(transparent)]
3079 pub struct ItemsClient<___T: ::fidl_next::Transport> {
3080 #[allow(dead_code)]
3081 client: ::fidl_next::protocol::Client<___T>,
3082 }
3083
3084 impl<___T> ItemsClient<___T>
3085 where
3086 ___T: ::fidl_next::Transport,
3087 {
3088 #[doc = " Get a `payload` for a boot item of `type` and `extra`.\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n\n TODO: Refactor API: https://fxbug.dev/42109921\n\n For a list of `type`s, refer to <lib/zbi-format/zbi.h>.\n For a list of `extra`s, refer to <lib/zbi-format/driver-config.h>.\n"]
3089 pub fn get(
3090 &self,
3091
3092 type_: impl ::fidl_next::Encode<
3093 ::fidl_next::wire::Uint32,
3094 <___T as ::fidl_next::Transport>::SendBuffer,
3095 >,
3096
3097 extra: impl ::fidl_next::Encode<
3098 ::fidl_next::wire::Uint32,
3099 <___T as ::fidl_next::Transport>::SendBuffer,
3100 >,
3101 ) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T>
3102 where
3103 <___T as ::fidl_next::Transport>::SendBuffer:
3104 ::fidl_next::encoder::InternalHandleEncoder,
3105 {
3106 self.get_with(crate::generic::ItemsGetRequest { type_, extra })
3107 }
3108
3109 #[doc = " Get a `payload` for a boot item of `type` and `extra`.\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n\n TODO: Refactor API: https://fxbug.dev/42109921\n\n For a list of `type`s, refer to <lib/zbi-format/zbi.h>.\n For a list of `extra`s, refer to <lib/zbi-format/driver-config.h>.\n"]
3110 pub fn get_with<___R>(
3111 &self,
3112 request: ___R,
3113 ) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T>
3114 where
3115 ___R: ::fidl_next::Encode<
3116 crate::wire::ItemsGetRequest,
3117 <___T as ::fidl_next::Transport>::SendBuffer,
3118 >,
3119 {
3120 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
3121 6065702122792689372,
3122 <super::Get as ::fidl_next::Method>::FLEXIBILITY,
3123 request,
3124 ))
3125 }
3126
3127 #[doc = " Get all stored items of `type`, optionally also restricted by `extra`. Note that\n length is returned for each item as VMOs are page-aligned.\n\n Returns ZX_ERR_NOT_SUPPORTED if this is an untracked item which will never be stored.\n"]
3128 pub fn get2(
3129 &self,
3130
3131 type_: impl ::fidl_next::Encode<
3132 ::fidl_next::wire::Uint32,
3133 <___T as ::fidl_next::Transport>::SendBuffer,
3134 >,
3135
3136 extra: impl ::fidl_next::Encode<
3137 ::fidl_next::wire::Box<'static, crate::wire::Extra>,
3138 <___T as ::fidl_next::Transport>::SendBuffer,
3139 >,
3140 ) -> ::fidl_next::TwoWayFuture<'_, super::Get2, ___T>
3141 where
3142 <___T as ::fidl_next::Transport>::SendBuffer:
3143 ::fidl_next::encoder::InternalHandleEncoder,
3144 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
3145 {
3146 self.get2_with(crate::generic::ItemsGet2Request { type_, extra })
3147 }
3148
3149 #[doc = " Get all stored items of `type`, optionally also restricted by `extra`. Note that\n length is returned for each item as VMOs are page-aligned.\n\n Returns ZX_ERR_NOT_SUPPORTED if this is an untracked item which will never be stored.\n"]
3150 pub fn get2_with<___R>(
3151 &self,
3152 request: ___R,
3153 ) -> ::fidl_next::TwoWayFuture<'_, super::Get2, ___T>
3154 where
3155 ___R: ::fidl_next::Encode<
3156 crate::wire::ItemsGet2Request<'static>,
3157 <___T as ::fidl_next::Transport>::SendBuffer,
3158 >,
3159 {
3160 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
3161 3054774473899786030,
3162 <super::Get2 as ::fidl_next::Method>::FLEXIBILITY,
3163 request,
3164 ))
3165 }
3166
3167 #[doc = " Gets the `payload` for a `ZBI_TYPE_BOOTLOADER_FILE` boot item.\n Note: ZX_PROP_VMO_CONTENT_SIZE will be set to the actual file content size\n"]
3168 pub fn get_bootloader_file(
3169 &self,
3170
3171 filename: impl ::fidl_next::Encode<
3172 ::fidl_next::wire::String<'static>,
3173 <___T as ::fidl_next::Transport>::SendBuffer,
3174 >,
3175 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBootloaderFile, ___T>
3176 where
3177 <___T as ::fidl_next::Transport>::SendBuffer:
3178 ::fidl_next::encoder::InternalHandleEncoder,
3179 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
3180 {
3181 self.get_bootloader_file_with(crate::generic::ItemsGetBootloaderFileRequest {
3182 filename,
3183 })
3184 }
3185
3186 #[doc = " Gets the `payload` for a `ZBI_TYPE_BOOTLOADER_FILE` boot item.\n Note: ZX_PROP_VMO_CONTENT_SIZE will be set to the actual file content size\n"]
3187 pub fn get_bootloader_file_with<___R>(
3188 &self,
3189 request: ___R,
3190 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBootloaderFile, ___T>
3191 where
3192 ___R: ::fidl_next::Encode<
3193 crate::wire::ItemsGetBootloaderFileRequest<'static>,
3194 <___T as ::fidl_next::Transport>::SendBuffer,
3195 >,
3196 {
3197 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
3198 6485268897983860364,
3199 <super::GetBootloaderFile as ::fidl_next::Method>::FLEXIBILITY,
3200 request,
3201 ))
3202 }
3203 }
3204
3205 #[repr(transparent)]
3207 pub struct ItemsServer<___T: ::fidl_next::Transport> {
3208 server: ::fidl_next::protocol::Server<___T>,
3209 }
3210
3211 impl<___T> ItemsServer<___T> where ___T: ::fidl_next::Transport {}
3212 }
3213}
3214
3215#[diagnostic::on_unimplemented(
3216 note = "If {Self} implements the non-local ItemsClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
3217)]
3218
3219pub trait ItemsLocalClientHandler<
3223 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3224 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3225>
3226{
3227}
3228
3229impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Items
3230where
3231 ___H: ItemsLocalClientHandler<___T>,
3232 ___T: ::fidl_next::Transport,
3233{
3234 async fn on_event(
3235 handler: &mut ___H,
3236 mut message: ::fidl_next::Message<___T>,
3237 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3238 match *message.header().ordinal {
3239 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3240 }
3241 }
3242}
3243
3244#[diagnostic::on_unimplemented(
3245 note = "If {Self} implements the non-local ItemsServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
3246)]
3247
3248pub trait ItemsLocalServerHandler<
3252 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3253 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3254>
3255{
3256 #[doc = " Get a `payload` for a boot item of `type` and `extra`.\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n\n TODO: Refactor API: https://fxbug.dev/42109921\n\n For a list of `type`s, refer to <lib/zbi-format/zbi.h>.\n For a list of `extra`s, refer to <lib/zbi-format/driver-config.h>.\n"]
3257 fn get(
3258 &mut self,
3259
3260 request: ::fidl_next::Request<items::Get, ___T>,
3261
3262 responder: ::fidl_next::Responder<items::Get, ___T>,
3263 ) -> impl ::core::future::Future<Output = ()>;
3264
3265 #[doc = " Get all stored items of `type`, optionally also restricted by `extra`. Note that\n length is returned for each item as VMOs are page-aligned.\n\n Returns ZX_ERR_NOT_SUPPORTED if this is an untracked item which will never be stored.\n"]
3266 fn get2(
3267 &mut self,
3268
3269 request: ::fidl_next::Request<items::Get2, ___T>,
3270
3271 responder: ::fidl_next::Responder<items::Get2, ___T>,
3272 ) -> impl ::core::future::Future<Output = ()>;
3273
3274 #[doc = " Gets the `payload` for a `ZBI_TYPE_BOOTLOADER_FILE` boot item.\n Note: ZX_PROP_VMO_CONTENT_SIZE will be set to the actual file content size\n"]
3275 fn get_bootloader_file(
3276 &mut self,
3277
3278 request: ::fidl_next::Request<items::GetBootloaderFile, ___T>,
3279
3280 responder: ::fidl_next::Responder<items::GetBootloaderFile, ___T>,
3281 ) -> impl ::core::future::Future<Output = ()>;
3282}
3283
3284impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Items
3285where
3286 ___H: ItemsLocalServerHandler<___T>,
3287 ___T: ::fidl_next::Transport,
3288 for<'de> crate::wire::ItemsGetRequest: ::fidl_next::Decode<
3289 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3290 Constraint = (),
3291 >,
3292 for<'de> crate::wire::ItemsGet2Request<'de>: ::fidl_next::Decode<
3293 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3294 Constraint = (),
3295 >,
3296 for<'de> crate::wire::ItemsGetBootloaderFileRequest<'de>: ::fidl_next::Decode<
3297 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3298 Constraint = (),
3299 >,
3300{
3301 async fn on_one_way(
3302 handler: &mut ___H,
3303 mut message: ::fidl_next::Message<___T>,
3304 ) -> ::core::result::Result<
3305 (),
3306 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3307 > {
3308 match *message.header().ordinal {
3309 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3310 }
3311 }
3312
3313 async fn on_two_way(
3314 handler: &mut ___H,
3315 mut message: ::fidl_next::Message<___T>,
3316 responder: ::fidl_next::protocol::Responder<___T>,
3317 ) -> ::core::result::Result<
3318 (),
3319 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3320 > {
3321 match *message.header().ordinal {
3322 6065702122792689372 => {
3323 let responder = ::fidl_next::Responder::from_untyped(responder);
3324
3325 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3326 Ok(decoded) => {
3327 handler.get(::fidl_next::Request::from_decoded(decoded), responder).await;
3328 Ok(())
3329 }
3330 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3331 ordinal: 6065702122792689372,
3332 error,
3333 }),
3334 }
3335 }
3336
3337 3054774473899786030 => {
3338 let responder = ::fidl_next::Responder::from_untyped(responder);
3339
3340 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3341 Ok(decoded) => {
3342 handler.get2(::fidl_next::Request::from_decoded(decoded), responder).await;
3343 Ok(())
3344 }
3345 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3346 ordinal: 3054774473899786030,
3347 error,
3348 }),
3349 }
3350 }
3351
3352 6485268897983860364 => {
3353 let responder = ::fidl_next::Responder::from_untyped(responder);
3354
3355 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3356 Ok(decoded) => {
3357 handler
3358 .get_bootloader_file(
3359 ::fidl_next::Request::from_decoded(decoded),
3360 responder,
3361 )
3362 .await;
3363 Ok(())
3364 }
3365 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3366 ordinal: 6485268897983860364,
3367 error,
3368 }),
3369 }
3370 }
3371
3372 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3373 }
3374 }
3375}
3376
3377pub trait ItemsClientHandler<
3381 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3382 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3383>
3384{
3385}
3386
3387impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Items
3388where
3389 ___H: ItemsClientHandler<___T> + ::core::marker::Send,
3390 ___T: ::fidl_next::Transport,
3391{
3392 async fn on_event(
3393 handler: &mut ___H,
3394 mut message: ::fidl_next::Message<___T>,
3395 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3396 match *message.header().ordinal {
3397 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3398 }
3399 }
3400}
3401
3402pub trait ItemsServerHandler<
3406 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3407 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3408>
3409{
3410 #[doc = " Get a `payload` for a boot item of `type` and `extra`.\n NOTE: We return the `length` of the item, as VMOs must be page-aligned.\n\n TODO: Refactor API: https://fxbug.dev/42109921\n\n For a list of `type`s, refer to <lib/zbi-format/zbi.h>.\n For a list of `extra`s, refer to <lib/zbi-format/driver-config.h>.\n"]
3411 fn get(
3412 &mut self,
3413
3414 request: ::fidl_next::Request<items::Get, ___T>,
3415
3416 responder: ::fidl_next::Responder<items::Get, ___T>,
3417 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3418
3419 #[doc = " Get all stored items of `type`, optionally also restricted by `extra`. Note that\n length is returned for each item as VMOs are page-aligned.\n\n Returns ZX_ERR_NOT_SUPPORTED if this is an untracked item which will never be stored.\n"]
3420 fn get2(
3421 &mut self,
3422
3423 request: ::fidl_next::Request<items::Get2, ___T>,
3424
3425 responder: ::fidl_next::Responder<items::Get2, ___T>,
3426 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3427
3428 #[doc = " Gets the `payload` for a `ZBI_TYPE_BOOTLOADER_FILE` boot item.\n Note: ZX_PROP_VMO_CONTENT_SIZE will be set to the actual file content size\n"]
3429 fn get_bootloader_file(
3430 &mut self,
3431
3432 request: ::fidl_next::Request<items::GetBootloaderFile, ___T>,
3433
3434 responder: ::fidl_next::Responder<items::GetBootloaderFile, ___T>,
3435 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3436}
3437
3438impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Items
3439where
3440 ___H: ItemsServerHandler<___T> + ::core::marker::Send,
3441 ___T: ::fidl_next::Transport,
3442 for<'de> crate::wire::ItemsGetRequest: ::fidl_next::Decode<
3443 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3444 Constraint = (),
3445 >,
3446 for<'de> crate::wire::ItemsGet2Request<'de>: ::fidl_next::Decode<
3447 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3448 Constraint = (),
3449 >,
3450 for<'de> crate::wire::ItemsGetBootloaderFileRequest<'de>: ::fidl_next::Decode<
3451 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
3452 Constraint = (),
3453 >,
3454{
3455 async fn on_one_way(
3456 handler: &mut ___H,
3457 mut message: ::fidl_next::Message<___T>,
3458 ) -> ::core::result::Result<
3459 (),
3460 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3461 > {
3462 match *message.header().ordinal {
3463 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3464 }
3465 }
3466
3467 async fn on_two_way(
3468 handler: &mut ___H,
3469 mut message: ::fidl_next::Message<___T>,
3470 responder: ::fidl_next::protocol::Responder<___T>,
3471 ) -> ::core::result::Result<
3472 (),
3473 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3474 > {
3475 match *message.header().ordinal {
3476 6065702122792689372 => {
3477 let responder = ::fidl_next::Responder::from_untyped(responder);
3478
3479 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3480 Ok(decoded) => {
3481 handler.get(::fidl_next::Request::from_decoded(decoded), responder).await;
3482 Ok(())
3483 }
3484 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3485 ordinal: 6065702122792689372,
3486 error,
3487 }),
3488 }
3489 }
3490
3491 3054774473899786030 => {
3492 let responder = ::fidl_next::Responder::from_untyped(responder);
3493
3494 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3495 Ok(decoded) => {
3496 handler.get2(::fidl_next::Request::from_decoded(decoded), responder).await;
3497 Ok(())
3498 }
3499 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3500 ordinal: 3054774473899786030,
3501 error,
3502 }),
3503 }
3504 }
3505
3506 6485268897983860364 => {
3507 let responder = ::fidl_next::Responder::from_untyped(responder);
3508
3509 match ::fidl_next::AsDecoderExt::into_decoded(message) {
3510 Ok(decoded) => {
3511 handler
3512 .get_bootloader_file(
3513 ::fidl_next::Request::from_decoded(decoded),
3514 responder,
3515 )
3516 .await;
3517 Ok(())
3518 }
3519 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
3520 ordinal: 6485268897983860364,
3521 error,
3522 }),
3523 }
3524 }
3525
3526 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3527 }
3528 }
3529}
3530
3531impl<___T> ItemsClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
3532
3533impl<___H, ___T> ItemsLocalClientHandler<___T> for ::fidl_next::Local<___H>
3534where
3535 ___H: ItemsClientHandler<___T>,
3536 ___T: ::fidl_next::Transport,
3537{
3538}
3539
3540impl<___H, ___T> ItemsLocalServerHandler<___T> for ::fidl_next::Local<___H>
3541where
3542 ___H: ItemsServerHandler<___T>,
3543 ___T: ::fidl_next::Transport,
3544{
3545 async fn get(
3546 &mut self,
3547
3548 request: ::fidl_next::Request<items::Get, ___T>,
3549
3550 responder: ::fidl_next::Responder<items::Get, ___T>,
3551 ) {
3552 ___H::get(&mut self.0, request, responder).await
3553 }
3554
3555 async fn get2(
3556 &mut self,
3557
3558 request: ::fidl_next::Request<items::Get2, ___T>,
3559
3560 responder: ::fidl_next::Responder<items::Get2, ___T>,
3561 ) {
3562 ___H::get2(&mut self.0, request, responder).await
3563 }
3564
3565 async fn get_bootloader_file(
3566 &mut self,
3567
3568 request: ::fidl_next::Request<items::GetBootloaderFile, ___T>,
3569
3570 responder: ::fidl_next::Responder<items::GetBootloaderFile, ___T>,
3571 ) {
3572 ___H::get_bootloader_file(&mut self.0, request, responder).await
3573 }
3574}
3575
3576#[doc = " Protocol for providing the kernel log, readable.\n"]
3578#[derive(PartialEq, Debug)]
3579pub struct ReadOnlyLog;
3580
3581impl ::fidl_next::Discoverable for ReadOnlyLog {
3582 const PROTOCOL_NAME: &'static str = "fuchsia.boot.ReadOnlyLog";
3583}
3584
3585#[cfg(target_os = "fuchsia")]
3586impl ::fidl_next::HasTransport for ReadOnlyLog {
3587 type Transport = ::fidl_next::fuchsia::zx::Channel;
3588}
3589
3590pub mod read_only_log {
3591 pub mod prelude {
3592 pub use crate::{
3593 ReadOnlyLog, ReadOnlyLogClientHandler, ReadOnlyLogLocalClientHandler,
3594 ReadOnlyLogLocalServerHandler, ReadOnlyLogServerHandler, read_only_log,
3595 };
3596
3597 pub use crate::natural::ReadOnlyLogGetResponse;
3598 }
3599
3600 pub struct Get;
3601
3602 impl ::fidl_next::Method for Get {
3603 const ORDINAL: u64 = 8015540534685233663;
3604 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3605 ::fidl_next::protocol::Flexibility::Strict;
3606
3607 type Protocol = crate::ReadOnlyLog;
3608
3609 type Request = ::fidl_next::wire::EmptyMessageBody;
3610 }
3611
3612 impl ::fidl_next::TwoWayMethod for Get {
3613 type Response = ::fidl_next::wire::Strict<crate::wire::ReadOnlyLogGetResponse>;
3614 }
3615
3616 impl<___R> ::fidl_next::Respond<___R> for Get {
3617 type Output = ::fidl_next::Strict<crate::generic::ReadOnlyLogGetResponse<___R>>;
3618
3619 fn respond(response: ___R) -> Self::Output {
3620 ::fidl_next::Strict(crate::generic::ReadOnlyLogGetResponse { log: response })
3621 }
3622 }
3623
3624 mod ___detail {
3625 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ReadOnlyLog
3626 where
3627 ___T: ::fidl_next::Transport,
3628 {
3629 type Client = ReadOnlyLogClient<___T>;
3630 type Server = ReadOnlyLogServer<___T>;
3631 }
3632
3633 #[repr(transparent)]
3635 pub struct ReadOnlyLogClient<___T: ::fidl_next::Transport> {
3636 #[allow(dead_code)]
3637 client: ::fidl_next::protocol::Client<___T>,
3638 }
3639
3640 impl<___T> ReadOnlyLogClient<___T>
3641 where
3642 ___T: ::fidl_next::Transport,
3643 {
3644 #[doc = " Get read-only handle to the kernel `log`.\n"]
3645 pub fn get(&self) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T> {
3646 ::fidl_next::TwoWayFuture::from_untyped(
3647 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
3648 8015540534685233663,
3649 <super::Get as ::fidl_next::Method>::FLEXIBILITY,
3650 (),
3651 ),
3652 )
3653 }
3654 }
3655
3656 #[repr(transparent)]
3658 pub struct ReadOnlyLogServer<___T: ::fidl_next::Transport> {
3659 server: ::fidl_next::protocol::Server<___T>,
3660 }
3661
3662 impl<___T> ReadOnlyLogServer<___T> where ___T: ::fidl_next::Transport {}
3663 }
3664}
3665
3666#[diagnostic::on_unimplemented(
3667 note = "If {Self} implements the non-local ReadOnlyLogClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
3668)]
3669
3670pub trait ReadOnlyLogLocalClientHandler<
3674 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3675 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3676>
3677{
3678}
3679
3680impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ReadOnlyLog
3681where
3682 ___H: ReadOnlyLogLocalClientHandler<___T>,
3683 ___T: ::fidl_next::Transport,
3684{
3685 async fn on_event(
3686 handler: &mut ___H,
3687 mut message: ::fidl_next::Message<___T>,
3688 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3689 match *message.header().ordinal {
3690 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3691 }
3692 }
3693}
3694
3695#[diagnostic::on_unimplemented(
3696 note = "If {Self} implements the non-local ReadOnlyLogServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
3697)]
3698
3699pub trait ReadOnlyLogLocalServerHandler<
3703 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3704 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3705>
3706{
3707 #[doc = " Get read-only handle to the kernel `log`.\n"]
3708 fn get(
3709 &mut self,
3710
3711 responder: ::fidl_next::Responder<read_only_log::Get, ___T>,
3712 ) -> impl ::core::future::Future<Output = ()>;
3713}
3714
3715impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ReadOnlyLog
3716where
3717 ___H: ReadOnlyLogLocalServerHandler<___T>,
3718 ___T: ::fidl_next::Transport,
3719{
3720 async fn on_one_way(
3721 handler: &mut ___H,
3722 mut message: ::fidl_next::Message<___T>,
3723 ) -> ::core::result::Result<
3724 (),
3725 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3726 > {
3727 match *message.header().ordinal {
3728 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3729 }
3730 }
3731
3732 async fn on_two_way(
3733 handler: &mut ___H,
3734 mut message: ::fidl_next::Message<___T>,
3735 responder: ::fidl_next::protocol::Responder<___T>,
3736 ) -> ::core::result::Result<
3737 (),
3738 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3739 > {
3740 match *message.header().ordinal {
3741 8015540534685233663 => {
3742 let responder = ::fidl_next::Responder::from_untyped(responder);
3743
3744 handler.get(responder).await;
3745 Ok(())
3746 }
3747
3748 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3749 }
3750 }
3751}
3752
3753pub trait ReadOnlyLogClientHandler<
3757 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3758 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3759>
3760{
3761}
3762
3763impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ReadOnlyLog
3764where
3765 ___H: ReadOnlyLogClientHandler<___T> + ::core::marker::Send,
3766 ___T: ::fidl_next::Transport,
3767{
3768 async fn on_event(
3769 handler: &mut ___H,
3770 mut message: ::fidl_next::Message<___T>,
3771 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3772 match *message.header().ordinal {
3773 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3774 }
3775 }
3776}
3777
3778pub trait ReadOnlyLogServerHandler<
3782 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3783 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3784>
3785{
3786 #[doc = " Get read-only handle to the kernel `log`.\n"]
3787 fn get(
3788 &mut self,
3789
3790 responder: ::fidl_next::Responder<read_only_log::Get, ___T>,
3791 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3792}
3793
3794impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ReadOnlyLog
3795where
3796 ___H: ReadOnlyLogServerHandler<___T> + ::core::marker::Send,
3797 ___T: ::fidl_next::Transport,
3798{
3799 async fn on_one_way(
3800 handler: &mut ___H,
3801 mut message: ::fidl_next::Message<___T>,
3802 ) -> ::core::result::Result<
3803 (),
3804 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3805 > {
3806 match *message.header().ordinal {
3807 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3808 }
3809 }
3810
3811 async fn on_two_way(
3812 handler: &mut ___H,
3813 mut message: ::fidl_next::Message<___T>,
3814 responder: ::fidl_next::protocol::Responder<___T>,
3815 ) -> ::core::result::Result<
3816 (),
3817 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3818 > {
3819 match *message.header().ordinal {
3820 8015540534685233663 => {
3821 let responder = ::fidl_next::Responder::from_untyped(responder);
3822
3823 handler.get(responder).await;
3824 Ok(())
3825 }
3826
3827 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3828 }
3829 }
3830}
3831
3832impl<___T> ReadOnlyLogClientHandler<___T> for ::fidl_next::IgnoreEvents where
3833 ___T: ::fidl_next::Transport
3834{
3835}
3836
3837impl<___H, ___T> ReadOnlyLogLocalClientHandler<___T> for ::fidl_next::Local<___H>
3838where
3839 ___H: ReadOnlyLogClientHandler<___T>,
3840 ___T: ::fidl_next::Transport,
3841{
3842}
3843
3844impl<___H, ___T> ReadOnlyLogLocalServerHandler<___T> for ::fidl_next::Local<___H>
3845where
3846 ___H: ReadOnlyLogServerHandler<___T>,
3847 ___T: ::fidl_next::Transport,
3848{
3849 async fn get(&mut self, responder: ::fidl_next::Responder<read_only_log::Get, ___T>) {
3850 ___H::get(&mut self.0, responder).await
3851 }
3852}
3853
3854#[doc = " Protocol for storing svc server ends of \'svc\' for later processing during early boot.\n"]
3856#[derive(PartialEq, Debug)]
3857pub struct SvcStash;
3858
3859#[cfg(target_os = "fuchsia")]
3860impl ::fidl_next::HasTransport for SvcStash {
3861 type Transport = ::fidl_next::fuchsia::zx::Channel;
3862}
3863
3864pub mod svc_stash {
3865 pub mod prelude {
3866 pub use crate::{
3867 SvcStash, SvcStashClientHandler, SvcStashLocalClientHandler,
3868 SvcStashLocalServerHandler, SvcStashServerHandler, svc_stash,
3869 };
3870
3871 pub use crate::natural::SvcStashStoreRequest;
3872 }
3873
3874 pub struct Store;
3875
3876 impl ::fidl_next::Method for Store {
3877 const ORDINAL: u64 = 875467318821005424;
3878 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
3879 ::fidl_next::protocol::Flexibility::Strict;
3880
3881 type Protocol = crate::SvcStash;
3882
3883 type Request = crate::wire::SvcStashStoreRequest;
3884 }
3885
3886 mod ___detail {
3887 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::SvcStash
3888 where
3889 ___T: ::fidl_next::Transport,
3890 {
3891 type Client = SvcStashClient<___T>;
3892 type Server = SvcStashServer<___T>;
3893 }
3894
3895 #[repr(transparent)]
3897 pub struct SvcStashClient<___T: ::fidl_next::Transport> {
3898 #[allow(dead_code)]
3899 client: ::fidl_next::protocol::Client<___T>,
3900 }
3901
3902 impl<___T> SvcStashClient<___T>
3903 where
3904 ___T: ::fidl_next::Transport,
3905 {
3906 #[doc = " Store a svc_endpoint in the stash. Stored endpoints will remain in transit,\n since there might not be a server side implementation. The server end\n is retrieved by |SvcStashProvider/Get|.\n"]
3907 pub fn store(
3908 &self,
3909
3910 svc_endpoint: impl ::fidl_next::Encode<
3911 ::fidl_next::ServerEnd<
3912 ::fidl_next_fuchsia_io::Directory,
3913 ::fidl_next::wire::fuchsia::Channel,
3914 >,
3915 <___T as ::fidl_next::Transport>::SendBuffer,
3916 >,
3917 ) -> ::fidl_next::SendFuture<'_, ___T>
3918 where
3919 <___T as ::fidl_next::Transport>::SendBuffer:
3920 ::fidl_next::encoder::InternalHandleEncoder,
3921 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
3922 {
3923 self.store_with(crate::generic::SvcStashStoreRequest { svc_endpoint })
3924 }
3925
3926 #[doc = " Store a svc_endpoint in the stash. Stored endpoints will remain in transit,\n since there might not be a server side implementation. The server end\n is retrieved by |SvcStashProvider/Get|.\n"]
3927 pub fn store_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
3928 where
3929 ___R: ::fidl_next::Encode<
3930 crate::wire::SvcStashStoreRequest,
3931 <___T as ::fidl_next::Transport>::SendBuffer,
3932 >,
3933 {
3934 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
3935 875467318821005424,
3936 <super::Store as ::fidl_next::Method>::FLEXIBILITY,
3937 request,
3938 ))
3939 }
3940 }
3941
3942 #[repr(transparent)]
3944 pub struct SvcStashServer<___T: ::fidl_next::Transport> {
3945 server: ::fidl_next::protocol::Server<___T>,
3946 }
3947
3948 impl<___T> SvcStashServer<___T> where ___T: ::fidl_next::Transport {}
3949 }
3950}
3951
3952#[diagnostic::on_unimplemented(
3953 note = "If {Self} implements the non-local SvcStashClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
3954)]
3955
3956pub trait SvcStashLocalClientHandler<
3960 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3961 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3962>
3963{
3964}
3965
3966impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for SvcStash
3967where
3968 ___H: SvcStashLocalClientHandler<___T>,
3969 ___T: ::fidl_next::Transport,
3970{
3971 async fn on_event(
3972 handler: &mut ___H,
3973 mut message: ::fidl_next::Message<___T>,
3974 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
3975 match *message.header().ordinal {
3976 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
3977 }
3978 }
3979}
3980
3981#[diagnostic::on_unimplemented(
3982 note = "If {Self} implements the non-local SvcStashServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
3983)]
3984
3985pub trait SvcStashLocalServerHandler<
3989 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
3990 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
3991>
3992{
3993 #[doc = " Store a svc_endpoint in the stash. Stored endpoints will remain in transit,\n since there might not be a server side implementation. The server end\n is retrieved by |SvcStashProvider/Get|.\n"]
3994 fn store(
3995 &mut self,
3996
3997 request: ::fidl_next::Request<svc_stash::Store, ___T>,
3998 ) -> impl ::core::future::Future<Output = ()>;
3999}
4000
4001impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for SvcStash
4002where
4003 ___H: SvcStashLocalServerHandler<___T>,
4004 ___T: ::fidl_next::Transport,
4005 for<'de> crate::wire::SvcStashStoreRequest: ::fidl_next::Decode<
4006 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4007 Constraint = (),
4008 >,
4009{
4010 async fn on_one_way(
4011 handler: &mut ___H,
4012 mut message: ::fidl_next::Message<___T>,
4013 ) -> ::core::result::Result<
4014 (),
4015 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4016 > {
4017 match *message.header().ordinal {
4018 875467318821005424 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
4019 Ok(decoded) => {
4020 handler.store(::fidl_next::Request::from_decoded(decoded)).await;
4021 Ok(())
4022 }
4023 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4024 ordinal: 875467318821005424,
4025 error,
4026 }),
4027 },
4028
4029 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4030 }
4031 }
4032
4033 async fn on_two_way(
4034 handler: &mut ___H,
4035 mut message: ::fidl_next::Message<___T>,
4036 responder: ::fidl_next::protocol::Responder<___T>,
4037 ) -> ::core::result::Result<
4038 (),
4039 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4040 > {
4041 match *message.header().ordinal {
4042 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4043 }
4044 }
4045}
4046
4047pub trait SvcStashClientHandler<
4051 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4052 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4053>
4054{
4055}
4056
4057impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for SvcStash
4058where
4059 ___H: SvcStashClientHandler<___T> + ::core::marker::Send,
4060 ___T: ::fidl_next::Transport,
4061{
4062 async fn on_event(
4063 handler: &mut ___H,
4064 mut message: ::fidl_next::Message<___T>,
4065 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4066 match *message.header().ordinal {
4067 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4068 }
4069 }
4070}
4071
4072pub trait SvcStashServerHandler<
4076 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4077 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4078>
4079{
4080 #[doc = " Store a svc_endpoint in the stash. Stored endpoints will remain in transit,\n since there might not be a server side implementation. The server end\n is retrieved by |SvcStashProvider/Get|.\n"]
4081 fn store(
4082 &mut self,
4083
4084 request: ::fidl_next::Request<svc_stash::Store, ___T>,
4085 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4086}
4087
4088impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for SvcStash
4089where
4090 ___H: SvcStashServerHandler<___T> + ::core::marker::Send,
4091 ___T: ::fidl_next::Transport,
4092 for<'de> crate::wire::SvcStashStoreRequest: ::fidl_next::Decode<
4093 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4094 Constraint = (),
4095 >,
4096{
4097 async fn on_one_way(
4098 handler: &mut ___H,
4099 mut message: ::fidl_next::Message<___T>,
4100 ) -> ::core::result::Result<
4101 (),
4102 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4103 > {
4104 match *message.header().ordinal {
4105 875467318821005424 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
4106 Ok(decoded) => {
4107 handler.store(::fidl_next::Request::from_decoded(decoded)).await;
4108 Ok(())
4109 }
4110 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4111 ordinal: 875467318821005424,
4112 error,
4113 }),
4114 },
4115
4116 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4117 }
4118 }
4119
4120 async fn on_two_way(
4121 handler: &mut ___H,
4122 mut message: ::fidl_next::Message<___T>,
4123 responder: ::fidl_next::protocol::Responder<___T>,
4124 ) -> ::core::result::Result<
4125 (),
4126 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4127 > {
4128 match *message.header().ordinal {
4129 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4130 }
4131 }
4132}
4133
4134impl<___T> SvcStashClientHandler<___T> for ::fidl_next::IgnoreEvents where
4135 ___T: ::fidl_next::Transport
4136{
4137}
4138
4139impl<___H, ___T> SvcStashLocalClientHandler<___T> for ::fidl_next::Local<___H>
4140where
4141 ___H: SvcStashClientHandler<___T>,
4142 ___T: ::fidl_next::Transport,
4143{
4144}
4145
4146impl<___H, ___T> SvcStashLocalServerHandler<___T> for ::fidl_next::Local<___H>
4147where
4148 ___H: SvcStashServerHandler<___T>,
4149 ___T: ::fidl_next::Transport,
4150{
4151 async fn store(&mut self, request: ::fidl_next::Request<svc_stash::Store, ___T>) {
4152 ___H::store(&mut self.0, request).await
4153 }
4154}
4155
4156#[doc = " Protocol for providing the server end of the \'SvcStash\'.\n"]
4158#[derive(PartialEq, Debug)]
4159pub struct SvcStashProvider;
4160
4161impl ::fidl_next::Discoverable for SvcStashProvider {
4162 const PROTOCOL_NAME: &'static str = "fuchsia.boot.SvcStashProvider";
4163}
4164
4165#[cfg(target_os = "fuchsia")]
4166impl ::fidl_next::HasTransport for SvcStashProvider {
4167 type Transport = ::fidl_next::fuchsia::zx::Channel;
4168}
4169
4170pub mod svc_stash_provider {
4171 pub mod prelude {
4172 pub use crate::{
4173 SvcStashProvider, SvcStashProviderClientHandler, SvcStashProviderLocalClientHandler,
4174 SvcStashProviderLocalServerHandler, SvcStashProviderServerHandler, svc_stash_provider,
4175 };
4176
4177 pub use crate::natural::SvcStashProviderGetResponse;
4178 }
4179
4180 pub struct Get;
4181
4182 impl ::fidl_next::Method for Get {
4183 const ORDINAL: u64 = 4072866865090984067;
4184 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4185 ::fidl_next::protocol::Flexibility::Strict;
4186
4187 type Protocol = crate::SvcStashProvider;
4188
4189 type Request = ::fidl_next::wire::EmptyMessageBody;
4190 }
4191
4192 impl ::fidl_next::TwoWayMethod for Get {
4193 type Response = ::fidl_next::wire::Result<
4194 'static,
4195 crate::wire::SvcStashProviderGetResponse,
4196 ::fidl_next::wire::fuchsia::Status,
4197 >;
4198 }
4199
4200 impl<___R> ::fidl_next::Respond<___R> for Get {
4201 type Output = ::core::result::Result<
4202 crate::generic::SvcStashProviderGetResponse<___R>,
4203 ::fidl_next::never::Never,
4204 >;
4205
4206 fn respond(response: ___R) -> Self::Output {
4207 ::core::result::Result::Ok(crate::generic::SvcStashProviderGetResponse {
4208 resource: response,
4209 })
4210 }
4211 }
4212
4213 impl<___R> ::fidl_next::RespondErr<___R> for Get {
4214 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
4215
4216 fn respond_err(response: ___R) -> Self::Output {
4217 ::core::result::Result::Err(response)
4218 }
4219 }
4220
4221 mod ___detail {
4222 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::SvcStashProvider
4223 where
4224 ___T: ::fidl_next::Transport,
4225 {
4226 type Client = SvcStashProviderClient<___T>;
4227 type Server = SvcStashProviderServer<___T>;
4228 }
4229
4230 #[repr(transparent)]
4232 pub struct SvcStashProviderClient<___T: ::fidl_next::Transport> {
4233 #[allow(dead_code)]
4234 client: ::fidl_next::protocol::Client<___T>,
4235 }
4236
4237 impl<___T> SvcStashProviderClient<___T>
4238 where
4239 ___T: ::fidl_next::Transport,
4240 {
4241 #[doc = " Get the SvcStash server endpoint.\n\n There is at most one instance for the system, meaning only the first caller\n may consume the handle.\n"]
4242 pub fn get(&self) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T> {
4243 ::fidl_next::TwoWayFuture::from_untyped(
4244 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
4245 4072866865090984067,
4246 <super::Get as ::fidl_next::Method>::FLEXIBILITY,
4247 (),
4248 ),
4249 )
4250 }
4251 }
4252
4253 #[repr(transparent)]
4255 pub struct SvcStashProviderServer<___T: ::fidl_next::Transport> {
4256 server: ::fidl_next::protocol::Server<___T>,
4257 }
4258
4259 impl<___T> SvcStashProviderServer<___T> where ___T: ::fidl_next::Transport {}
4260 }
4261}
4262
4263#[diagnostic::on_unimplemented(
4264 note = "If {Self} implements the non-local SvcStashProviderClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4265)]
4266
4267pub trait SvcStashProviderLocalClientHandler<
4271 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4272 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4273>
4274{
4275}
4276
4277impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for SvcStashProvider
4278where
4279 ___H: SvcStashProviderLocalClientHandler<___T>,
4280 ___T: ::fidl_next::Transport,
4281{
4282 async fn on_event(
4283 handler: &mut ___H,
4284 mut message: ::fidl_next::Message<___T>,
4285 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4286 match *message.header().ordinal {
4287 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4288 }
4289 }
4290}
4291
4292#[diagnostic::on_unimplemented(
4293 note = "If {Self} implements the non-local SvcStashProviderServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
4294)]
4295
4296pub trait SvcStashProviderLocalServerHandler<
4300 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4301 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4302>
4303{
4304 #[doc = " Get the SvcStash server endpoint.\n\n There is at most one instance for the system, meaning only the first caller\n may consume the handle.\n"]
4305 fn get(
4306 &mut self,
4307
4308 responder: ::fidl_next::Responder<svc_stash_provider::Get, ___T>,
4309 ) -> impl ::core::future::Future<Output = ()>;
4310}
4311
4312impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for SvcStashProvider
4313where
4314 ___H: SvcStashProviderLocalServerHandler<___T>,
4315 ___T: ::fidl_next::Transport,
4316{
4317 async fn on_one_way(
4318 handler: &mut ___H,
4319 mut message: ::fidl_next::Message<___T>,
4320 ) -> ::core::result::Result<
4321 (),
4322 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4323 > {
4324 match *message.header().ordinal {
4325 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4326 }
4327 }
4328
4329 async fn on_two_way(
4330 handler: &mut ___H,
4331 mut message: ::fidl_next::Message<___T>,
4332 responder: ::fidl_next::protocol::Responder<___T>,
4333 ) -> ::core::result::Result<
4334 (),
4335 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4336 > {
4337 match *message.header().ordinal {
4338 4072866865090984067 => {
4339 let responder = ::fidl_next::Responder::from_untyped(responder);
4340
4341 handler.get(responder).await;
4342 Ok(())
4343 }
4344
4345 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4346 }
4347 }
4348}
4349
4350pub trait SvcStashProviderClientHandler<
4354 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4355 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4356>
4357{
4358}
4359
4360impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for SvcStashProvider
4361where
4362 ___H: SvcStashProviderClientHandler<___T> + ::core::marker::Send,
4363 ___T: ::fidl_next::Transport,
4364{
4365 async fn on_event(
4366 handler: &mut ___H,
4367 mut message: ::fidl_next::Message<___T>,
4368 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4369 match *message.header().ordinal {
4370 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4371 }
4372 }
4373}
4374
4375pub trait SvcStashProviderServerHandler<
4379 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4380 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4381>
4382{
4383 #[doc = " Get the SvcStash server endpoint.\n\n There is at most one instance for the system, meaning only the first caller\n may consume the handle.\n"]
4384 fn get(
4385 &mut self,
4386
4387 responder: ::fidl_next::Responder<svc_stash_provider::Get, ___T>,
4388 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4389}
4390
4391impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for SvcStashProvider
4392where
4393 ___H: SvcStashProviderServerHandler<___T> + ::core::marker::Send,
4394 ___T: ::fidl_next::Transport,
4395{
4396 async fn on_one_way(
4397 handler: &mut ___H,
4398 mut message: ::fidl_next::Message<___T>,
4399 ) -> ::core::result::Result<
4400 (),
4401 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4402 > {
4403 match *message.header().ordinal {
4404 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4405 }
4406 }
4407
4408 async fn on_two_way(
4409 handler: &mut ___H,
4410 mut message: ::fidl_next::Message<___T>,
4411 responder: ::fidl_next::protocol::Responder<___T>,
4412 ) -> ::core::result::Result<
4413 (),
4414 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4415 > {
4416 match *message.header().ordinal {
4417 4072866865090984067 => {
4418 let responder = ::fidl_next::Responder::from_untyped(responder);
4419
4420 handler.get(responder).await;
4421 Ok(())
4422 }
4423
4424 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4425 }
4426 }
4427}
4428
4429impl<___T> SvcStashProviderClientHandler<___T> for ::fidl_next::IgnoreEvents where
4430 ___T: ::fidl_next::Transport
4431{
4432}
4433
4434impl<___H, ___T> SvcStashProviderLocalClientHandler<___T> for ::fidl_next::Local<___H>
4435where
4436 ___H: SvcStashProviderClientHandler<___T>,
4437 ___T: ::fidl_next::Transport,
4438{
4439}
4440
4441impl<___H, ___T> SvcStashProviderLocalServerHandler<___T> for ::fidl_next::Local<___H>
4442where
4443 ___H: SvcStashProviderServerHandler<___T>,
4444 ___T: ::fidl_next::Transport,
4445{
4446 async fn get(&mut self, responder: ::fidl_next::Responder<svc_stash_provider::Get, ___T>) {
4447 ___H::get(&mut self.0, responder).await
4448 }
4449}
4450
4451#[doc = " Protocol for communication between `userboot` and the process booted by userboot.\n\n The userboot process will act as a client, pipelining requests containing information and/or handles that might\n be useful for the booted process. The booted process, or whoever processes the server endpoint of this protocol,\n will then process the pipelined requests from userboot.\n\n TODO(https://fxbug.dev/354275371): Move handles not participating in the bootstrap process to this protocol.\n"]
4453#[derive(PartialEq, Debug)]
4454pub struct Userboot;
4455
4456#[cfg(target_os = "fuchsia")]
4457impl ::fidl_next::HasTransport for Userboot {
4458 type Transport = ::fidl_next::fuchsia::zx::Channel;
4459}
4460
4461pub mod userboot {
4462 pub mod prelude {
4463 pub use crate::{
4464 Userboot, UserbootClientHandler, UserbootLocalClientHandler,
4465 UserbootLocalServerHandler, UserbootServerHandler, userboot,
4466 };
4467
4468 pub use crate::natural::UserbootPostBootfsFilesRequest;
4469
4470 pub use crate::natural::UserbootPostStashSvcRequest;
4471 }
4472
4473 pub struct PostBootfsFiles;
4474
4475 impl ::fidl_next::Method for PostBootfsFiles {
4476 const ORDINAL: u64 = 2985117035928536724;
4477 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4478 ::fidl_next::protocol::Flexibility::Strict;
4479
4480 type Protocol = crate::Userboot;
4481
4482 type Request = crate::wire::UserbootPostBootfsFilesRequest<'static>;
4483 }
4484
4485 pub struct PostStashSvc;
4486
4487 impl ::fidl_next::Method for PostStashSvc {
4488 const ORDINAL: u64 = 5795797909204819628;
4489 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4490 ::fidl_next::protocol::Flexibility::Strict;
4491
4492 type Protocol = crate::Userboot;
4493
4494 type Request = crate::wire::UserbootPostStashSvcRequest;
4495 }
4496
4497 mod ___detail {
4498 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Userboot
4499 where
4500 ___T: ::fidl_next::Transport,
4501 {
4502 type Client = UserbootClient<___T>;
4503 type Server = UserbootServer<___T>;
4504 }
4505
4506 #[repr(transparent)]
4508 pub struct UserbootClient<___T: ::fidl_next::Transport> {
4509 #[allow(dead_code)]
4510 client: ::fidl_next::protocol::Client<___T>,
4511 }
4512
4513 impl<___T> UserbootClient<___T>
4514 where
4515 ___T: ::fidl_next::Transport,
4516 {
4517 #[doc = " Posts a set of `BootfsFileVmo` that were used for launching the `userboot.next=` program and are no longer\n available in the big BootfsVmo.\n\n Messages will only become available after the `Userboot` protocol client end (userboot\'s handle)\n has been closed.\n"]
4518 pub fn post_bootfs_files(
4519 &self,
4520
4521 files: impl ::fidl_next::Encode<
4522 ::fidl_next::wire::Vector<'static, crate::wire::BootfsFileVmo>,
4523 <___T as ::fidl_next::Transport>::SendBuffer,
4524 >,
4525 ) -> ::fidl_next::SendFuture<'_, ___T>
4526 where
4527 <___T as ::fidl_next::Transport>::SendBuffer:
4528 ::fidl_next::encoder::InternalHandleEncoder,
4529 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4530 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
4531 {
4532 self.post_bootfs_files_with(crate::generic::UserbootPostBootfsFilesRequest {
4533 files,
4534 })
4535 }
4536
4537 #[doc = " Posts a set of `BootfsFileVmo` that were used for launching the `userboot.next=` program and are no longer\n available in the big BootfsVmo.\n\n Messages will only become available after the `Userboot` protocol client end (userboot\'s handle)\n has been closed.\n"]
4538 pub fn post_bootfs_files_with<___R>(
4539 &self,
4540 request: ___R,
4541 ) -> ::fidl_next::SendFuture<'_, ___T>
4542 where
4543 ___R: ::fidl_next::Encode<
4544 crate::wire::UserbootPostBootfsFilesRequest<'static>,
4545 <___T as ::fidl_next::Transport>::SendBuffer,
4546 >,
4547 {
4548 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
4549 2985117035928536724,
4550 <super::PostBootfsFiles as ::fidl_next::Method>::FLEXIBILITY,
4551 request,
4552 ))
4553 }
4554
4555 #[doc = " Posts `svc_stash` server endpoint. For more information refer to `fuchsia.boot.SvcStash`.\n"]
4556 pub fn post_stash_svc(
4557 &self,
4558
4559 stash_svc_endpoint: impl ::fidl_next::Encode<
4560 ::fidl_next::ServerEnd<crate::SvcStash, ::fidl_next::wire::fuchsia::Channel>,
4561 <___T as ::fidl_next::Transport>::SendBuffer,
4562 >,
4563 ) -> ::fidl_next::SendFuture<'_, ___T>
4564 where
4565 <___T as ::fidl_next::Transport>::SendBuffer:
4566 ::fidl_next::encoder::InternalHandleEncoder,
4567 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
4568 {
4569 self.post_stash_svc_with(crate::generic::UserbootPostStashSvcRequest {
4570 stash_svc_endpoint,
4571 })
4572 }
4573
4574 #[doc = " Posts `svc_stash` server endpoint. For more information refer to `fuchsia.boot.SvcStash`.\n"]
4575 pub fn post_stash_svc_with<___R>(
4576 &self,
4577 request: ___R,
4578 ) -> ::fidl_next::SendFuture<'_, ___T>
4579 where
4580 ___R: ::fidl_next::Encode<
4581 crate::wire::UserbootPostStashSvcRequest,
4582 <___T as ::fidl_next::Transport>::SendBuffer,
4583 >,
4584 {
4585 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
4586 5795797909204819628,
4587 <super::PostStashSvc as ::fidl_next::Method>::FLEXIBILITY,
4588 request,
4589 ))
4590 }
4591 }
4592
4593 #[repr(transparent)]
4595 pub struct UserbootServer<___T: ::fidl_next::Transport> {
4596 server: ::fidl_next::protocol::Server<___T>,
4597 }
4598
4599 impl<___T> UserbootServer<___T> where ___T: ::fidl_next::Transport {}
4600 }
4601}
4602
4603#[diagnostic::on_unimplemented(
4604 note = "If {Self} implements the non-local UserbootClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4605)]
4606
4607pub trait UserbootLocalClientHandler<
4611 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4612 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4613>
4614{
4615}
4616
4617impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Userboot
4618where
4619 ___H: UserbootLocalClientHandler<___T>,
4620 ___T: ::fidl_next::Transport,
4621{
4622 async fn on_event(
4623 handler: &mut ___H,
4624 mut message: ::fidl_next::Message<___T>,
4625 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4626 match *message.header().ordinal {
4627 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4628 }
4629 }
4630}
4631
4632#[diagnostic::on_unimplemented(
4633 note = "If {Self} implements the non-local UserbootServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
4634)]
4635
4636pub trait UserbootLocalServerHandler<
4640 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4641 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4642>
4643{
4644 #[doc = " Posts a set of `BootfsFileVmo` that were used for launching the `userboot.next=` program and are no longer\n available in the big BootfsVmo.\n\n Messages will only become available after the `Userboot` protocol client end (userboot\'s handle)\n has been closed.\n"]
4645 fn post_bootfs_files(
4646 &mut self,
4647
4648 request: ::fidl_next::Request<userboot::PostBootfsFiles, ___T>,
4649 ) -> impl ::core::future::Future<Output = ()>;
4650
4651 #[doc = " Posts `svc_stash` server endpoint. For more information refer to `fuchsia.boot.SvcStash`.\n"]
4652 fn post_stash_svc(
4653 &mut self,
4654
4655 request: ::fidl_next::Request<userboot::PostStashSvc, ___T>,
4656 ) -> impl ::core::future::Future<Output = ()>;
4657}
4658
4659impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Userboot
4660where
4661 ___H: UserbootLocalServerHandler<___T>,
4662 ___T: ::fidl_next::Transport,
4663 for<'de> crate::wire::UserbootPostBootfsFilesRequest<'de>: ::fidl_next::Decode<
4664 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4665 Constraint = (),
4666 >,
4667 for<'de> crate::wire::UserbootPostStashSvcRequest: ::fidl_next::Decode<
4668 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4669 Constraint = (),
4670 >,
4671{
4672 async fn on_one_way(
4673 handler: &mut ___H,
4674 mut message: ::fidl_next::Message<___T>,
4675 ) -> ::core::result::Result<
4676 (),
4677 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4678 > {
4679 match *message.header().ordinal {
4680 2985117035928536724 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
4681 Ok(decoded) => {
4682 handler.post_bootfs_files(::fidl_next::Request::from_decoded(decoded)).await;
4683 Ok(())
4684 }
4685 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4686 ordinal: 2985117035928536724,
4687 error,
4688 }),
4689 },
4690
4691 5795797909204819628 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
4692 Ok(decoded) => {
4693 handler.post_stash_svc(::fidl_next::Request::from_decoded(decoded)).await;
4694 Ok(())
4695 }
4696 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4697 ordinal: 5795797909204819628,
4698 error,
4699 }),
4700 },
4701
4702 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4703 }
4704 }
4705
4706 async fn on_two_way(
4707 handler: &mut ___H,
4708 mut message: ::fidl_next::Message<___T>,
4709 responder: ::fidl_next::protocol::Responder<___T>,
4710 ) -> ::core::result::Result<
4711 (),
4712 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4713 > {
4714 match *message.header().ordinal {
4715 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4716 }
4717 }
4718}
4719
4720pub trait UserbootClientHandler<
4724 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4725 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4726>
4727{
4728}
4729
4730impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Userboot
4731where
4732 ___H: UserbootClientHandler<___T> + ::core::marker::Send,
4733 ___T: ::fidl_next::Transport,
4734{
4735 async fn on_event(
4736 handler: &mut ___H,
4737 mut message: ::fidl_next::Message<___T>,
4738 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4739 match *message.header().ordinal {
4740 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4741 }
4742 }
4743}
4744
4745pub trait UserbootServerHandler<
4749 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4750 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4751>
4752{
4753 #[doc = " Posts a set of `BootfsFileVmo` that were used for launching the `userboot.next=` program and are no longer\n available in the big BootfsVmo.\n\n Messages will only become available after the `Userboot` protocol client end (userboot\'s handle)\n has been closed.\n"]
4754 fn post_bootfs_files(
4755 &mut self,
4756
4757 request: ::fidl_next::Request<userboot::PostBootfsFiles, ___T>,
4758 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4759
4760 #[doc = " Posts `svc_stash` server endpoint. For more information refer to `fuchsia.boot.SvcStash`.\n"]
4761 fn post_stash_svc(
4762 &mut self,
4763
4764 request: ::fidl_next::Request<userboot::PostStashSvc, ___T>,
4765 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4766}
4767
4768impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Userboot
4769where
4770 ___H: UserbootServerHandler<___T> + ::core::marker::Send,
4771 ___T: ::fidl_next::Transport,
4772 for<'de> crate::wire::UserbootPostBootfsFilesRequest<'de>: ::fidl_next::Decode<
4773 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4774 Constraint = (),
4775 >,
4776 for<'de> crate::wire::UserbootPostStashSvcRequest: ::fidl_next::Decode<
4777 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4778 Constraint = (),
4779 >,
4780{
4781 async fn on_one_way(
4782 handler: &mut ___H,
4783 mut message: ::fidl_next::Message<___T>,
4784 ) -> ::core::result::Result<
4785 (),
4786 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4787 > {
4788 match *message.header().ordinal {
4789 2985117035928536724 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
4790 Ok(decoded) => {
4791 handler.post_bootfs_files(::fidl_next::Request::from_decoded(decoded)).await;
4792 Ok(())
4793 }
4794 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4795 ordinal: 2985117035928536724,
4796 error,
4797 }),
4798 },
4799
4800 5795797909204819628 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
4801 Ok(decoded) => {
4802 handler.post_stash_svc(::fidl_next::Request::from_decoded(decoded)).await;
4803 Ok(())
4804 }
4805 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4806 ordinal: 5795797909204819628,
4807 error,
4808 }),
4809 },
4810
4811 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4812 }
4813 }
4814
4815 async fn on_two_way(
4816 handler: &mut ___H,
4817 mut message: ::fidl_next::Message<___T>,
4818 responder: ::fidl_next::protocol::Responder<___T>,
4819 ) -> ::core::result::Result<
4820 (),
4821 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4822 > {
4823 match *message.header().ordinal {
4824 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4825 }
4826 }
4827}
4828
4829impl<___T> UserbootClientHandler<___T> for ::fidl_next::IgnoreEvents where
4830 ___T: ::fidl_next::Transport
4831{
4832}
4833
4834impl<___H, ___T> UserbootLocalClientHandler<___T> for ::fidl_next::Local<___H>
4835where
4836 ___H: UserbootClientHandler<___T>,
4837 ___T: ::fidl_next::Transport,
4838{
4839}
4840
4841impl<___H, ___T> UserbootLocalServerHandler<___T> for ::fidl_next::Local<___H>
4842where
4843 ___H: UserbootServerHandler<___T>,
4844 ___T: ::fidl_next::Transport,
4845{
4846 async fn post_bootfs_files(
4847 &mut self,
4848
4849 request: ::fidl_next::Request<userboot::PostBootfsFiles, ___T>,
4850 ) {
4851 ___H::post_bootfs_files(&mut self.0, request).await
4852 }
4853
4854 async fn post_stash_svc(
4855 &mut self,
4856
4857 request: ::fidl_next::Request<userboot::PostStashSvc, ___T>,
4858 ) {
4859 ___H::post_stash_svc(&mut self.0, request).await
4860 }
4861}
4862
4863#[doc = " Protocol for providing the kernel log, writable.\n"]
4865#[derive(PartialEq, Debug)]
4866pub struct WriteOnlyLog;
4867
4868impl ::fidl_next::Discoverable for WriteOnlyLog {
4869 const PROTOCOL_NAME: &'static str = "fuchsia.boot.WriteOnlyLog";
4870}
4871
4872#[cfg(target_os = "fuchsia")]
4873impl ::fidl_next::HasTransport for WriteOnlyLog {
4874 type Transport = ::fidl_next::fuchsia::zx::Channel;
4875}
4876
4877pub mod write_only_log {
4878 pub mod prelude {
4879 pub use crate::{
4880 WriteOnlyLog, WriteOnlyLogClientHandler, WriteOnlyLogLocalClientHandler,
4881 WriteOnlyLogLocalServerHandler, WriteOnlyLogServerHandler, write_only_log,
4882 };
4883
4884 pub use crate::natural::WriteOnlyLogGetResponse;
4885 }
4886
4887 pub struct Get;
4888
4889 impl ::fidl_next::Method for Get {
4890 const ORDINAL: u64 = 312892061866864647;
4891 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4892 ::fidl_next::protocol::Flexibility::Strict;
4893
4894 type Protocol = crate::WriteOnlyLog;
4895
4896 type Request = ::fidl_next::wire::EmptyMessageBody;
4897 }
4898
4899 impl ::fidl_next::TwoWayMethod for Get {
4900 type Response = ::fidl_next::wire::Strict<crate::wire::WriteOnlyLogGetResponse>;
4901 }
4902
4903 impl<___R> ::fidl_next::Respond<___R> for Get {
4904 type Output = ::fidl_next::Strict<crate::generic::WriteOnlyLogGetResponse<___R>>;
4905
4906 fn respond(response: ___R) -> Self::Output {
4907 ::fidl_next::Strict(crate::generic::WriteOnlyLogGetResponse { log: response })
4908 }
4909 }
4910
4911 mod ___detail {
4912 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::WriteOnlyLog
4913 where
4914 ___T: ::fidl_next::Transport,
4915 {
4916 type Client = WriteOnlyLogClient<___T>;
4917 type Server = WriteOnlyLogServer<___T>;
4918 }
4919
4920 #[repr(transparent)]
4922 pub struct WriteOnlyLogClient<___T: ::fidl_next::Transport> {
4923 #[allow(dead_code)]
4924 client: ::fidl_next::protocol::Client<___T>,
4925 }
4926
4927 impl<___T> WriteOnlyLogClient<___T>
4928 where
4929 ___T: ::fidl_next::Transport,
4930 {
4931 #[doc = " Get write-only handle to the kernel `log`.\n"]
4932 pub fn get(&self) -> ::fidl_next::TwoWayFuture<'_, super::Get, ___T> {
4933 ::fidl_next::TwoWayFuture::from_untyped(
4934 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
4935 312892061866864647,
4936 <super::Get as ::fidl_next::Method>::FLEXIBILITY,
4937 (),
4938 ),
4939 )
4940 }
4941 }
4942
4943 #[repr(transparent)]
4945 pub struct WriteOnlyLogServer<___T: ::fidl_next::Transport> {
4946 server: ::fidl_next::protocol::Server<___T>,
4947 }
4948
4949 impl<___T> WriteOnlyLogServer<___T> where ___T: ::fidl_next::Transport {}
4950 }
4951}
4952
4953#[diagnostic::on_unimplemented(
4954 note = "If {Self} implements the non-local WriteOnlyLogClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4955)]
4956
4957pub trait WriteOnlyLogLocalClientHandler<
4961 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4962 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4963>
4964{
4965}
4966
4967impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for WriteOnlyLog
4968where
4969 ___H: WriteOnlyLogLocalClientHandler<___T>,
4970 ___T: ::fidl_next::Transport,
4971{
4972 async fn on_event(
4973 handler: &mut ___H,
4974 mut message: ::fidl_next::Message<___T>,
4975 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4976 match *message.header().ordinal {
4977 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4978 }
4979 }
4980}
4981
4982#[diagnostic::on_unimplemented(
4983 note = "If {Self} implements the non-local WriteOnlyLogServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
4984)]
4985
4986pub trait WriteOnlyLogLocalServerHandler<
4990 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4991 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4992>
4993{
4994 #[doc = " Get write-only handle to the kernel `log`.\n"]
4995 fn get(
4996 &mut self,
4997
4998 responder: ::fidl_next::Responder<write_only_log::Get, ___T>,
4999 ) -> impl ::core::future::Future<Output = ()>;
5000}
5001
5002impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for WriteOnlyLog
5003where
5004 ___H: WriteOnlyLogLocalServerHandler<___T>,
5005 ___T: ::fidl_next::Transport,
5006{
5007 async fn on_one_way(
5008 handler: &mut ___H,
5009 mut message: ::fidl_next::Message<___T>,
5010 ) -> ::core::result::Result<
5011 (),
5012 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5013 > {
5014 match *message.header().ordinal {
5015 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5016 }
5017 }
5018
5019 async fn on_two_way(
5020 handler: &mut ___H,
5021 mut message: ::fidl_next::Message<___T>,
5022 responder: ::fidl_next::protocol::Responder<___T>,
5023 ) -> ::core::result::Result<
5024 (),
5025 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5026 > {
5027 match *message.header().ordinal {
5028 312892061866864647 => {
5029 let responder = ::fidl_next::Responder::from_untyped(responder);
5030
5031 handler.get(responder).await;
5032 Ok(())
5033 }
5034
5035 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5036 }
5037 }
5038}
5039
5040pub trait WriteOnlyLogClientHandler<
5044 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5045 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5046>
5047{
5048}
5049
5050impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for WriteOnlyLog
5051where
5052 ___H: WriteOnlyLogClientHandler<___T> + ::core::marker::Send,
5053 ___T: ::fidl_next::Transport,
5054{
5055 async fn on_event(
5056 handler: &mut ___H,
5057 mut message: ::fidl_next::Message<___T>,
5058 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5059 match *message.header().ordinal {
5060 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5061 }
5062 }
5063}
5064
5065pub trait WriteOnlyLogServerHandler<
5069 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5070 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5071>
5072{
5073 #[doc = " Get write-only handle to the kernel `log`.\n"]
5074 fn get(
5075 &mut self,
5076
5077 responder: ::fidl_next::Responder<write_only_log::Get, ___T>,
5078 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5079}
5080
5081impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for WriteOnlyLog
5082where
5083 ___H: WriteOnlyLogServerHandler<___T> + ::core::marker::Send,
5084 ___T: ::fidl_next::Transport,
5085{
5086 async fn on_one_way(
5087 handler: &mut ___H,
5088 mut message: ::fidl_next::Message<___T>,
5089 ) -> ::core::result::Result<
5090 (),
5091 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5092 > {
5093 match *message.header().ordinal {
5094 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5095 }
5096 }
5097
5098 async fn on_two_way(
5099 handler: &mut ___H,
5100 mut message: ::fidl_next::Message<___T>,
5101 responder: ::fidl_next::protocol::Responder<___T>,
5102 ) -> ::core::result::Result<
5103 (),
5104 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5105 > {
5106 match *message.header().ordinal {
5107 312892061866864647 => {
5108 let responder = ::fidl_next::Responder::from_untyped(responder);
5109
5110 handler.get(responder).await;
5111 Ok(())
5112 }
5113
5114 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5115 }
5116 }
5117}
5118
5119impl<___T> WriteOnlyLogClientHandler<___T> for ::fidl_next::IgnoreEvents where
5120 ___T: ::fidl_next::Transport
5121{
5122}
5123
5124impl<___H, ___T> WriteOnlyLogLocalClientHandler<___T> for ::fidl_next::Local<___H>
5125where
5126 ___H: WriteOnlyLogClientHandler<___T>,
5127 ___T: ::fidl_next::Transport,
5128{
5129}
5130
5131impl<___H, ___T> WriteOnlyLogLocalServerHandler<___T> for ::fidl_next::Local<___H>
5132where
5133 ___H: WriteOnlyLogServerHandler<___T>,
5134 ___T: ::fidl_next::Transport,
5135{
5136 async fn get(&mut self, responder: ::fidl_next::Responder<write_only_log::Get, ___T>) {
5137 ___H::get(&mut self.0, responder).await
5138 }
5139}
5140
5141pub use fidl_next_common_fuchsia_boot::*;