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_test_conformance::natural::*;
8
9 #[derive(Debug, PartialEq)]
10 pub struct AlternatingHandlesAndFailures {
11 pub h1: ::fidl_next::fuchsia::zx::NullableHandle,
12
13 pub failure_trigger1: ::std::string::String,
14
15 pub h2: ::fidl_next::fuchsia::zx::NullableHandle,
16
17 pub failure_trigger2: ::std::string::String,
18
19 pub h3: ::fidl_next::fuchsia::zx::NullableHandle,
20 }
21
22 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AlternatingHandlesAndFailures<'static>, ___E>
23 for AlternatingHandlesAndFailures
24 where
25 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
26 ___E: ::fidl_next::Encoder,
27 ___E: ::fidl_next::fuchsia::HandleEncoder,
28 {
29 #[inline]
30 fn encode(
31 self,
32 encoder_: &mut ___E,
33 out_: &mut ::core::mem::MaybeUninit<
34 crate::wire::AlternatingHandlesAndFailures<'static>,
35 >,
36 _: (),
37 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
38 ::fidl_next::munge! {
39 let crate::wire::AlternatingHandlesAndFailures {
40 h1,
41 failure_trigger1,
42 h2,
43 failure_trigger2,
44 h3,
45
46 } = out_;
47 }
48
49 ::fidl_next::Encode::encode(self.h1, encoder_, h1, ())?;
50
51 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h1.as_mut_ptr()) };
52
53 ::fidl_next::Encode::encode(self.failure_trigger1, encoder_, failure_trigger1, 1)?;
54
55 let mut _field =
56 unsafe { ::fidl_next::Slot::new_unchecked(failure_trigger1.as_mut_ptr()) };
57 ::fidl_next::Constrained::validate(_field, 1)?;
58
59 ::fidl_next::Encode::encode(self.h2, encoder_, h2, ())?;
60
61 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h2.as_mut_ptr()) };
62
63 ::fidl_next::Encode::encode(self.failure_trigger2, encoder_, failure_trigger2, 1)?;
64
65 let mut _field =
66 unsafe { ::fidl_next::Slot::new_unchecked(failure_trigger2.as_mut_ptr()) };
67 ::fidl_next::Constrained::validate(_field, 1)?;
68
69 ::fidl_next::Encode::encode(self.h3, encoder_, h3, ())?;
70
71 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h3.as_mut_ptr()) };
72
73 Ok(())
74 }
75 }
76
77 unsafe impl<___E>
78 ::fidl_next::EncodeOption<
79 ::fidl_next::wire::Box<'static, crate::wire::AlternatingHandlesAndFailures<'static>>,
80 ___E,
81 > for AlternatingHandlesAndFailures
82 where
83 ___E: ::fidl_next::Encoder + ?Sized,
84 AlternatingHandlesAndFailures:
85 ::fidl_next::Encode<crate::wire::AlternatingHandlesAndFailures<'static>, ___E>,
86 {
87 #[inline]
88 fn encode_option(
89 this: ::core::option::Option<Self>,
90 encoder: &mut ___E,
91 out: &mut ::core::mem::MaybeUninit<
92 ::fidl_next::wire::Box<
93 'static,
94 crate::wire::AlternatingHandlesAndFailures<'static>,
95 >,
96 >,
97 _: (),
98 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
99 if let Some(inner) = this {
100 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
101 ::fidl_next::wire::Box::encode_present(out);
102 } else {
103 ::fidl_next::wire::Box::encode_absent(out);
104 }
105
106 Ok(())
107 }
108 }
109
110 impl<'de> ::fidl_next::FromWire<crate::wire::AlternatingHandlesAndFailures<'de>>
111 for AlternatingHandlesAndFailures
112 {
113 #[inline]
114 fn from_wire(wire: crate::wire::AlternatingHandlesAndFailures<'de>) -> Self {
115 Self {
116 h1: ::fidl_next::FromWire::from_wire(wire.h1),
117
118 failure_trigger1: ::fidl_next::FromWire::from_wire(wire.failure_trigger1),
119
120 h2: ::fidl_next::FromWire::from_wire(wire.h2),
121
122 failure_trigger2: ::fidl_next::FromWire::from_wire(wire.failure_trigger2),
123
124 h3: ::fidl_next::FromWire::from_wire(wire.h3),
125 }
126 }
127 }
128
129 #[derive(Debug, PartialEq)]
130 #[repr(C)]
131 pub struct ArrayOfArrayOfNonnullableHandles {
132 pub handles: [[::fidl_next::fuchsia::zx::NullableHandle; 3]; 4],
133 }
134
135 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ArrayOfArrayOfNonnullableHandles, ___E>
136 for ArrayOfArrayOfNonnullableHandles
137 where
138 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
139 ___E: ::fidl_next::fuchsia::HandleEncoder,
140 {
141 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
142 Self,
143 crate::wire::ArrayOfArrayOfNonnullableHandles,
144 > = unsafe {
145 ::fidl_next::CopyOptimization::enable_if(
146 true
147
148 && <
149 [[::fidl_next::fuchsia::zx::NullableHandle; 3]; 4] as ::fidl_next::Encode<[[::fidl_next::wire::fuchsia::NullableHandle; 3]; 4], ___E>
150 >::COPY_OPTIMIZATION.is_enabled()
151
152 )
153 };
154
155 #[inline]
156 fn encode(
157 self,
158 encoder_: &mut ___E,
159 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfArrayOfNonnullableHandles>,
160 _: (),
161 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
162 ::fidl_next::munge! {
163 let crate::wire::ArrayOfArrayOfNonnullableHandles {
164 handles,
165
166 } = out_;
167 }
168
169 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
170
171 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handles.as_mut_ptr()) };
172
173 Ok(())
174 }
175 }
176
177 unsafe impl<___E>
178 ::fidl_next::EncodeOption<
179 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfArrayOfNonnullableHandles>,
180 ___E,
181 > for ArrayOfArrayOfNonnullableHandles
182 where
183 ___E: ::fidl_next::Encoder + ?Sized,
184 ArrayOfArrayOfNonnullableHandles:
185 ::fidl_next::Encode<crate::wire::ArrayOfArrayOfNonnullableHandles, ___E>,
186 {
187 #[inline]
188 fn encode_option(
189 this: ::core::option::Option<Self>,
190 encoder: &mut ___E,
191 out: &mut ::core::mem::MaybeUninit<
192 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfArrayOfNonnullableHandles>,
193 >,
194 _: (),
195 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
196 if let Some(inner) = this {
197 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
198 ::fidl_next::wire::Box::encode_present(out);
199 } else {
200 ::fidl_next::wire::Box::encode_absent(out);
201 }
202
203 Ok(())
204 }
205 }
206
207 impl ::fidl_next::FromWire<crate::wire::ArrayOfArrayOfNonnullableHandles>
208 for ArrayOfArrayOfNonnullableHandles
209 {
210 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
211 crate::wire::ArrayOfArrayOfNonnullableHandles,
212 Self,
213 > = unsafe {
214 ::fidl_next::CopyOptimization::enable_if(
215 true
216
217 && <
218 [[::fidl_next::fuchsia::zx::NullableHandle; 3]; 4] as ::fidl_next::FromWire<[[::fidl_next::wire::fuchsia::NullableHandle; 3]; 4]>
219 >::COPY_OPTIMIZATION.is_enabled()
220
221 )
222 };
223
224 #[inline]
225 fn from_wire(wire: crate::wire::ArrayOfArrayOfNonnullableHandles) -> Self {
226 Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
227 }
228 }
229
230 #[derive(Debug, PartialEq)]
231 #[repr(C)]
232 pub struct ArrayOfHandles {
233 pub a: [::fidl_next::fuchsia::zx::NullableHandle; 3],
234 }
235
236 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ArrayOfHandles, ___E> for ArrayOfHandles
237 where
238 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
239 ___E: ::fidl_next::fuchsia::HandleEncoder,
240 {
241 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ArrayOfHandles> = unsafe {
242 ::fidl_next::CopyOptimization::enable_if(
243 true && <[::fidl_next::fuchsia::zx::NullableHandle; 3] as ::fidl_next::Encode<
244 [::fidl_next::wire::fuchsia::NullableHandle; 3],
245 ___E,
246 >>::COPY_OPTIMIZATION
247 .is_enabled(),
248 )
249 };
250
251 #[inline]
252 fn encode(
253 self,
254 encoder_: &mut ___E,
255 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfHandles>,
256 _: (),
257 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
258 ::fidl_next::munge! {
259 let crate::wire::ArrayOfHandles {
260 a,
261
262 } = out_;
263 }
264
265 ::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
266
267 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
268
269 Ok(())
270 }
271 }
272
273 unsafe impl<___E>
274 ::fidl_next::EncodeOption<
275 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfHandles>,
276 ___E,
277 > for ArrayOfHandles
278 where
279 ___E: ::fidl_next::Encoder + ?Sized,
280 ArrayOfHandles: ::fidl_next::Encode<crate::wire::ArrayOfHandles, ___E>,
281 {
282 #[inline]
283 fn encode_option(
284 this: ::core::option::Option<Self>,
285 encoder: &mut ___E,
286 out: &mut ::core::mem::MaybeUninit<
287 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfHandles>,
288 >,
289 _: (),
290 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
291 if let Some(inner) = this {
292 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
293 ::fidl_next::wire::Box::encode_present(out);
294 } else {
295 ::fidl_next::wire::Box::encode_absent(out);
296 }
297
298 Ok(())
299 }
300 }
301
302 impl ::fidl_next::FromWire<crate::wire::ArrayOfHandles> for ArrayOfHandles {
303 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ArrayOfHandles, Self> = unsafe {
304 ::fidl_next::CopyOptimization::enable_if(
305 true && <[::fidl_next::fuchsia::zx::NullableHandle; 3] as ::fidl_next::FromWire<
306 [::fidl_next::wire::fuchsia::NullableHandle; 3],
307 >>::COPY_OPTIMIZATION
308 .is_enabled(),
309 )
310 };
311
312 #[inline]
313 fn from_wire(wire: crate::wire::ArrayOfHandles) -> Self {
314 Self { a: ::fidl_next::FromWire::from_wire(wire.a) }
315 }
316 }
317
318 #[derive(Debug, PartialEq)]
319 #[repr(C)]
320 pub struct ArrayOfNonnullableHandles {
321 pub handles: [::fidl_next::fuchsia::zx::NullableHandle; 4],
322 }
323
324 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ArrayOfNonnullableHandles, ___E>
325 for ArrayOfNonnullableHandles
326 where
327 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
328 ___E: ::fidl_next::fuchsia::HandleEncoder,
329 {
330 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
331 Self,
332 crate::wire::ArrayOfNonnullableHandles,
333 > = unsafe {
334 ::fidl_next::CopyOptimization::enable_if(
335 true && <[::fidl_next::fuchsia::zx::NullableHandle; 4] as ::fidl_next::Encode<
336 [::fidl_next::wire::fuchsia::NullableHandle; 4],
337 ___E,
338 >>::COPY_OPTIMIZATION
339 .is_enabled(),
340 )
341 };
342
343 #[inline]
344 fn encode(
345 self,
346 encoder_: &mut ___E,
347 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfNonnullableHandles>,
348 _: (),
349 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
350 ::fidl_next::munge! {
351 let crate::wire::ArrayOfNonnullableHandles {
352 handles,
353
354 } = out_;
355 }
356
357 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
358
359 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handles.as_mut_ptr()) };
360
361 Ok(())
362 }
363 }
364
365 unsafe impl<___E>
366 ::fidl_next::EncodeOption<
367 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfNonnullableHandles>,
368 ___E,
369 > for ArrayOfNonnullableHandles
370 where
371 ___E: ::fidl_next::Encoder + ?Sized,
372 ArrayOfNonnullableHandles:
373 ::fidl_next::Encode<crate::wire::ArrayOfNonnullableHandles, ___E>,
374 {
375 #[inline]
376 fn encode_option(
377 this: ::core::option::Option<Self>,
378 encoder: &mut ___E,
379 out: &mut ::core::mem::MaybeUninit<
380 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfNonnullableHandles>,
381 >,
382 _: (),
383 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
384 if let Some(inner) = this {
385 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
386 ::fidl_next::wire::Box::encode_present(out);
387 } else {
388 ::fidl_next::wire::Box::encode_absent(out);
389 }
390
391 Ok(())
392 }
393 }
394
395 impl ::fidl_next::FromWire<crate::wire::ArrayOfNonnullableHandles> for ArrayOfNonnullableHandles {
396 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
397 crate::wire::ArrayOfNonnullableHandles,
398 Self,
399 > = unsafe {
400 ::fidl_next::CopyOptimization::enable_if(
401 true && <[::fidl_next::fuchsia::zx::NullableHandle; 4] as ::fidl_next::FromWire<
402 [::fidl_next::wire::fuchsia::NullableHandle; 4],
403 >>::COPY_OPTIMIZATION
404 .is_enabled(),
405 )
406 };
407
408 #[inline]
409 fn from_wire(wire: crate::wire::ArrayOfNonnullableHandles) -> Self {
410 Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
411 }
412 }
413
414 #[derive(Debug, PartialEq)]
415 #[repr(C)]
416 pub struct ArrayOfNullableHandles {
417 pub handles: [::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>; 5],
418 }
419
420 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ArrayOfNullableHandles, ___E>
421 for ArrayOfNullableHandles
422 where
423 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
424 ___E: ::fidl_next::fuchsia::HandleEncoder,
425 {
426 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
427 Self,
428 crate::wire::ArrayOfNullableHandles,
429 > = unsafe {
430 ::fidl_next::CopyOptimization::enable_if(
431 true
432
433 && <
434 [::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>; 5] as ::fidl_next::Encode<[::fidl_next::wire::fuchsia::OptionalNullableHandle; 5], ___E>
435 >::COPY_OPTIMIZATION.is_enabled()
436
437 )
438 };
439
440 #[inline]
441 fn encode(
442 self,
443 encoder_: &mut ___E,
444 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfNullableHandles>,
445 _: (),
446 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
447 ::fidl_next::munge! {
448 let crate::wire::ArrayOfNullableHandles {
449 handles,
450
451 } = out_;
452 }
453
454 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
455
456 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handles.as_mut_ptr()) };
457
458 Ok(())
459 }
460 }
461
462 unsafe impl<___E>
463 ::fidl_next::EncodeOption<
464 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfNullableHandles>,
465 ___E,
466 > for ArrayOfNullableHandles
467 where
468 ___E: ::fidl_next::Encoder + ?Sized,
469 ArrayOfNullableHandles: ::fidl_next::Encode<crate::wire::ArrayOfNullableHandles, ___E>,
470 {
471 #[inline]
472 fn encode_option(
473 this: ::core::option::Option<Self>,
474 encoder: &mut ___E,
475 out: &mut ::core::mem::MaybeUninit<
476 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfNullableHandles>,
477 >,
478 _: (),
479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
480 if let Some(inner) = this {
481 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
482 ::fidl_next::wire::Box::encode_present(out);
483 } else {
484 ::fidl_next::wire::Box::encode_absent(out);
485 }
486
487 Ok(())
488 }
489 }
490
491 impl ::fidl_next::FromWire<crate::wire::ArrayOfNullableHandles> for ArrayOfNullableHandles {
492 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
493 crate::wire::ArrayOfNullableHandles,
494 Self,
495 > = unsafe {
496 ::fidl_next::CopyOptimization::enable_if(
497 true
498
499 && <
500 [::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>; 5] as ::fidl_next::FromWire<[::fidl_next::wire::fuchsia::OptionalNullableHandle; 5]>
501 >::COPY_OPTIMIZATION.is_enabled()
502
503 )
504 };
505
506 #[inline]
507 fn from_wire(wire: crate::wire::ArrayOfNullableHandles) -> Self {
508 Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
509 }
510 }
511
512 #[derive(Debug, PartialEq)]
513 #[repr(C)]
514 pub struct ArrayOfOptionalHandles {
515 pub a: [::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>; 3],
516 }
517
518 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ArrayOfOptionalHandles, ___E>
519 for ArrayOfOptionalHandles
520 where
521 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
522 ___E: ::fidl_next::fuchsia::HandleEncoder,
523 {
524 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
525 Self,
526 crate::wire::ArrayOfOptionalHandles,
527 > = unsafe {
528 ::fidl_next::CopyOptimization::enable_if(
529 true
530
531 && <
532 [::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>; 3] as ::fidl_next::Encode<[::fidl_next::wire::fuchsia::OptionalNullableHandle; 3], ___E>
533 >::COPY_OPTIMIZATION.is_enabled()
534
535 )
536 };
537
538 #[inline]
539 fn encode(
540 self,
541 encoder_: &mut ___E,
542 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfOptionalHandles>,
543 _: (),
544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
545 ::fidl_next::munge! {
546 let crate::wire::ArrayOfOptionalHandles {
547 a,
548
549 } = out_;
550 }
551
552 ::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
553
554 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
555
556 Ok(())
557 }
558 }
559
560 unsafe impl<___E>
561 ::fidl_next::EncodeOption<
562 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfOptionalHandles>,
563 ___E,
564 > for ArrayOfOptionalHandles
565 where
566 ___E: ::fidl_next::Encoder + ?Sized,
567 ArrayOfOptionalHandles: ::fidl_next::Encode<crate::wire::ArrayOfOptionalHandles, ___E>,
568 {
569 #[inline]
570 fn encode_option(
571 this: ::core::option::Option<Self>,
572 encoder: &mut ___E,
573 out: &mut ::core::mem::MaybeUninit<
574 ::fidl_next::wire::Box<'static, crate::wire::ArrayOfOptionalHandles>,
575 >,
576 _: (),
577 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
578 if let Some(inner) = this {
579 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
580 ::fidl_next::wire::Box::encode_present(out);
581 } else {
582 ::fidl_next::wire::Box::encode_absent(out);
583 }
584
585 Ok(())
586 }
587 }
588
589 impl ::fidl_next::FromWire<crate::wire::ArrayOfOptionalHandles> for ArrayOfOptionalHandles {
590 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
591 crate::wire::ArrayOfOptionalHandles,
592 Self,
593 > = unsafe {
594 ::fidl_next::CopyOptimization::enable_if(
595 true
596
597 && <
598 [::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>; 3] as ::fidl_next::FromWire<[::fidl_next::wire::fuchsia::OptionalNullableHandle; 3]>
599 >::COPY_OPTIMIZATION.is_enabled()
600
601 )
602 };
603
604 #[inline]
605 fn from_wire(wire: crate::wire::ArrayOfOptionalHandles) -> Self {
606 Self { a: ::fidl_next::FromWire::from_wire(wire.a) }
607 }
608 }
609
610 #[derive(Debug, PartialEq)]
611 pub struct ArrayOfVectorOfEventInStructWithDefaultRights {
612 pub h: [::std::vec::Vec<::fidl_next::fuchsia::zx::Event>; 1],
613 }
614
615 unsafe impl<___E>
616 ::fidl_next::Encode<
617 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
618 ___E,
619 > for ArrayOfVectorOfEventInStructWithDefaultRights
620 where
621 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
622 ___E: ::fidl_next::Encoder,
623 ___E: ::fidl_next::fuchsia::HandleEncoder,
624 {
625 #[inline]
626 fn encode(
627 self,
628 encoder_: &mut ___E,
629 out_: &mut ::core::mem::MaybeUninit<
630 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
631 >,
632 _: (),
633 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
634 ::fidl_next::munge! {
635 let crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights {
636 h,
637
638 } = out_;
639 }
640
641 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
642
643 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
644 ::fidl_next::Constrained::validate(_field, (1, ()))?;
645
646 Ok(())
647 }
648 }
649
650 unsafe impl<___E>
651 ::fidl_next::EncodeOption<
652 ::fidl_next::wire::Box<
653 'static,
654 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
655 >,
656 ___E,
657 > for ArrayOfVectorOfEventInStructWithDefaultRights
658 where
659 ___E: ::fidl_next::Encoder + ?Sized,
660 ArrayOfVectorOfEventInStructWithDefaultRights: ::fidl_next::Encode<
661 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
662 ___E,
663 >,
664 {
665 #[inline]
666 fn encode_option(
667 this: ::core::option::Option<Self>,
668 encoder: &mut ___E,
669 out: &mut ::core::mem::MaybeUninit<
670 ::fidl_next::wire::Box<
671 'static,
672 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
673 >,
674 >,
675 _: (),
676 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
677 if let Some(inner) = this {
678 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
679 ::fidl_next::wire::Box::encode_present(out);
680 } else {
681 ::fidl_next::wire::Box::encode_absent(out);
682 }
683
684 Ok(())
685 }
686 }
687
688 impl<'de> ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'de>>
689 for ArrayOfVectorOfEventInStructWithDefaultRights
690 {
691 #[inline]
692 fn from_wire(
693 wire: crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'de>,
694 ) -> Self {
695 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
696 }
697 }
698
699 #[derive(Debug, PartialEq)]
700 pub struct ArrayOfVectorOfEventInStructWithReducedRights {
701 pub h: [::std::vec::Vec<::fidl_next::fuchsia::zx::Event>; 1],
702 }
703
704 unsafe impl<___E>
705 ::fidl_next::Encode<
706 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
707 ___E,
708 > for ArrayOfVectorOfEventInStructWithReducedRights
709 where
710 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
711 ___E: ::fidl_next::Encoder,
712 ___E: ::fidl_next::fuchsia::HandleEncoder,
713 {
714 #[inline]
715 fn encode(
716 self,
717 encoder_: &mut ___E,
718 out_: &mut ::core::mem::MaybeUninit<
719 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
720 >,
721 _: (),
722 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
723 ::fidl_next::munge! {
724 let crate::wire::ArrayOfVectorOfEventInStructWithReducedRights {
725 h,
726
727 } = out_;
728 }
729
730 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
731
732 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
733 ::fidl_next::Constrained::validate(_field, (1, ()))?;
734
735 Ok(())
736 }
737 }
738
739 unsafe impl<___E>
740 ::fidl_next::EncodeOption<
741 ::fidl_next::wire::Box<
742 'static,
743 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
744 >,
745 ___E,
746 > for ArrayOfVectorOfEventInStructWithReducedRights
747 where
748 ___E: ::fidl_next::Encoder + ?Sized,
749 ArrayOfVectorOfEventInStructWithReducedRights: ::fidl_next::Encode<
750 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
751 ___E,
752 >,
753 {
754 #[inline]
755 fn encode_option(
756 this: ::core::option::Option<Self>,
757 encoder: &mut ___E,
758 out: &mut ::core::mem::MaybeUninit<
759 ::fidl_next::wire::Box<
760 'static,
761 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
762 >,
763 >,
764 _: (),
765 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
766 if let Some(inner) = this {
767 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
768 ::fidl_next::wire::Box::encode_present(out);
769 } else {
770 ::fidl_next::wire::Box::encode_absent(out);
771 }
772
773 Ok(())
774 }
775 }
776
777 impl<'de> ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'de>>
778 for ArrayOfVectorOfEventInStructWithReducedRights
779 {
780 #[inline]
781 fn from_wire(
782 wire: crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'de>,
783 ) -> Self {
784 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
785 }
786 }
787
788 #[derive(Debug, Default, PartialEq)]
789 pub struct ArrayOfVectorOfEventInTableWithDefaultRights {
790 pub h: ::core::option::Option<[::std::vec::Vec<::fidl_next::fuchsia::zx::Event>; 1]>,
791 }
792
793 impl ArrayOfVectorOfEventInTableWithDefaultRights {
794 fn __max_ordinal(&self) -> usize {
795 if self.h.is_some() {
796 return 1;
797 }
798
799 0
800 }
801 }
802
803 unsafe impl<___E>
804 ::fidl_next::Encode<
805 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights<'static>,
806 ___E,
807 > for ArrayOfVectorOfEventInTableWithDefaultRights
808 where
809 ___E: ::fidl_next::Encoder + ?Sized,
810 ___E: ::fidl_next::fuchsia::HandleEncoder,
811 {
812 #[inline]
813 fn encode(
814 mut self,
815 encoder: &mut ___E,
816 out: &mut ::core::mem::MaybeUninit<
817 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights<'static>,
818 >,
819 _: (),
820 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
821 ::fidl_next::munge!(let crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights { table } = out);
822
823 let max_ord = self.__max_ordinal();
824
825 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
826 ::fidl_next::Wire::zero_padding(&mut out);
827
828 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
829 ::fidl_next::wire::Envelope,
830 >(encoder, max_ord);
831
832 for i in 1..=max_ord {
833 match i {
834 1 => {
835 if let Some(value) = self.h.take() {
836 ::fidl_next::wire::Envelope::encode_value::<
837 [::fidl_next::wire::Vector<
838 'static,
839 ::fidl_next::wire::fuchsia::Event,
840 >; 1],
841 ___E,
842 >(
843 value, preallocated.encoder, &mut out, (1, ())
844 )?;
845 } else {
846 ::fidl_next::wire::Envelope::encode_zero(&mut out)
847 }
848 }
849
850 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
851 }
852 unsafe {
853 preallocated.write_next(out.assume_init_ref());
854 }
855 }
856
857 ::fidl_next::wire::Table::encode_len(table, max_ord);
858
859 Ok(())
860 }
861 }
862
863 impl<'de> ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights<'de>>
864 for ArrayOfVectorOfEventInTableWithDefaultRights
865 {
866 #[inline]
867 fn from_wire(
868 wire_: crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights<'de>,
869 ) -> Self {
870 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
871
872 let h = wire_.table.get(1);
873
874 Self {
875
876
877 h: h.map(|envelope| ::fidl_next::FromWire::from_wire(
878 unsafe { envelope.read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>() }
879 )),
880
881 }
882 }
883 }
884
885 #[derive(Debug, PartialEq)]
886 pub struct ArrayOfVectorOfEventInTableWithDefaultRightsStruct {
887 pub t: crate::natural::ArrayOfVectorOfEventInTableWithDefaultRights,
888 }
889
890 unsafe impl<___E>
891 ::fidl_next::Encode<
892 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
893 ___E,
894 > for ArrayOfVectorOfEventInTableWithDefaultRightsStruct
895 where
896 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
897 ___E: ::fidl_next::Encoder,
898 ___E: ::fidl_next::fuchsia::HandleEncoder,
899 {
900 #[inline]
901 fn encode(
902 self,
903 encoder_: &mut ___E,
904 out_: &mut ::core::mem::MaybeUninit<
905 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
906 >,
907 _: (),
908 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
909 ::fidl_next::munge! {
910 let crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct {
911 t,
912
913 } = out_;
914 }
915
916 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
917
918 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
919
920 Ok(())
921 }
922 }
923
924 unsafe impl<___E>
925 ::fidl_next::EncodeOption<
926 ::fidl_next::wire::Box<
927 'static,
928 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
929 >,
930 ___E,
931 > for ArrayOfVectorOfEventInTableWithDefaultRightsStruct
932 where
933 ___E: ::fidl_next::Encoder + ?Sized,
934 ArrayOfVectorOfEventInTableWithDefaultRightsStruct: ::fidl_next::Encode<
935 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
936 ___E,
937 >,
938 {
939 #[inline]
940 fn encode_option(
941 this: ::core::option::Option<Self>,
942 encoder: &mut ___E,
943 out: &mut ::core::mem::MaybeUninit<
944 ::fidl_next::wire::Box<
945 'static,
946 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
947 >,
948 >,
949 _: (),
950 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
951 if let Some(inner) = this {
952 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
953 ::fidl_next::wire::Box::encode_present(out);
954 } else {
955 ::fidl_next::wire::Box::encode_absent(out);
956 }
957
958 Ok(())
959 }
960 }
961
962 impl<'de>
963 ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'de>>
964 for ArrayOfVectorOfEventInTableWithDefaultRightsStruct
965 {
966 #[inline]
967 fn from_wire(
968 wire: crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'de>,
969 ) -> Self {
970 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
971 }
972 }
973
974 #[derive(Debug, Default, PartialEq)]
975 pub struct ArrayOfVectorOfEventInTableWithReducedRights {
976 pub h: ::core::option::Option<[::std::vec::Vec<::fidl_next::fuchsia::zx::Event>; 1]>,
977 }
978
979 impl ArrayOfVectorOfEventInTableWithReducedRights {
980 fn __max_ordinal(&self) -> usize {
981 if self.h.is_some() {
982 return 1;
983 }
984
985 0
986 }
987 }
988
989 unsafe impl<___E>
990 ::fidl_next::Encode<
991 crate::wire::ArrayOfVectorOfEventInTableWithReducedRights<'static>,
992 ___E,
993 > for ArrayOfVectorOfEventInTableWithReducedRights
994 where
995 ___E: ::fidl_next::Encoder + ?Sized,
996 ___E: ::fidl_next::fuchsia::HandleEncoder,
997 {
998 #[inline]
999 fn encode(
1000 mut self,
1001 encoder: &mut ___E,
1002 out: &mut ::core::mem::MaybeUninit<
1003 crate::wire::ArrayOfVectorOfEventInTableWithReducedRights<'static>,
1004 >,
1005 _: (),
1006 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1007 ::fidl_next::munge!(let crate::wire::ArrayOfVectorOfEventInTableWithReducedRights { table } = out);
1008
1009 let max_ord = self.__max_ordinal();
1010
1011 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1012 ::fidl_next::Wire::zero_padding(&mut out);
1013
1014 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1015 ::fidl_next::wire::Envelope,
1016 >(encoder, max_ord);
1017
1018 for i in 1..=max_ord {
1019 match i {
1020 1 => {
1021 if let Some(value) = self.h.take() {
1022 ::fidl_next::wire::Envelope::encode_value::<
1023 [::fidl_next::wire::Vector<
1024 'static,
1025 ::fidl_next::wire::fuchsia::Event,
1026 >; 1],
1027 ___E,
1028 >(
1029 value, preallocated.encoder, &mut out, (1, ())
1030 )?;
1031 } else {
1032 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1033 }
1034 }
1035
1036 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1037 }
1038 unsafe {
1039 preallocated.write_next(out.assume_init_ref());
1040 }
1041 }
1042
1043 ::fidl_next::wire::Table::encode_len(table, max_ord);
1044
1045 Ok(())
1046 }
1047 }
1048
1049 impl<'de> ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInTableWithReducedRights<'de>>
1050 for ArrayOfVectorOfEventInTableWithReducedRights
1051 {
1052 #[inline]
1053 fn from_wire(
1054 wire_: crate::wire::ArrayOfVectorOfEventInTableWithReducedRights<'de>,
1055 ) -> Self {
1056 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1057
1058 let h = wire_.table.get(1);
1059
1060 Self {
1061
1062
1063 h: h.map(|envelope| ::fidl_next::FromWire::from_wire(
1064 unsafe { envelope.read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>() }
1065 )),
1066
1067 }
1068 }
1069 }
1070
1071 #[derive(Debug, PartialEq)]
1072 pub struct ArrayOfVectorOfEventInTableWithReducedRightsStruct {
1073 pub t: crate::natural::ArrayOfVectorOfEventInTableWithReducedRights,
1074 }
1075
1076 unsafe impl<___E>
1077 ::fidl_next::Encode<
1078 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
1079 ___E,
1080 > for ArrayOfVectorOfEventInTableWithReducedRightsStruct
1081 where
1082 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1083 ___E: ::fidl_next::Encoder,
1084 ___E: ::fidl_next::fuchsia::HandleEncoder,
1085 {
1086 #[inline]
1087 fn encode(
1088 self,
1089 encoder_: &mut ___E,
1090 out_: &mut ::core::mem::MaybeUninit<
1091 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
1092 >,
1093 _: (),
1094 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1095 ::fidl_next::munge! {
1096 let crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct {
1097 t,
1098
1099 } = out_;
1100 }
1101
1102 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
1103
1104 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
1105
1106 Ok(())
1107 }
1108 }
1109
1110 unsafe impl<___E>
1111 ::fidl_next::EncodeOption<
1112 ::fidl_next::wire::Box<
1113 'static,
1114 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
1115 >,
1116 ___E,
1117 > for ArrayOfVectorOfEventInTableWithReducedRightsStruct
1118 where
1119 ___E: ::fidl_next::Encoder + ?Sized,
1120 ArrayOfVectorOfEventInTableWithReducedRightsStruct: ::fidl_next::Encode<
1121 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
1122 ___E,
1123 >,
1124 {
1125 #[inline]
1126 fn encode_option(
1127 this: ::core::option::Option<Self>,
1128 encoder: &mut ___E,
1129 out: &mut ::core::mem::MaybeUninit<
1130 ::fidl_next::wire::Box<
1131 'static,
1132 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
1133 >,
1134 >,
1135 _: (),
1136 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1137 if let Some(inner) = this {
1138 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1139 ::fidl_next::wire::Box::encode_present(out);
1140 } else {
1141 ::fidl_next::wire::Box::encode_absent(out);
1142 }
1143
1144 Ok(())
1145 }
1146 }
1147
1148 impl<'de>
1149 ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'de>>
1150 for ArrayOfVectorOfEventInTableWithReducedRightsStruct
1151 {
1152 #[inline]
1153 fn from_wire(
1154 wire: crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'de>,
1155 ) -> Self {
1156 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
1157 }
1158 }
1159
1160 #[derive(Debug, PartialEq)]
1161 pub enum ArrayOfVectorOfEventInUnionWithDefaultRights {
1162 H([::std::vec::Vec<::fidl_next::fuchsia::zx::Event>; 1]),
1163 }
1164
1165 unsafe impl<___E>
1166 ::fidl_next::Encode<
1167 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'static>,
1168 ___E,
1169 > for ArrayOfVectorOfEventInUnionWithDefaultRights
1170 where
1171 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1172 ___E: ::fidl_next::Encoder,
1173 ___E: ::fidl_next::fuchsia::HandleEncoder,
1174 {
1175 #[inline]
1176 fn encode(
1177 self,
1178 encoder: &mut ___E,
1179 out: &mut ::core::mem::MaybeUninit<
1180 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'static>,
1181 >,
1182 _: (),
1183 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1184 ::fidl_next::munge!(let crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights { raw, _phantom: _ } = out);
1185
1186 match self {
1187 Self::H(value) => ::fidl_next::wire::Union::encode_as::<
1188 ___E,
1189 [::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::Event>; 1],
1190 >(value, 1, encoder, raw, (1, ()))?,
1191 }
1192
1193 Ok(())
1194 }
1195 }
1196
1197 unsafe impl<___E>
1198 ::fidl_next::EncodeOption<
1199 crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'static>,
1200 ___E,
1201 > for ArrayOfVectorOfEventInUnionWithDefaultRights
1202 where
1203 ___E: ?Sized,
1204 ArrayOfVectorOfEventInUnionWithDefaultRights: ::fidl_next::Encode<
1205 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'static>,
1206 ___E,
1207 >,
1208 {
1209 #[inline]
1210 fn encode_option(
1211 this: ::core::option::Option<Self>,
1212 encoder: &mut ___E,
1213 out: &mut ::core::mem::MaybeUninit<
1214 crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'static>,
1215 >,
1216 _: (),
1217 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1218 ::fidl_next::munge!(let crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights { raw, _phantom: _ } = &mut *out);
1219
1220 if let Some(inner) = this {
1221 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1222 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1223 } else {
1224 ::fidl_next::wire::Union::encode_absent(raw);
1225 }
1226
1227 Ok(())
1228 }
1229 }
1230
1231 impl<'de> ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>>
1232 for ArrayOfVectorOfEventInUnionWithDefaultRights
1233 {
1234 #[inline]
1235 fn from_wire(wire: crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>) -> Self {
1236 let wire = ::core::mem::ManuallyDrop::new(wire);
1237 match wire.raw.ordinal() {
1238 1 => Self::H(::fidl_next::FromWire::from_wire(unsafe {
1239 wire.raw.get().read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
1240 })),
1241
1242 _ => unsafe { ::core::hint::unreachable_unchecked() },
1243 }
1244 }
1245 }
1246
1247 impl<'de>
1248 ::fidl_next::FromWireOption<
1249 crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>,
1250 > for ArrayOfVectorOfEventInUnionWithDefaultRights
1251 {
1252 #[inline]
1253 fn from_wire_option(
1254 wire: crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>,
1255 ) -> ::core::option::Option<Self> {
1256 if let Some(inner) = wire.into_option() {
1257 Some(::fidl_next::FromWire::from_wire(inner))
1258 } else {
1259 None
1260 }
1261 }
1262 }
1263
1264 impl<'de>
1265 ::fidl_next::FromWireOption<
1266 crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>,
1267 > for Box<ArrayOfVectorOfEventInUnionWithDefaultRights>
1268 {
1269 #[inline]
1270 fn from_wire_option(
1271 wire: crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>,
1272 ) -> ::core::option::Option<Self> {
1273 <ArrayOfVectorOfEventInUnionWithDefaultRights as ::fidl_next::FromWireOption<
1274 crate::wire_optional::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>,
1275 >>::from_wire_option(wire)
1276 .map(Box::new)
1277 }
1278 }
1279
1280 #[derive(Debug, PartialEq)]
1281 pub struct ArrayOfVectorOfEventInUnionWithDefaultRightsStruct {
1282 pub u: crate::natural::ArrayOfVectorOfEventInUnionWithDefaultRights,
1283 }
1284
1285 unsafe impl<___E>
1286 ::fidl_next::Encode<
1287 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
1288 ___E,
1289 > for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct
1290 where
1291 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1292 ___E: ::fidl_next::Encoder,
1293 ___E: ::fidl_next::fuchsia::HandleEncoder,
1294 {
1295 #[inline]
1296 fn encode(
1297 self,
1298 encoder_: &mut ___E,
1299 out_: &mut ::core::mem::MaybeUninit<
1300 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
1301 >,
1302 _: (),
1303 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1304 ::fidl_next::munge! {
1305 let crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct {
1306 u,
1307
1308 } = out_;
1309 }
1310
1311 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
1312
1313 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(u.as_mut_ptr()) };
1314
1315 Ok(())
1316 }
1317 }
1318
1319 unsafe impl<___E>
1320 ::fidl_next::EncodeOption<
1321 ::fidl_next::wire::Box<
1322 'static,
1323 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
1324 >,
1325 ___E,
1326 > for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct
1327 where
1328 ___E: ::fidl_next::Encoder + ?Sized,
1329 ArrayOfVectorOfEventInUnionWithDefaultRightsStruct: ::fidl_next::Encode<
1330 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
1331 ___E,
1332 >,
1333 {
1334 #[inline]
1335 fn encode_option(
1336 this: ::core::option::Option<Self>,
1337 encoder: &mut ___E,
1338 out: &mut ::core::mem::MaybeUninit<
1339 ::fidl_next::wire::Box<
1340 'static,
1341 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
1342 >,
1343 >,
1344 _: (),
1345 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1346 if let Some(inner) = this {
1347 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1348 ::fidl_next::wire::Box::encode_present(out);
1349 } else {
1350 ::fidl_next::wire::Box::encode_absent(out);
1351 }
1352
1353 Ok(())
1354 }
1355 }
1356
1357 impl<'de>
1358 ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'de>>
1359 for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct
1360 {
1361 #[inline]
1362 fn from_wire(
1363 wire: crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'de>,
1364 ) -> Self {
1365 Self { u: ::fidl_next::FromWire::from_wire(wire.u) }
1366 }
1367 }
1368
1369 #[derive(Debug, PartialEq)]
1370 pub enum ArrayOfVectorOfEventInUnionWithReducedRights {
1371 H([::std::vec::Vec<::fidl_next::fuchsia::zx::Event>; 1]),
1372 }
1373
1374 unsafe impl<___E>
1375 ::fidl_next::Encode<
1376 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'static>,
1377 ___E,
1378 > for ArrayOfVectorOfEventInUnionWithReducedRights
1379 where
1380 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1381 ___E: ::fidl_next::Encoder,
1382 ___E: ::fidl_next::fuchsia::HandleEncoder,
1383 {
1384 #[inline]
1385 fn encode(
1386 self,
1387 encoder: &mut ___E,
1388 out: &mut ::core::mem::MaybeUninit<
1389 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'static>,
1390 >,
1391 _: (),
1392 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1393 ::fidl_next::munge!(let crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights { raw, _phantom: _ } = out);
1394
1395 match self {
1396 Self::H(value) => ::fidl_next::wire::Union::encode_as::<
1397 ___E,
1398 [::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::Event>; 1],
1399 >(value, 1, encoder, raw, (1, ()))?,
1400 }
1401
1402 Ok(())
1403 }
1404 }
1405
1406 unsafe impl<___E>
1407 ::fidl_next::EncodeOption<
1408 crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'static>,
1409 ___E,
1410 > for ArrayOfVectorOfEventInUnionWithReducedRights
1411 where
1412 ___E: ?Sized,
1413 ArrayOfVectorOfEventInUnionWithReducedRights: ::fidl_next::Encode<
1414 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'static>,
1415 ___E,
1416 >,
1417 {
1418 #[inline]
1419 fn encode_option(
1420 this: ::core::option::Option<Self>,
1421 encoder: &mut ___E,
1422 out: &mut ::core::mem::MaybeUninit<
1423 crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'static>,
1424 >,
1425 _: (),
1426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1427 ::fidl_next::munge!(let crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights { raw, _phantom: _ } = &mut *out);
1428
1429 if let Some(inner) = this {
1430 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1431 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1432 } else {
1433 ::fidl_next::wire::Union::encode_absent(raw);
1434 }
1435
1436 Ok(())
1437 }
1438 }
1439
1440 impl<'de> ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'de>>
1441 for ArrayOfVectorOfEventInUnionWithReducedRights
1442 {
1443 #[inline]
1444 fn from_wire(wire: crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'de>) -> Self {
1445 let wire = ::core::mem::ManuallyDrop::new(wire);
1446 match wire.raw.ordinal() {
1447 1 => Self::H(::fidl_next::FromWire::from_wire(unsafe {
1448 wire.raw.get().read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
1449 })),
1450
1451 _ => unsafe { ::core::hint::unreachable_unchecked() },
1452 }
1453 }
1454 }
1455
1456 impl<'de>
1457 ::fidl_next::FromWireOption<
1458 crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'de>,
1459 > for ArrayOfVectorOfEventInUnionWithReducedRights
1460 {
1461 #[inline]
1462 fn from_wire_option(
1463 wire: crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'de>,
1464 ) -> ::core::option::Option<Self> {
1465 if let Some(inner) = wire.into_option() {
1466 Some(::fidl_next::FromWire::from_wire(inner))
1467 } else {
1468 None
1469 }
1470 }
1471 }
1472
1473 impl<'de>
1474 ::fidl_next::FromWireOption<
1475 crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'de>,
1476 > for Box<ArrayOfVectorOfEventInUnionWithReducedRights>
1477 {
1478 #[inline]
1479 fn from_wire_option(
1480 wire: crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'de>,
1481 ) -> ::core::option::Option<Self> {
1482 <ArrayOfVectorOfEventInUnionWithReducedRights as ::fidl_next::FromWireOption<
1483 crate::wire_optional::ArrayOfVectorOfEventInUnionWithReducedRights<'de>,
1484 >>::from_wire_option(wire)
1485 .map(Box::new)
1486 }
1487 }
1488
1489 #[derive(Debug, PartialEq)]
1490 pub struct ArrayOfVectorOfEventInUnionWithReducedRightsStruct {
1491 pub u: crate::natural::ArrayOfVectorOfEventInUnionWithReducedRights,
1492 }
1493
1494 unsafe impl<___E>
1495 ::fidl_next::Encode<
1496 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
1497 ___E,
1498 > for ArrayOfVectorOfEventInUnionWithReducedRightsStruct
1499 where
1500 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1501 ___E: ::fidl_next::Encoder,
1502 ___E: ::fidl_next::fuchsia::HandleEncoder,
1503 {
1504 #[inline]
1505 fn encode(
1506 self,
1507 encoder_: &mut ___E,
1508 out_: &mut ::core::mem::MaybeUninit<
1509 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
1510 >,
1511 _: (),
1512 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1513 ::fidl_next::munge! {
1514 let crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct {
1515 u,
1516
1517 } = out_;
1518 }
1519
1520 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
1521
1522 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(u.as_mut_ptr()) };
1523
1524 Ok(())
1525 }
1526 }
1527
1528 unsafe impl<___E>
1529 ::fidl_next::EncodeOption<
1530 ::fidl_next::wire::Box<
1531 'static,
1532 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
1533 >,
1534 ___E,
1535 > for ArrayOfVectorOfEventInUnionWithReducedRightsStruct
1536 where
1537 ___E: ::fidl_next::Encoder + ?Sized,
1538 ArrayOfVectorOfEventInUnionWithReducedRightsStruct: ::fidl_next::Encode<
1539 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
1540 ___E,
1541 >,
1542 {
1543 #[inline]
1544 fn encode_option(
1545 this: ::core::option::Option<Self>,
1546 encoder: &mut ___E,
1547 out: &mut ::core::mem::MaybeUninit<
1548 ::fidl_next::wire::Box<
1549 'static,
1550 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
1551 >,
1552 >,
1553 _: (),
1554 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1555 if let Some(inner) = this {
1556 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1557 ::fidl_next::wire::Box::encode_present(out);
1558 } else {
1559 ::fidl_next::wire::Box::encode_absent(out);
1560 }
1561
1562 Ok(())
1563 }
1564 }
1565
1566 impl<'de>
1567 ::fidl_next::FromWire<crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'de>>
1568 for ArrayOfVectorOfEventInUnionWithReducedRightsStruct
1569 {
1570 #[inline]
1571 fn from_wire(
1572 wire: crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'de>,
1573 ) -> Self {
1574 Self { u: ::fidl_next::FromWire::from_wire(wire.u) }
1575 }
1576 }
1577
1578 #[derive(Debug, PartialEq)]
1579 pub struct Bounded32NonnullableVectorOfHandles {
1580 pub vh0: ::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>,
1581 }
1582
1583 unsafe impl<___E>
1584 ::fidl_next::Encode<crate::wire::Bounded32NonnullableVectorOfHandles<'static>, ___E>
1585 for Bounded32NonnullableVectorOfHandles
1586 where
1587 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1588 ___E: ::fidl_next::Encoder,
1589 ___E: ::fidl_next::fuchsia::HandleEncoder,
1590 {
1591 #[inline]
1592 fn encode(
1593 self,
1594 encoder_: &mut ___E,
1595 out_: &mut ::core::mem::MaybeUninit<
1596 crate::wire::Bounded32NonnullableVectorOfHandles<'static>,
1597 >,
1598 _: (),
1599 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1600 ::fidl_next::munge! {
1601 let crate::wire::Bounded32NonnullableVectorOfHandles {
1602 vh0,
1603
1604 } = out_;
1605 }
1606
1607 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (32, ()))?;
1608
1609 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh0.as_mut_ptr()) };
1610 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1611
1612 Ok(())
1613 }
1614 }
1615
1616 unsafe impl<___E>
1617 ::fidl_next::EncodeOption<
1618 ::fidl_next::wire::Box<
1619 'static,
1620 crate::wire::Bounded32NonnullableVectorOfHandles<'static>,
1621 >,
1622 ___E,
1623 > for Bounded32NonnullableVectorOfHandles
1624 where
1625 ___E: ::fidl_next::Encoder + ?Sized,
1626 Bounded32NonnullableVectorOfHandles:
1627 ::fidl_next::Encode<crate::wire::Bounded32NonnullableVectorOfHandles<'static>, ___E>,
1628 {
1629 #[inline]
1630 fn encode_option(
1631 this: ::core::option::Option<Self>,
1632 encoder: &mut ___E,
1633 out: &mut ::core::mem::MaybeUninit<
1634 ::fidl_next::wire::Box<
1635 'static,
1636 crate::wire::Bounded32NonnullableVectorOfHandles<'static>,
1637 >,
1638 >,
1639 _: (),
1640 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1641 if let Some(inner) = this {
1642 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1643 ::fidl_next::wire::Box::encode_present(out);
1644 } else {
1645 ::fidl_next::wire::Box::encode_absent(out);
1646 }
1647
1648 Ok(())
1649 }
1650 }
1651
1652 impl<'de> ::fidl_next::FromWire<crate::wire::Bounded32NonnullableVectorOfHandles<'de>>
1653 for Bounded32NonnullableVectorOfHandles
1654 {
1655 #[inline]
1656 fn from_wire(wire: crate::wire::Bounded32NonnullableVectorOfHandles<'de>) -> Self {
1657 Self { vh0: ::fidl_next::FromWire::from_wire(wire.vh0) }
1658 }
1659 }
1660
1661 #[derive(Debug, PartialEq)]
1662 pub struct Bounded32NullableVectorOfHandles {
1663 pub vh0: ::core::option::Option<::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>>,
1664 }
1665
1666 unsafe impl<___E>
1667 ::fidl_next::Encode<crate::wire::Bounded32NullableVectorOfHandles<'static>, ___E>
1668 for Bounded32NullableVectorOfHandles
1669 where
1670 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1671 ___E: ::fidl_next::Encoder,
1672 ___E: ::fidl_next::fuchsia::HandleEncoder,
1673 {
1674 #[inline]
1675 fn encode(
1676 self,
1677 encoder_: &mut ___E,
1678 out_: &mut ::core::mem::MaybeUninit<
1679 crate::wire::Bounded32NullableVectorOfHandles<'static>,
1680 >,
1681 _: (),
1682 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1683 ::fidl_next::munge! {
1684 let crate::wire::Bounded32NullableVectorOfHandles {
1685 vh0,
1686
1687 } = out_;
1688 }
1689
1690 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (32, ()))?;
1691
1692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh0.as_mut_ptr()) };
1693 ::fidl_next::Constrained::validate(_field, (32, ()))?;
1694
1695 Ok(())
1696 }
1697 }
1698
1699 unsafe impl<___E>
1700 ::fidl_next::EncodeOption<
1701 ::fidl_next::wire::Box<'static, crate::wire::Bounded32NullableVectorOfHandles<'static>>,
1702 ___E,
1703 > for Bounded32NullableVectorOfHandles
1704 where
1705 ___E: ::fidl_next::Encoder + ?Sized,
1706 Bounded32NullableVectorOfHandles:
1707 ::fidl_next::Encode<crate::wire::Bounded32NullableVectorOfHandles<'static>, ___E>,
1708 {
1709 #[inline]
1710 fn encode_option(
1711 this: ::core::option::Option<Self>,
1712 encoder: &mut ___E,
1713 out: &mut ::core::mem::MaybeUninit<
1714 ::fidl_next::wire::Box<
1715 'static,
1716 crate::wire::Bounded32NullableVectorOfHandles<'static>,
1717 >,
1718 >,
1719 _: (),
1720 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1721 if let Some(inner) = this {
1722 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1723 ::fidl_next::wire::Box::encode_present(out);
1724 } else {
1725 ::fidl_next::wire::Box::encode_absent(out);
1726 }
1727
1728 Ok(())
1729 }
1730 }
1731
1732 impl<'de> ::fidl_next::FromWire<crate::wire::Bounded32NullableVectorOfHandles<'de>>
1733 for Bounded32NullableVectorOfHandles
1734 {
1735 #[inline]
1736 fn from_wire(wire: crate::wire::Bounded32NullableVectorOfHandles<'de>) -> Self {
1737 Self { vh0: ::fidl_next::FromWire::from_wire(wire.vh0) }
1738 }
1739 }
1740
1741 #[derive(Debug, PartialEq)]
1742 pub struct BoxOfSingleHandle {
1743 pub b: ::core::option::Option<::std::boxed::Box<crate::natural::SingleHandle>>,
1744 }
1745
1746 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BoxOfSingleHandle<'static>, ___E>
1747 for BoxOfSingleHandle
1748 where
1749 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1750 ___E: ::fidl_next::Encoder,
1751 ___E: ::fidl_next::fuchsia::HandleEncoder,
1752 {
1753 #[inline]
1754 fn encode(
1755 self,
1756 encoder_: &mut ___E,
1757 out_: &mut ::core::mem::MaybeUninit<crate::wire::BoxOfSingleHandle<'static>>,
1758 _: (),
1759 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1760 ::fidl_next::munge! {
1761 let crate::wire::BoxOfSingleHandle {
1762 b,
1763
1764 } = out_;
1765 }
1766
1767 ::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
1768
1769 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
1770
1771 Ok(())
1772 }
1773 }
1774
1775 unsafe impl<___E>
1776 ::fidl_next::EncodeOption<
1777 ::fidl_next::wire::Box<'static, crate::wire::BoxOfSingleHandle<'static>>,
1778 ___E,
1779 > for BoxOfSingleHandle
1780 where
1781 ___E: ::fidl_next::Encoder + ?Sized,
1782 BoxOfSingleHandle: ::fidl_next::Encode<crate::wire::BoxOfSingleHandle<'static>, ___E>,
1783 {
1784 #[inline]
1785 fn encode_option(
1786 this: ::core::option::Option<Self>,
1787 encoder: &mut ___E,
1788 out: &mut ::core::mem::MaybeUninit<
1789 ::fidl_next::wire::Box<'static, crate::wire::BoxOfSingleHandle<'static>>,
1790 >,
1791 _: (),
1792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1793 if let Some(inner) = this {
1794 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1795 ::fidl_next::wire::Box::encode_present(out);
1796 } else {
1797 ::fidl_next::wire::Box::encode_absent(out);
1798 }
1799
1800 Ok(())
1801 }
1802 }
1803
1804 impl<'de> ::fidl_next::FromWire<crate::wire::BoxOfSingleHandle<'de>> for BoxOfSingleHandle {
1805 #[inline]
1806 fn from_wire(wire: crate::wire::BoxOfSingleHandle<'de>) -> Self {
1807 Self { b: ::fidl_next::FromWire::from_wire(wire.b) }
1808 }
1809 }
1810
1811 #[derive(Debug, PartialEq)]
1812 pub struct BoxOfSingleOptionalHandle {
1813 pub b: ::core::option::Option<::std::boxed::Box<crate::natural::SingleOptionalHandle>>,
1814 }
1815
1816 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BoxOfSingleOptionalHandle<'static>, ___E>
1817 for BoxOfSingleOptionalHandle
1818 where
1819 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1820 ___E: ::fidl_next::Encoder,
1821 ___E: ::fidl_next::fuchsia::HandleEncoder,
1822 {
1823 #[inline]
1824 fn encode(
1825 self,
1826 encoder_: &mut ___E,
1827 out_: &mut ::core::mem::MaybeUninit<crate::wire::BoxOfSingleOptionalHandle<'static>>,
1828 _: (),
1829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1830 ::fidl_next::munge! {
1831 let crate::wire::BoxOfSingleOptionalHandle {
1832 b,
1833
1834 } = out_;
1835 }
1836
1837 ::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
1838
1839 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
1840
1841 Ok(())
1842 }
1843 }
1844
1845 unsafe impl<___E>
1846 ::fidl_next::EncodeOption<
1847 ::fidl_next::wire::Box<'static, crate::wire::BoxOfSingleOptionalHandle<'static>>,
1848 ___E,
1849 > for BoxOfSingleOptionalHandle
1850 where
1851 ___E: ::fidl_next::Encoder + ?Sized,
1852 BoxOfSingleOptionalHandle:
1853 ::fidl_next::Encode<crate::wire::BoxOfSingleOptionalHandle<'static>, ___E>,
1854 {
1855 #[inline]
1856 fn encode_option(
1857 this: ::core::option::Option<Self>,
1858 encoder: &mut ___E,
1859 out: &mut ::core::mem::MaybeUninit<
1860 ::fidl_next::wire::Box<'static, crate::wire::BoxOfSingleOptionalHandle<'static>>,
1861 >,
1862 _: (),
1863 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1864 if let Some(inner) = this {
1865 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1866 ::fidl_next::wire::Box::encode_present(out);
1867 } else {
1868 ::fidl_next::wire::Box::encode_absent(out);
1869 }
1870
1871 Ok(())
1872 }
1873 }
1874
1875 impl<'de> ::fidl_next::FromWire<crate::wire::BoxOfSingleOptionalHandle<'de>>
1876 for BoxOfSingleOptionalHandle
1877 {
1878 #[inline]
1879 fn from_wire(wire: crate::wire::BoxOfSingleOptionalHandle<'de>) -> Self {
1880 Self { b: ::fidl_next::FromWire::from_wire(wire.b) }
1881 }
1882 }
1883
1884 #[derive(Debug, PartialEq)]
1885 pub struct LaunchInfo {
1886 pub url: ::std::string::String,
1887
1888 pub arguments: ::core::option::Option<::std::vec::Vec<::std::string::String>>,
1889
1890 pub out: ::core::option::Option<::std::boxed::Box<crate::natural::TransformerEmptyStruct>>,
1891
1892 pub err: ::core::option::Option<::std::boxed::Box<crate::natural::TransformerEmptyStruct>>,
1893
1894 pub directory_request: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
1895
1896 pub flat_namespace:
1897 ::core::option::Option<::std::boxed::Box<crate::natural::TransformerEmptyStruct>>,
1898
1899 pub additional_services:
1900 ::core::option::Option<::std::boxed::Box<crate::natural::TransformerEmptyStruct>>,
1901 }
1902
1903 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E> for LaunchInfo
1904 where
1905 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1906 ___E: ::fidl_next::Encoder,
1907 ___E: ::fidl_next::fuchsia::HandleEncoder,
1908 {
1909 #[inline]
1910 fn encode(
1911 self,
1912 encoder_: &mut ___E,
1913 out_: &mut ::core::mem::MaybeUninit<crate::wire::LaunchInfo<'static>>,
1914 _: (),
1915 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1916 ::fidl_next::munge! {
1917 let crate::wire::LaunchInfo {
1918 url,
1919 arguments,
1920 out,
1921 err,
1922 directory_request,
1923 flat_namespace,
1924 additional_services,
1925
1926 } = out_;
1927 }
1928
1929 ::fidl_next::Encode::encode(self.url, encoder_, url, 200)?;
1930
1931 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(url.as_mut_ptr()) };
1932 ::fidl_next::Constrained::validate(_field, 200)?;
1933
1934 ::fidl_next::Encode::encode(
1935 self.arguments,
1936 encoder_,
1937 arguments,
1938 (4294967295, 4294967295),
1939 )?;
1940
1941 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(arguments.as_mut_ptr()) };
1942 ::fidl_next::Constrained::validate(_field, (4294967295, 4294967295))?;
1943
1944 ::fidl_next::Encode::encode(self.out, encoder_, out, ())?;
1945
1946 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(out.as_mut_ptr()) };
1947
1948 ::fidl_next::Encode::encode(self.err, encoder_, err, ())?;
1949
1950 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(err.as_mut_ptr()) };
1951
1952 ::fidl_next::Encode::encode(self.directory_request, encoder_, directory_request, ())?;
1953
1954 let mut _field =
1955 unsafe { ::fidl_next::Slot::new_unchecked(directory_request.as_mut_ptr()) };
1956
1957 ::fidl_next::Encode::encode(self.flat_namespace, encoder_, flat_namespace, ())?;
1958
1959 let mut _field =
1960 unsafe { ::fidl_next::Slot::new_unchecked(flat_namespace.as_mut_ptr()) };
1961
1962 ::fidl_next::Encode::encode(
1963 self.additional_services,
1964 encoder_,
1965 additional_services,
1966 (),
1967 )?;
1968
1969 let mut _field =
1970 unsafe { ::fidl_next::Slot::new_unchecked(additional_services.as_mut_ptr()) };
1971
1972 Ok(())
1973 }
1974 }
1975
1976 unsafe impl<___E>
1977 ::fidl_next::EncodeOption<
1978 ::fidl_next::wire::Box<'static, crate::wire::LaunchInfo<'static>>,
1979 ___E,
1980 > for LaunchInfo
1981 where
1982 ___E: ::fidl_next::Encoder + ?Sized,
1983 LaunchInfo: ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>,
1984 {
1985 #[inline]
1986 fn encode_option(
1987 this: ::core::option::Option<Self>,
1988 encoder: &mut ___E,
1989 out: &mut ::core::mem::MaybeUninit<
1990 ::fidl_next::wire::Box<'static, crate::wire::LaunchInfo<'static>>,
1991 >,
1992 _: (),
1993 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1994 if let Some(inner) = this {
1995 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1996 ::fidl_next::wire::Box::encode_present(out);
1997 } else {
1998 ::fidl_next::wire::Box::encode_absent(out);
1999 }
2000
2001 Ok(())
2002 }
2003 }
2004
2005 impl<'de> ::fidl_next::FromWire<crate::wire::LaunchInfo<'de>> for LaunchInfo {
2006 #[inline]
2007 fn from_wire(wire: crate::wire::LaunchInfo<'de>) -> Self {
2008 Self {
2009 url: ::fidl_next::FromWire::from_wire(wire.url),
2010
2011 arguments: ::fidl_next::FromWire::from_wire(wire.arguments),
2012
2013 out: ::fidl_next::FromWire::from_wire(wire.out),
2014
2015 err: ::fidl_next::FromWire::from_wire(wire.err),
2016
2017 directory_request: ::fidl_next::FromWire::from_wire(wire.directory_request),
2018
2019 flat_namespace: ::fidl_next::FromWire::from_wire(wire.flat_namespace),
2020
2021 additional_services: ::fidl_next::FromWire::from_wire(wire.additional_services),
2022 }
2023 }
2024 }
2025
2026 #[derive(Debug, PartialEq)]
2027 pub struct CreateComponentRequest {
2028 pub launch_info: crate::natural::LaunchInfo,
2029
2030 pub controller: ::core::option::Option<
2031 ::fidl_next::ServerEnd<crate::ComponentController, ::fidl_next::fuchsia::zx::Channel>,
2032 >,
2033 }
2034
2035 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CreateComponentRequest<'static>, ___E>
2036 for CreateComponentRequest
2037 where
2038 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2039 ___E: ::fidl_next::Encoder,
2040 ___E: ::fidl_next::fuchsia::HandleEncoder,
2041 {
2042 #[inline]
2043 fn encode(
2044 self,
2045 encoder_: &mut ___E,
2046 out_: &mut ::core::mem::MaybeUninit<crate::wire::CreateComponentRequest<'static>>,
2047 _: (),
2048 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2049 ::fidl_next::munge! {
2050 let crate::wire::CreateComponentRequest {
2051 launch_info,
2052 controller,
2053
2054 } = out_;
2055 }
2056
2057 ::fidl_next::Encode::encode(self.launch_info, encoder_, launch_info, ())?;
2058
2059 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(launch_info.as_mut_ptr()) };
2060
2061 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
2062
2063 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(controller.as_mut_ptr()) };
2064
2065 Ok(())
2066 }
2067 }
2068
2069 unsafe impl<___E>
2070 ::fidl_next::EncodeOption<
2071 ::fidl_next::wire::Box<'static, crate::wire::CreateComponentRequest<'static>>,
2072 ___E,
2073 > for CreateComponentRequest
2074 where
2075 ___E: ::fidl_next::Encoder + ?Sized,
2076 CreateComponentRequest:
2077 ::fidl_next::Encode<crate::wire::CreateComponentRequest<'static>, ___E>,
2078 {
2079 #[inline]
2080 fn encode_option(
2081 this: ::core::option::Option<Self>,
2082 encoder: &mut ___E,
2083 out: &mut ::core::mem::MaybeUninit<
2084 ::fidl_next::wire::Box<'static, crate::wire::CreateComponentRequest<'static>>,
2085 >,
2086 _: (),
2087 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2088 if let Some(inner) = this {
2089 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2090 ::fidl_next::wire::Box::encode_present(out);
2091 } else {
2092 ::fidl_next::wire::Box::encode_absent(out);
2093 }
2094
2095 Ok(())
2096 }
2097 }
2098
2099 impl<'de> ::fidl_next::FromWire<crate::wire::CreateComponentRequest<'de>>
2100 for CreateComponentRequest
2101 {
2102 #[inline]
2103 fn from_wire(wire: crate::wire::CreateComponentRequest<'de>) -> Self {
2104 Self {
2105 launch_info: ::fidl_next::FromWire::from_wire(wire.launch_info),
2106
2107 controller: ::fidl_next::FromWire::from_wire(wire.controller),
2108 }
2109 }
2110 }
2111
2112 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2113 pub struct EmptyResourceTable {}
2114
2115 impl EmptyResourceTable {
2116 fn __max_ordinal(&self) -> usize {
2117 0
2118 }
2119 }
2120
2121 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EmptyResourceTable<'static>, ___E>
2122 for EmptyResourceTable
2123 where
2124 ___E: ::fidl_next::Encoder + ?Sized,
2125 ___E: ::fidl_next::fuchsia::HandleEncoder,
2126 {
2127 #[inline]
2128 fn encode(
2129 mut self,
2130 encoder: &mut ___E,
2131 out: &mut ::core::mem::MaybeUninit<crate::wire::EmptyResourceTable<'static>>,
2132 _: (),
2133 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2134 ::fidl_next::munge!(let crate::wire::EmptyResourceTable { table } = out);
2135
2136 let max_ord = self.__max_ordinal();
2137
2138 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2139 ::fidl_next::Wire::zero_padding(&mut out);
2140
2141 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2142 ::fidl_next::wire::Envelope,
2143 >(encoder, max_ord);
2144
2145 for i in 1..=max_ord {
2146 match i {
2147 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2148 }
2149 unsafe {
2150 preallocated.write_next(out.assume_init_ref());
2151 }
2152 }
2153
2154 ::fidl_next::wire::Table::encode_len(table, max_ord);
2155
2156 Ok(())
2157 }
2158 }
2159
2160 impl<'de> ::fidl_next::FromWire<crate::wire::EmptyResourceTable<'de>> for EmptyResourceTable {
2161 #[inline]
2162 fn from_wire(wire_: crate::wire::EmptyResourceTable<'de>) -> Self {
2163 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2164
2165 Self {}
2166 }
2167 }
2168
2169 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2170 pub struct EmptyResourceTableStruct {
2171 pub table: crate::natural::EmptyResourceTable,
2172 }
2173
2174 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EmptyResourceTableStruct<'static>, ___E>
2175 for EmptyResourceTableStruct
2176 where
2177 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2178 ___E: ::fidl_next::Encoder,
2179 ___E: ::fidl_next::fuchsia::HandleEncoder,
2180 {
2181 #[inline]
2182 fn encode(
2183 self,
2184 encoder_: &mut ___E,
2185 out_: &mut ::core::mem::MaybeUninit<crate::wire::EmptyResourceTableStruct<'static>>,
2186 _: (),
2187 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2188 ::fidl_next::munge! {
2189 let crate::wire::EmptyResourceTableStruct {
2190 table,
2191
2192 } = out_;
2193 }
2194
2195 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
2196
2197 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(table.as_mut_ptr()) };
2198
2199 Ok(())
2200 }
2201 }
2202
2203 unsafe impl<___E>
2204 ::fidl_next::EncodeOption<
2205 ::fidl_next::wire::Box<'static, crate::wire::EmptyResourceTableStruct<'static>>,
2206 ___E,
2207 > for EmptyResourceTableStruct
2208 where
2209 ___E: ::fidl_next::Encoder + ?Sized,
2210 EmptyResourceTableStruct:
2211 ::fidl_next::Encode<crate::wire::EmptyResourceTableStruct<'static>, ___E>,
2212 {
2213 #[inline]
2214 fn encode_option(
2215 this: ::core::option::Option<Self>,
2216 encoder: &mut ___E,
2217 out: &mut ::core::mem::MaybeUninit<
2218 ::fidl_next::wire::Box<'static, crate::wire::EmptyResourceTableStruct<'static>>,
2219 >,
2220 _: (),
2221 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2222 if let Some(inner) = this {
2223 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2224 ::fidl_next::wire::Box::encode_present(out);
2225 } else {
2226 ::fidl_next::wire::Box::encode_absent(out);
2227 }
2228
2229 Ok(())
2230 }
2231 }
2232
2233 impl<'de> ::fidl_next::FromWire<crate::wire::EmptyResourceTableStruct<'de>>
2234 for EmptyResourceTableStruct
2235 {
2236 #[inline]
2237 fn from_wire(wire: crate::wire::EmptyResourceTableStruct<'de>) -> Self {
2238 Self { table: ::fidl_next::FromWire::from_wire(wire.table) }
2239 }
2240 }
2241
2242 #[derive(Debug, PartialEq)]
2243 pub enum EnvelopeInliningTestUnion {
2244 Small(u32),
2245
2246 Large(u64),
2247
2248 Handle(::fidl_next::fuchsia::zx::NullableHandle),
2249
2250 UnknownOrdinal_(u64),
2251 }
2252
2253 impl EnvelopeInliningTestUnion {
2254 pub fn is_unknown(&self) -> bool {
2255 #[allow(unreachable_patterns)]
2256 match self {
2257 Self::UnknownOrdinal_(_) => true,
2258 _ => false,
2259 }
2260 }
2261 }
2262
2263 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EnvelopeInliningTestUnion<'static>, ___E>
2264 for EnvelopeInliningTestUnion
2265 where
2266 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2267 ___E: ::fidl_next::Encoder,
2268 ___E: ::fidl_next::fuchsia::HandleEncoder,
2269 {
2270 #[inline]
2271 fn encode(
2272 self,
2273 encoder: &mut ___E,
2274 out: &mut ::core::mem::MaybeUninit<crate::wire::EnvelopeInliningTestUnion<'static>>,
2275 _: (),
2276 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2277 ::fidl_next::munge!(let crate::wire::EnvelopeInliningTestUnion { raw, _phantom: _ } = out);
2278
2279 match self {
2280 Self::Small(value) => ::fidl_next::wire::Union::encode_as::<
2281 ___E,
2282 ::fidl_next::wire::Uint32,
2283 >(value, 1, encoder, raw, ())?,
2284
2285 Self::Large(value) => ::fidl_next::wire::Union::encode_as::<
2286 ___E,
2287 ::fidl_next::wire::Uint64,
2288 >(value, 2, encoder, raw, ())?,
2289
2290 Self::Handle(value) => ::fidl_next::wire::Union::encode_as::<
2291 ___E,
2292 ::fidl_next::wire::fuchsia::NullableHandle,
2293 >(value, 3, encoder, raw, ())?,
2294
2295 Self::UnknownOrdinal_(ordinal) => {
2296 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
2297 }
2298 }
2299
2300 Ok(())
2301 }
2302 }
2303
2304 unsafe impl<___E>
2305 ::fidl_next::EncodeOption<crate::wire_optional::EnvelopeInliningTestUnion<'static>, ___E>
2306 for EnvelopeInliningTestUnion
2307 where
2308 ___E: ?Sized,
2309 EnvelopeInliningTestUnion:
2310 ::fidl_next::Encode<crate::wire::EnvelopeInliningTestUnion<'static>, ___E>,
2311 {
2312 #[inline]
2313 fn encode_option(
2314 this: ::core::option::Option<Self>,
2315 encoder: &mut ___E,
2316 out: &mut ::core::mem::MaybeUninit<
2317 crate::wire_optional::EnvelopeInliningTestUnion<'static>,
2318 >,
2319 _: (),
2320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2321 ::fidl_next::munge!(let crate::wire_optional::EnvelopeInliningTestUnion { raw, _phantom: _ } = &mut *out);
2322
2323 if let Some(inner) = this {
2324 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2325 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2326 } else {
2327 ::fidl_next::wire::Union::encode_absent(raw);
2328 }
2329
2330 Ok(())
2331 }
2332 }
2333
2334 impl<'de> ::fidl_next::FromWire<crate::wire::EnvelopeInliningTestUnion<'de>>
2335 for EnvelopeInliningTestUnion
2336 {
2337 #[inline]
2338 fn from_wire(wire: crate::wire::EnvelopeInliningTestUnion<'de>) -> Self {
2339 let wire = ::core::mem::ManuallyDrop::new(wire);
2340 match wire.raw.ordinal() {
2341 1 => Self::Small(::fidl_next::FromWire::from_wire(unsafe {
2342 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
2343 })),
2344
2345 2 => Self::Large(::fidl_next::FromWire::from_wire(unsafe {
2346 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint64>()
2347 })),
2348
2349 3 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
2350 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
2351 })),
2352
2353 ord => return Self::UnknownOrdinal_(ord as u64),
2354 }
2355 }
2356 }
2357
2358 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EnvelopeInliningTestUnion<'de>>
2359 for EnvelopeInliningTestUnion
2360 {
2361 #[inline]
2362 fn from_wire_option(
2363 wire: crate::wire_optional::EnvelopeInliningTestUnion<'de>,
2364 ) -> ::core::option::Option<Self> {
2365 if let Some(inner) = wire.into_option() {
2366 Some(::fidl_next::FromWire::from_wire(inner))
2367 } else {
2368 None
2369 }
2370 }
2371 }
2372
2373 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EnvelopeInliningTestUnion<'de>>
2374 for Box<EnvelopeInliningTestUnion>
2375 {
2376 #[inline]
2377 fn from_wire_option(
2378 wire: crate::wire_optional::EnvelopeInliningTestUnion<'de>,
2379 ) -> ::core::option::Option<Self> {
2380 <EnvelopeInliningTestUnion as ::fidl_next::FromWireOption<
2381 crate::wire_optional::EnvelopeInliningTestUnion<'de>,
2382 >>::from_wire_option(wire)
2383 .map(Box::new)
2384 }
2385 }
2386
2387 #[derive(Debug, PartialEq)]
2388 pub struct EnvelopeInliningTestUnionStruct {
2389 pub u: crate::natural::EnvelopeInliningTestUnion,
2390 }
2391
2392 unsafe impl<___E>
2393 ::fidl_next::Encode<crate::wire::EnvelopeInliningTestUnionStruct<'static>, ___E>
2394 for EnvelopeInliningTestUnionStruct
2395 where
2396 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2397 ___E: ::fidl_next::Encoder,
2398 ___E: ::fidl_next::fuchsia::HandleEncoder,
2399 {
2400 #[inline]
2401 fn encode(
2402 self,
2403 encoder_: &mut ___E,
2404 out_: &mut ::core::mem::MaybeUninit<
2405 crate::wire::EnvelopeInliningTestUnionStruct<'static>,
2406 >,
2407 _: (),
2408 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2409 ::fidl_next::munge! {
2410 let crate::wire::EnvelopeInliningTestUnionStruct {
2411 u,
2412
2413 } = out_;
2414 }
2415
2416 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
2417
2418 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(u.as_mut_ptr()) };
2419
2420 Ok(())
2421 }
2422 }
2423
2424 unsafe impl<___E>
2425 ::fidl_next::EncodeOption<
2426 ::fidl_next::wire::Box<'static, crate::wire::EnvelopeInliningTestUnionStruct<'static>>,
2427 ___E,
2428 > for EnvelopeInliningTestUnionStruct
2429 where
2430 ___E: ::fidl_next::Encoder + ?Sized,
2431 EnvelopeInliningTestUnionStruct:
2432 ::fidl_next::Encode<crate::wire::EnvelopeInliningTestUnionStruct<'static>, ___E>,
2433 {
2434 #[inline]
2435 fn encode_option(
2436 this: ::core::option::Option<Self>,
2437 encoder: &mut ___E,
2438 out: &mut ::core::mem::MaybeUninit<
2439 ::fidl_next::wire::Box<
2440 'static,
2441 crate::wire::EnvelopeInliningTestUnionStruct<'static>,
2442 >,
2443 >,
2444 _: (),
2445 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2446 if let Some(inner) = this {
2447 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2448 ::fidl_next::wire::Box::encode_present(out);
2449 } else {
2450 ::fidl_next::wire::Box::encode_absent(out);
2451 }
2452
2453 Ok(())
2454 }
2455 }
2456
2457 impl<'de> ::fidl_next::FromWire<crate::wire::EnvelopeInliningTestUnionStruct<'de>>
2458 for EnvelopeInliningTestUnionStruct
2459 {
2460 #[inline]
2461 fn from_wire(wire: crate::wire::EnvelopeInliningTestUnionStruct<'de>) -> Self {
2462 Self { u: ::fidl_next::FromWire::from_wire(wire.u) }
2463 }
2464 }
2465
2466 #[derive(Debug, PartialEq)]
2467 #[repr(C)]
2468 pub struct EventWithDefaultRights {
2469 pub h: ::fidl_next::fuchsia::zx::Event,
2470 }
2471
2472 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventWithDefaultRights, ___E>
2473 for EventWithDefaultRights
2474 where
2475 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2476 ___E: ::fidl_next::fuchsia::HandleEncoder,
2477 {
2478 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2479 Self,
2480 crate::wire::EventWithDefaultRights,
2481 > = unsafe {
2482 ::fidl_next::CopyOptimization::enable_if(
2483 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
2484 ::fidl_next::wire::fuchsia::Event,
2485 ___E,
2486 >>::COPY_OPTIMIZATION
2487 .is_enabled(),
2488 )
2489 };
2490
2491 #[inline]
2492 fn encode(
2493 self,
2494 encoder_: &mut ___E,
2495 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventWithDefaultRights>,
2496 _: (),
2497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2498 ::fidl_next::munge! {
2499 let crate::wire::EventWithDefaultRights {
2500 h,
2501
2502 } = out_;
2503 }
2504
2505 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
2506
2507 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
2508
2509 Ok(())
2510 }
2511 }
2512
2513 unsafe impl<___E>
2514 ::fidl_next::EncodeOption<
2515 ::fidl_next::wire::Box<'static, crate::wire::EventWithDefaultRights>,
2516 ___E,
2517 > for EventWithDefaultRights
2518 where
2519 ___E: ::fidl_next::Encoder + ?Sized,
2520 EventWithDefaultRights: ::fidl_next::Encode<crate::wire::EventWithDefaultRights, ___E>,
2521 {
2522 #[inline]
2523 fn encode_option(
2524 this: ::core::option::Option<Self>,
2525 encoder: &mut ___E,
2526 out: &mut ::core::mem::MaybeUninit<
2527 ::fidl_next::wire::Box<'static, crate::wire::EventWithDefaultRights>,
2528 >,
2529 _: (),
2530 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2531 if let Some(inner) = this {
2532 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2533 ::fidl_next::wire::Box::encode_present(out);
2534 } else {
2535 ::fidl_next::wire::Box::encode_absent(out);
2536 }
2537
2538 Ok(())
2539 }
2540 }
2541
2542 impl ::fidl_next::FromWire<crate::wire::EventWithDefaultRights> for EventWithDefaultRights {
2543 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2544 crate::wire::EventWithDefaultRights,
2545 Self,
2546 > = unsafe {
2547 ::fidl_next::CopyOptimization::enable_if(
2548 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
2549 ::fidl_next::wire::fuchsia::Event,
2550 >>::COPY_OPTIMIZATION
2551 .is_enabled(),
2552 )
2553 };
2554
2555 #[inline]
2556 fn from_wire(wire: crate::wire::EventWithDefaultRights) -> Self {
2557 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
2558 }
2559 }
2560
2561 #[derive(Debug, PartialEq)]
2562 #[repr(C)]
2563 pub struct EventWithReducedRights {
2564 pub h: ::fidl_next::fuchsia::zx::Event,
2565 }
2566
2567 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventWithReducedRights, ___E>
2568 for EventWithReducedRights
2569 where
2570 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2571 ___E: ::fidl_next::fuchsia::HandleEncoder,
2572 {
2573 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2574 Self,
2575 crate::wire::EventWithReducedRights,
2576 > = unsafe {
2577 ::fidl_next::CopyOptimization::enable_if(
2578 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
2579 ::fidl_next::wire::fuchsia::Event,
2580 ___E,
2581 >>::COPY_OPTIMIZATION
2582 .is_enabled(),
2583 )
2584 };
2585
2586 #[inline]
2587 fn encode(
2588 self,
2589 encoder_: &mut ___E,
2590 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventWithReducedRights>,
2591 _: (),
2592 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2593 ::fidl_next::munge! {
2594 let crate::wire::EventWithReducedRights {
2595 h,
2596
2597 } = out_;
2598 }
2599
2600 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
2601
2602 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
2603
2604 Ok(())
2605 }
2606 }
2607
2608 unsafe impl<___E>
2609 ::fidl_next::EncodeOption<
2610 ::fidl_next::wire::Box<'static, crate::wire::EventWithReducedRights>,
2611 ___E,
2612 > for EventWithReducedRights
2613 where
2614 ___E: ::fidl_next::Encoder + ?Sized,
2615 EventWithReducedRights: ::fidl_next::Encode<crate::wire::EventWithReducedRights, ___E>,
2616 {
2617 #[inline]
2618 fn encode_option(
2619 this: ::core::option::Option<Self>,
2620 encoder: &mut ___E,
2621 out: &mut ::core::mem::MaybeUninit<
2622 ::fidl_next::wire::Box<'static, crate::wire::EventWithReducedRights>,
2623 >,
2624 _: (),
2625 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2626 if let Some(inner) = this {
2627 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2628 ::fidl_next::wire::Box::encode_present(out);
2629 } else {
2630 ::fidl_next::wire::Box::encode_absent(out);
2631 }
2632
2633 Ok(())
2634 }
2635 }
2636
2637 impl ::fidl_next::FromWire<crate::wire::EventWithReducedRights> for EventWithReducedRights {
2638 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2639 crate::wire::EventWithReducedRights,
2640 Self,
2641 > = unsafe {
2642 ::fidl_next::CopyOptimization::enable_if(
2643 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
2644 ::fidl_next::wire::fuchsia::Event,
2645 >>::COPY_OPTIMIZATION
2646 .is_enabled(),
2647 )
2648 };
2649
2650 #[inline]
2651 fn from_wire(wire: crate::wire::EventWithReducedRights) -> Self {
2652 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
2653 }
2654 }
2655
2656 #[derive(Debug, PartialEq)]
2657 pub struct FidlvizDemo {
2658 pub f1: u8,
2659
2660 pub f2: i8,
2661
2662 pub f3: u16,
2663
2664 pub f4: u32,
2665
2666 pub f5: u64,
2667
2668 pub f6: u8,
2669
2670 pub f7: u8,
2671
2672 pub f8: u16,
2673
2674 pub f9: f32,
2675
2676 pub f10: f64,
2677
2678 pub f11: bool,
2679
2680 pub f12: bool,
2681
2682 pub f13: ::std::string::String,
2683
2684 pub f14: ::core::option::Option<::std::string::String>,
2685
2686 pub f15: ::std::string::String,
2687
2688 pub f16: ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>,
2689
2690 pub f17: ::fidl_next::fuchsia::zx::NullableHandle,
2691
2692 pub f18: [u8; 3],
2693
2694 pub f19: ::std::vec::Vec<f64>,
2695
2696 pub f20: ::core::option::Option<::std::vec::Vec<u8>>,
2697
2698 pub f21: ::std::vec::Vec<u8>,
2699
2700 pub f22: crate::natural::FidlvizBits,
2701
2702 pub f23: crate::natural::FidlvizEnum,
2703
2704 pub f24: crate::natural::FidlvizStruct1,
2705
2706 pub f25: crate::natural::FidlvizStruct2,
2707
2708 pub f26: ::core::option::Option<::std::boxed::Box<crate::natural::FidlvizStruct1>>,
2709
2710 pub f27: ::core::option::Option<::std::boxed::Box<crate::natural::FidlvizStruct2>>,
2711
2712 pub f28: crate::natural::FidlvizTable,
2713
2714 pub f29: crate::natural::FidlvizTable,
2715
2716 pub f30: ::core::option::Option<::std::boxed::Box<crate::natural::FidlvizUnion>>,
2717
2718 pub f31: crate::natural::FidlvizUnion,
2719 }
2720
2721 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FidlvizDemo<'static>, ___E> for FidlvizDemo
2722 where
2723 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2724 ___E: ::fidl_next::Encoder,
2725 ___E: ::fidl_next::fuchsia::HandleEncoder,
2726 {
2727 #[inline]
2728 fn encode(
2729 self,
2730 encoder_: &mut ___E,
2731 out_: &mut ::core::mem::MaybeUninit<crate::wire::FidlvizDemo<'static>>,
2732 _: (),
2733 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2734 ::fidl_next::munge! {
2735 let crate::wire::FidlvizDemo {
2736 f1,
2737 f2,
2738 f3,
2739 f4,
2740 f5,
2741 f6,
2742 f7,
2743 f8,
2744 f9,
2745 f10,
2746 f11,
2747 f12,
2748 f13,
2749 f14,
2750 f15,
2751 f16,
2752 f17,
2753 f18,
2754 f19,
2755 f20,
2756 f21,
2757 f22,
2758 f23,
2759 f24,
2760 f25,
2761 f26,
2762 f27,
2763 f28,
2764 f29,
2765 f30,
2766 f31,
2767
2768 } = out_;
2769 }
2770
2771 ::fidl_next::Encode::encode(self.f1, encoder_, f1, ())?;
2772
2773 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f1.as_mut_ptr()) };
2774
2775 ::fidl_next::Encode::encode(self.f2, encoder_, f2, ())?;
2776
2777 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f2.as_mut_ptr()) };
2778
2779 ::fidl_next::Encode::encode(self.f3, encoder_, f3, ())?;
2780
2781 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f3.as_mut_ptr()) };
2782
2783 ::fidl_next::Encode::encode(self.f4, encoder_, f4, ())?;
2784
2785 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f4.as_mut_ptr()) };
2786
2787 ::fidl_next::Encode::encode(self.f5, encoder_, f5, ())?;
2788
2789 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f5.as_mut_ptr()) };
2790
2791 ::fidl_next::Encode::encode(self.f6, encoder_, f6, ())?;
2792
2793 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f6.as_mut_ptr()) };
2794
2795 ::fidl_next::Encode::encode(self.f7, encoder_, f7, ())?;
2796
2797 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f7.as_mut_ptr()) };
2798
2799 ::fidl_next::Encode::encode(self.f8, encoder_, f8, ())?;
2800
2801 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f8.as_mut_ptr()) };
2802
2803 ::fidl_next::Encode::encode(self.f9, encoder_, f9, ())?;
2804
2805 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f9.as_mut_ptr()) };
2806
2807 ::fidl_next::Encode::encode(self.f10, encoder_, f10, ())?;
2808
2809 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f10.as_mut_ptr()) };
2810
2811 ::fidl_next::Encode::encode(self.f11, encoder_, f11, ())?;
2812
2813 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f11.as_mut_ptr()) };
2814
2815 ::fidl_next::Encode::encode(self.f12, encoder_, f12, ())?;
2816
2817 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f12.as_mut_ptr()) };
2818
2819 ::fidl_next::Encode::encode(self.f13, encoder_, f13, 4294967295)?;
2820
2821 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f13.as_mut_ptr()) };
2822 ::fidl_next::Constrained::validate(_field, 4294967295)?;
2823
2824 ::fidl_next::Encode::encode(self.f14, encoder_, f14, 4294967295)?;
2825
2826 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f14.as_mut_ptr()) };
2827 ::fidl_next::Constrained::validate(_field, 4294967295)?;
2828
2829 ::fidl_next::Encode::encode(self.f15, encoder_, f15, 4294967295)?;
2830
2831 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f15.as_mut_ptr()) };
2832 ::fidl_next::Constrained::validate(_field, 4294967295)?;
2833
2834 ::fidl_next::Encode::encode(self.f16, encoder_, f16, ())?;
2835
2836 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f16.as_mut_ptr()) };
2837
2838 ::fidl_next::Encode::encode(self.f17, encoder_, f17, ())?;
2839
2840 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f17.as_mut_ptr()) };
2841
2842 ::fidl_next::Encode::encode(self.f18, encoder_, f18, ())?;
2843
2844 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f18.as_mut_ptr()) };
2845
2846 ::fidl_next::Encode::encode(self.f19, encoder_, f19, (4294967295, ()))?;
2847
2848 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f19.as_mut_ptr()) };
2849 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2850
2851 ::fidl_next::Encode::encode(self.f20, encoder_, f20, (4294967295, ()))?;
2852
2853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f20.as_mut_ptr()) };
2854 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2855
2856 ::fidl_next::Encode::encode(self.f21, encoder_, f21, (4294967295, ()))?;
2857
2858 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f21.as_mut_ptr()) };
2859 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2860
2861 ::fidl_next::Encode::encode(self.f22, encoder_, f22, ())?;
2862
2863 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f22.as_mut_ptr()) };
2864
2865 ::fidl_next::Encode::encode(self.f23, encoder_, f23, ())?;
2866
2867 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f23.as_mut_ptr()) };
2868
2869 ::fidl_next::Encode::encode(self.f24, encoder_, f24, ())?;
2870
2871 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f24.as_mut_ptr()) };
2872
2873 ::fidl_next::Encode::encode(self.f25, encoder_, f25, ())?;
2874
2875 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f25.as_mut_ptr()) };
2876
2877 ::fidl_next::Encode::encode(self.f26, encoder_, f26, ())?;
2878
2879 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f26.as_mut_ptr()) };
2880
2881 ::fidl_next::Encode::encode(self.f27, encoder_, f27, ())?;
2882
2883 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f27.as_mut_ptr()) };
2884
2885 ::fidl_next::Encode::encode(self.f28, encoder_, f28, ())?;
2886
2887 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f28.as_mut_ptr()) };
2888
2889 ::fidl_next::Encode::encode(self.f29, encoder_, f29, ())?;
2890
2891 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f29.as_mut_ptr()) };
2892
2893 ::fidl_next::Encode::encode(self.f30, encoder_, f30, ())?;
2894
2895 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f30.as_mut_ptr()) };
2896
2897 ::fidl_next::Encode::encode(self.f31, encoder_, f31, ())?;
2898
2899 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(f31.as_mut_ptr()) };
2900
2901 Ok(())
2902 }
2903 }
2904
2905 unsafe impl<___E>
2906 ::fidl_next::EncodeOption<
2907 ::fidl_next::wire::Box<'static, crate::wire::FidlvizDemo<'static>>,
2908 ___E,
2909 > for FidlvizDemo
2910 where
2911 ___E: ::fidl_next::Encoder + ?Sized,
2912 FidlvizDemo: ::fidl_next::Encode<crate::wire::FidlvizDemo<'static>, ___E>,
2913 {
2914 #[inline]
2915 fn encode_option(
2916 this: ::core::option::Option<Self>,
2917 encoder: &mut ___E,
2918 out: &mut ::core::mem::MaybeUninit<
2919 ::fidl_next::wire::Box<'static, crate::wire::FidlvizDemo<'static>>,
2920 >,
2921 _: (),
2922 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2923 if let Some(inner) = this {
2924 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2925 ::fidl_next::wire::Box::encode_present(out);
2926 } else {
2927 ::fidl_next::wire::Box::encode_absent(out);
2928 }
2929
2930 Ok(())
2931 }
2932 }
2933
2934 impl<'de> ::fidl_next::FromWire<crate::wire::FidlvizDemo<'de>> for FidlvizDemo {
2935 #[inline]
2936 fn from_wire(wire: crate::wire::FidlvizDemo<'de>) -> Self {
2937 Self {
2938 f1: ::fidl_next::FromWire::from_wire(wire.f1),
2939
2940 f2: ::fidl_next::FromWire::from_wire(wire.f2),
2941
2942 f3: ::fidl_next::FromWire::from_wire(wire.f3),
2943
2944 f4: ::fidl_next::FromWire::from_wire(wire.f4),
2945
2946 f5: ::fidl_next::FromWire::from_wire(wire.f5),
2947
2948 f6: ::fidl_next::FromWire::from_wire(wire.f6),
2949
2950 f7: ::fidl_next::FromWire::from_wire(wire.f7),
2951
2952 f8: ::fidl_next::FromWire::from_wire(wire.f8),
2953
2954 f9: ::fidl_next::FromWire::from_wire(wire.f9),
2955
2956 f10: ::fidl_next::FromWire::from_wire(wire.f10),
2957
2958 f11: ::fidl_next::FromWire::from_wire(wire.f11),
2959
2960 f12: ::fidl_next::FromWire::from_wire(wire.f12),
2961
2962 f13: ::fidl_next::FromWire::from_wire(wire.f13),
2963
2964 f14: ::fidl_next::FromWire::from_wire(wire.f14),
2965
2966 f15: ::fidl_next::FromWire::from_wire(wire.f15),
2967
2968 f16: ::fidl_next::FromWire::from_wire(wire.f16),
2969
2970 f17: ::fidl_next::FromWire::from_wire(wire.f17),
2971
2972 f18: ::fidl_next::FromWire::from_wire(wire.f18),
2973
2974 f19: ::fidl_next::FromWire::from_wire(wire.f19),
2975
2976 f20: ::fidl_next::FromWire::from_wire(wire.f20),
2977
2978 f21: ::fidl_next::FromWire::from_wire(wire.f21),
2979
2980 f22: ::fidl_next::FromWire::from_wire(wire.f22),
2981
2982 f23: ::fidl_next::FromWire::from_wire(wire.f23),
2983
2984 f24: ::fidl_next::FromWire::from_wire(wire.f24),
2985
2986 f25: ::fidl_next::FromWire::from_wire(wire.f25),
2987
2988 f26: ::fidl_next::FromWire::from_wire(wire.f26),
2989
2990 f27: ::fidl_next::FromWire::from_wire(wire.f27),
2991
2992 f28: ::fidl_next::FromWire::from_wire(wire.f28),
2993
2994 f29: ::fidl_next::FromWire::from_wire(wire.f29),
2995
2996 f30: ::fidl_next::FromWire::from_wire(wire.f30),
2997
2998 f31: ::fidl_next::FromWire::from_wire(wire.f31),
2999 }
3000 }
3001 }
3002
3003 #[derive(Debug, PartialEq)]
3004 #[repr(C)]
3005 pub struct GoldenHandleBasicRightsStruct {
3006 pub v: ::fidl_next::fuchsia::zx::Event,
3007 }
3008
3009 unsafe impl<___E> ::fidl_next::Encode<crate::wire::GoldenHandleBasicRightsStruct, ___E>
3010 for GoldenHandleBasicRightsStruct
3011 where
3012 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3013 ___E: ::fidl_next::fuchsia::HandleEncoder,
3014 {
3015 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3016 Self,
3017 crate::wire::GoldenHandleBasicRightsStruct,
3018 > = unsafe {
3019 ::fidl_next::CopyOptimization::enable_if(
3020 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
3021 ::fidl_next::wire::fuchsia::Event,
3022 ___E,
3023 >>::COPY_OPTIMIZATION
3024 .is_enabled(),
3025 )
3026 };
3027
3028 #[inline]
3029 fn encode(
3030 self,
3031 encoder_: &mut ___E,
3032 out_: &mut ::core::mem::MaybeUninit<crate::wire::GoldenHandleBasicRightsStruct>,
3033 _: (),
3034 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3035 ::fidl_next::munge! {
3036 let crate::wire::GoldenHandleBasicRightsStruct {
3037 v,
3038
3039 } = out_;
3040 }
3041
3042 ::fidl_next::Encode::encode(self.v, encoder_, v, ())?;
3043
3044 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(v.as_mut_ptr()) };
3045
3046 Ok(())
3047 }
3048 }
3049
3050 unsafe impl<___E>
3051 ::fidl_next::EncodeOption<
3052 ::fidl_next::wire::Box<'static, crate::wire::GoldenHandleBasicRightsStruct>,
3053 ___E,
3054 > for GoldenHandleBasicRightsStruct
3055 where
3056 ___E: ::fidl_next::Encoder + ?Sized,
3057 GoldenHandleBasicRightsStruct:
3058 ::fidl_next::Encode<crate::wire::GoldenHandleBasicRightsStruct, ___E>,
3059 {
3060 #[inline]
3061 fn encode_option(
3062 this: ::core::option::Option<Self>,
3063 encoder: &mut ___E,
3064 out: &mut ::core::mem::MaybeUninit<
3065 ::fidl_next::wire::Box<'static, crate::wire::GoldenHandleBasicRightsStruct>,
3066 >,
3067 _: (),
3068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3069 if let Some(inner) = this {
3070 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3071 ::fidl_next::wire::Box::encode_present(out);
3072 } else {
3073 ::fidl_next::wire::Box::encode_absent(out);
3074 }
3075
3076 Ok(())
3077 }
3078 }
3079
3080 impl ::fidl_next::FromWire<crate::wire::GoldenHandleBasicRightsStruct>
3081 for GoldenHandleBasicRightsStruct
3082 {
3083 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3084 crate::wire::GoldenHandleBasicRightsStruct,
3085 Self,
3086 > = unsafe {
3087 ::fidl_next::CopyOptimization::enable_if(
3088 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
3089 ::fidl_next::wire::fuchsia::Event,
3090 >>::COPY_OPTIMIZATION
3091 .is_enabled(),
3092 )
3093 };
3094
3095 #[inline]
3096 fn from_wire(wire: crate::wire::GoldenHandleBasicRightsStruct) -> Self {
3097 Self { v: ::fidl_next::FromWire::from_wire(wire.v) }
3098 }
3099 }
3100
3101 #[derive(Debug, PartialEq)]
3102 #[repr(C)]
3103 pub struct GoldenNullableHandleStruct {
3104 pub v: ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>,
3105 }
3106
3107 unsafe impl<___E> ::fidl_next::Encode<crate::wire::GoldenNullableHandleStruct, ___E>
3108 for GoldenNullableHandleStruct
3109 where
3110 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3111 ___E: ::fidl_next::fuchsia::HandleEncoder,
3112 {
3113 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3114 Self,
3115 crate::wire::GoldenNullableHandleStruct,
3116 > = unsafe {
3117 ::fidl_next::CopyOptimization::enable_if(
3118 true
3119
3120 && <
3121 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>
3122 >::COPY_OPTIMIZATION.is_enabled()
3123
3124 )
3125 };
3126
3127 #[inline]
3128 fn encode(
3129 self,
3130 encoder_: &mut ___E,
3131 out_: &mut ::core::mem::MaybeUninit<crate::wire::GoldenNullableHandleStruct>,
3132 _: (),
3133 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3134 ::fidl_next::munge! {
3135 let crate::wire::GoldenNullableHandleStruct {
3136 v,
3137
3138 } = out_;
3139 }
3140
3141 ::fidl_next::Encode::encode(self.v, encoder_, v, ())?;
3142
3143 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(v.as_mut_ptr()) };
3144
3145 Ok(())
3146 }
3147 }
3148
3149 unsafe impl<___E>
3150 ::fidl_next::EncodeOption<
3151 ::fidl_next::wire::Box<'static, crate::wire::GoldenNullableHandleStruct>,
3152 ___E,
3153 > for GoldenNullableHandleStruct
3154 where
3155 ___E: ::fidl_next::Encoder + ?Sized,
3156 GoldenNullableHandleStruct:
3157 ::fidl_next::Encode<crate::wire::GoldenNullableHandleStruct, ___E>,
3158 {
3159 #[inline]
3160 fn encode_option(
3161 this: ::core::option::Option<Self>,
3162 encoder: &mut ___E,
3163 out: &mut ::core::mem::MaybeUninit<
3164 ::fidl_next::wire::Box<'static, crate::wire::GoldenNullableHandleStruct>,
3165 >,
3166 _: (),
3167 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3168 if let Some(inner) = this {
3169 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3170 ::fidl_next::wire::Box::encode_present(out);
3171 } else {
3172 ::fidl_next::wire::Box::encode_absent(out);
3173 }
3174
3175 Ok(())
3176 }
3177 }
3178
3179 impl ::fidl_next::FromWire<crate::wire::GoldenNullableHandleStruct> for GoldenNullableHandleStruct {
3180 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3181 crate::wire::GoldenNullableHandleStruct,
3182 Self,
3183 > = unsafe {
3184 ::fidl_next::CopyOptimization::enable_if(
3185 true
3186
3187 && <
3188 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalNullableHandle>
3189 >::COPY_OPTIMIZATION.is_enabled()
3190
3191 )
3192 };
3193
3194 #[inline]
3195 fn from_wire(wire: crate::wire::GoldenNullableHandleStruct) -> Self {
3196 Self { v: ::fidl_next::FromWire::from_wire(wire.v) }
3197 }
3198 }
3199
3200 #[derive(Debug, PartialEq)]
3201 pub struct MultipleBoundedNonnullableVectorsOfHandles {
3202 pub vh0: ::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>,
3203
3204 pub vh1: ::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>,
3205 }
3206
3207 unsafe impl<___E>
3208 ::fidl_next::Encode<crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>, ___E>
3209 for MultipleBoundedNonnullableVectorsOfHandles
3210 where
3211 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3212 ___E: ::fidl_next::Encoder,
3213 ___E: ::fidl_next::fuchsia::HandleEncoder,
3214 {
3215 #[inline]
3216 fn encode(
3217 self,
3218 encoder_: &mut ___E,
3219 out_: &mut ::core::mem::MaybeUninit<
3220 crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>,
3221 >,
3222 _: (),
3223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3224 ::fidl_next::munge! {
3225 let crate::wire::MultipleBoundedNonnullableVectorsOfHandles {
3226 vh0,
3227 vh1,
3228
3229 } = out_;
3230 }
3231
3232 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (2, ()))?;
3233
3234 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh0.as_mut_ptr()) };
3235 ::fidl_next::Constrained::validate(_field, (2, ()))?;
3236
3237 ::fidl_next::Encode::encode(self.vh1, encoder_, vh1, (32, ()))?;
3238
3239 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh1.as_mut_ptr()) };
3240 ::fidl_next::Constrained::validate(_field, (32, ()))?;
3241
3242 Ok(())
3243 }
3244 }
3245
3246 unsafe impl<___E>
3247 ::fidl_next::EncodeOption<
3248 ::fidl_next::wire::Box<
3249 'static,
3250 crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>,
3251 >,
3252 ___E,
3253 > for MultipleBoundedNonnullableVectorsOfHandles
3254 where
3255 ___E: ::fidl_next::Encoder + ?Sized,
3256 MultipleBoundedNonnullableVectorsOfHandles: ::fidl_next::Encode<
3257 crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>,
3258 ___E,
3259 >,
3260 {
3261 #[inline]
3262 fn encode_option(
3263 this: ::core::option::Option<Self>,
3264 encoder: &mut ___E,
3265 out: &mut ::core::mem::MaybeUninit<
3266 ::fidl_next::wire::Box<
3267 'static,
3268 crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>,
3269 >,
3270 >,
3271 _: (),
3272 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3273 if let Some(inner) = this {
3274 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3275 ::fidl_next::wire::Box::encode_present(out);
3276 } else {
3277 ::fidl_next::wire::Box::encode_absent(out);
3278 }
3279
3280 Ok(())
3281 }
3282 }
3283
3284 impl<'de> ::fidl_next::FromWire<crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'de>>
3285 for MultipleBoundedNonnullableVectorsOfHandles
3286 {
3287 #[inline]
3288 fn from_wire(wire: crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'de>) -> Self {
3289 Self {
3290 vh0: ::fidl_next::FromWire::from_wire(wire.vh0),
3291
3292 vh1: ::fidl_next::FromWire::from_wire(wire.vh1),
3293 }
3294 }
3295 }
3296
3297 #[derive(Debug, PartialEq)]
3298 pub struct MultipleBoundedNullableVectorsOfHandles {
3299 pub vh0: ::core::option::Option<::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>>,
3300
3301 pub vh1: ::core::option::Option<::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>>,
3302 }
3303
3304 unsafe impl<___E>
3305 ::fidl_next::Encode<crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>, ___E>
3306 for MultipleBoundedNullableVectorsOfHandles
3307 where
3308 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3309 ___E: ::fidl_next::Encoder,
3310 ___E: ::fidl_next::fuchsia::HandleEncoder,
3311 {
3312 #[inline]
3313 fn encode(
3314 self,
3315 encoder_: &mut ___E,
3316 out_: &mut ::core::mem::MaybeUninit<
3317 crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>,
3318 >,
3319 _: (),
3320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3321 ::fidl_next::munge! {
3322 let crate::wire::MultipleBoundedNullableVectorsOfHandles {
3323 vh0,
3324 vh1,
3325
3326 } = out_;
3327 }
3328
3329 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (2, ()))?;
3330
3331 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh0.as_mut_ptr()) };
3332 ::fidl_next::Constrained::validate(_field, (2, ()))?;
3333
3334 ::fidl_next::Encode::encode(self.vh1, encoder_, vh1, (32, ()))?;
3335
3336 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh1.as_mut_ptr()) };
3337 ::fidl_next::Constrained::validate(_field, (32, ()))?;
3338
3339 Ok(())
3340 }
3341 }
3342
3343 unsafe impl<___E>
3344 ::fidl_next::EncodeOption<
3345 ::fidl_next::wire::Box<
3346 'static,
3347 crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>,
3348 >,
3349 ___E,
3350 > for MultipleBoundedNullableVectorsOfHandles
3351 where
3352 ___E: ::fidl_next::Encoder + ?Sized,
3353 MultipleBoundedNullableVectorsOfHandles: ::fidl_next::Encode<crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>, ___E>,
3354 {
3355 #[inline]
3356 fn encode_option(
3357 this: ::core::option::Option<Self>,
3358 encoder: &mut ___E,
3359 out: &mut ::core::mem::MaybeUninit<
3360 ::fidl_next::wire::Box<
3361 'static,
3362 crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>,
3363 >,
3364 >,
3365 _: (),
3366 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3367 if let Some(inner) = this {
3368 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3369 ::fidl_next::wire::Box::encode_present(out);
3370 } else {
3371 ::fidl_next::wire::Box::encode_absent(out);
3372 }
3373
3374 Ok(())
3375 }
3376 }
3377
3378 impl<'de> ::fidl_next::FromWire<crate::wire::MultipleBoundedNullableVectorsOfHandles<'de>>
3379 for MultipleBoundedNullableVectorsOfHandles
3380 {
3381 #[inline]
3382 fn from_wire(wire: crate::wire::MultipleBoundedNullableVectorsOfHandles<'de>) -> Self {
3383 Self {
3384 vh0: ::fidl_next::FromWire::from_wire(wire.vh0),
3385
3386 vh1: ::fidl_next::FromWire::from_wire(wire.vh1),
3387 }
3388 }
3389 }
3390
3391 #[derive(Debug, PartialEq)]
3392 #[repr(C)]
3393 pub struct MultipleHandleSubtypes {
3394 pub untyped: ::fidl_next::fuchsia::zx::NullableHandle,
3395
3396 pub event: ::fidl_next::fuchsia::zx::Event,
3397
3398 pub channel: ::fidl_next::fuchsia::zx::Channel,
3399 }
3400
3401 unsafe impl<___E> ::fidl_next::Encode<crate::wire::MultipleHandleSubtypes, ___E>
3402 for MultipleHandleSubtypes
3403 where
3404 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3405 ___E: ::fidl_next::fuchsia::HandleEncoder,
3406 {
3407 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3408 Self,
3409 crate::wire::MultipleHandleSubtypes,
3410 > = unsafe {
3411 ::fidl_next::CopyOptimization::enable_if(
3412 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::Encode<
3413 ::fidl_next::wire::fuchsia::NullableHandle,
3414 ___E,
3415 >>::COPY_OPTIMIZATION
3416 .is_enabled()
3417 && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
3418 ::fidl_next::wire::fuchsia::Event,
3419 ___E,
3420 >>::COPY_OPTIMIZATION
3421 .is_enabled()
3422 && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<
3423 ::fidl_next::wire::fuchsia::Channel,
3424 ___E,
3425 >>::COPY_OPTIMIZATION
3426 .is_enabled(),
3427 )
3428 };
3429
3430 #[inline]
3431 fn encode(
3432 self,
3433 encoder_: &mut ___E,
3434 out_: &mut ::core::mem::MaybeUninit<crate::wire::MultipleHandleSubtypes>,
3435 _: (),
3436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3437 ::fidl_next::munge! {
3438 let crate::wire::MultipleHandleSubtypes {
3439 untyped,
3440 event,
3441 channel,
3442
3443 } = out_;
3444 }
3445
3446 ::fidl_next::Encode::encode(self.untyped, encoder_, untyped, ())?;
3447
3448 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(untyped.as_mut_ptr()) };
3449
3450 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
3451
3452 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };
3453
3454 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
3455
3456 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
3457
3458 Ok(())
3459 }
3460 }
3461
3462 unsafe impl<___E>
3463 ::fidl_next::EncodeOption<
3464 ::fidl_next::wire::Box<'static, crate::wire::MultipleHandleSubtypes>,
3465 ___E,
3466 > for MultipleHandleSubtypes
3467 where
3468 ___E: ::fidl_next::Encoder + ?Sized,
3469 MultipleHandleSubtypes: ::fidl_next::Encode<crate::wire::MultipleHandleSubtypes, ___E>,
3470 {
3471 #[inline]
3472 fn encode_option(
3473 this: ::core::option::Option<Self>,
3474 encoder: &mut ___E,
3475 out: &mut ::core::mem::MaybeUninit<
3476 ::fidl_next::wire::Box<'static, crate::wire::MultipleHandleSubtypes>,
3477 >,
3478 _: (),
3479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3480 if let Some(inner) = this {
3481 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3482 ::fidl_next::wire::Box::encode_present(out);
3483 } else {
3484 ::fidl_next::wire::Box::encode_absent(out);
3485 }
3486
3487 Ok(())
3488 }
3489 }
3490
3491 impl ::fidl_next::FromWire<crate::wire::MultipleHandleSubtypes> for MultipleHandleSubtypes {
3492 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3493 crate::wire::MultipleHandleSubtypes,
3494 Self,
3495 > = unsafe {
3496 ::fidl_next::CopyOptimization::enable_if(
3497 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::FromWire<
3498 ::fidl_next::wire::fuchsia::NullableHandle,
3499 >>::COPY_OPTIMIZATION
3500 .is_enabled()
3501 && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
3502 ::fidl_next::wire::fuchsia::Event,
3503 >>::COPY_OPTIMIZATION
3504 .is_enabled()
3505 && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3506 ::fidl_next::wire::fuchsia::Channel,
3507 >>::COPY_OPTIMIZATION
3508 .is_enabled(),
3509 )
3510 };
3511
3512 #[inline]
3513 fn from_wire(wire: crate::wire::MultipleHandleSubtypes) -> Self {
3514 Self {
3515 untyped: ::fidl_next::FromWire::from_wire(wire.untyped),
3516
3517 event: ::fidl_next::FromWire::from_wire(wire.event),
3518
3519 channel: ::fidl_next::FromWire::from_wire(wire.channel),
3520 }
3521 }
3522 }
3523
3524 #[derive(Debug, PartialEq)]
3525 #[repr(C)]
3526 pub struct MultipleNonnullableHandles {
3527 pub data0: u32,
3528
3529 pub handle0: ::fidl_next::fuchsia::zx::NullableHandle,
3530
3531 pub data1: u64,
3532
3533 pub handle1: ::fidl_next::fuchsia::zx::Channel,
3534
3535 pub handle2: ::fidl_next::fuchsia::zx::Event,
3536
3537 pub data2: u64,
3538 }
3539
3540 unsafe impl<___E> ::fidl_next::Encode<crate::wire::MultipleNonnullableHandles, ___E>
3541 for MultipleNonnullableHandles
3542 where
3543 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3544 ___E: ::fidl_next::fuchsia::HandleEncoder,
3545 {
3546 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3547 Self,
3548 crate::wire::MultipleNonnullableHandles,
3549 > = unsafe {
3550 ::fidl_next::CopyOptimization::enable_if(
3551 true
3552
3553 && <
3554 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3555 >::COPY_OPTIMIZATION.is_enabled()
3556
3557 && <
3558 ::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>
3559 >::COPY_OPTIMIZATION.is_enabled()
3560
3561 && <
3562 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
3563 >::COPY_OPTIMIZATION.is_enabled()
3564
3565 && <
3566 ::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>
3567 >::COPY_OPTIMIZATION.is_enabled()
3568
3569 && <
3570 ::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>
3571 >::COPY_OPTIMIZATION.is_enabled()
3572
3573 && <
3574 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
3575 >::COPY_OPTIMIZATION.is_enabled()
3576
3577 )
3578 };
3579
3580 #[inline]
3581 fn encode(
3582 self,
3583 encoder_: &mut ___E,
3584 out_: &mut ::core::mem::MaybeUninit<crate::wire::MultipleNonnullableHandles>,
3585 _: (),
3586 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3587 ::fidl_next::munge! {
3588 let crate::wire::MultipleNonnullableHandles {
3589 data0,
3590 handle0,
3591 data1,
3592 handle1,
3593 handle2,
3594 data2,
3595
3596 } = out_;
3597 }
3598
3599 ::fidl_next::Encode::encode(self.data0, encoder_, data0, ())?;
3600
3601 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data0.as_mut_ptr()) };
3602
3603 ::fidl_next::Encode::encode(self.handle0, encoder_, handle0, ())?;
3604
3605 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle0.as_mut_ptr()) };
3606
3607 ::fidl_next::Encode::encode(self.data1, encoder_, data1, ())?;
3608
3609 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data1.as_mut_ptr()) };
3610
3611 ::fidl_next::Encode::encode(self.handle1, encoder_, handle1, ())?;
3612
3613 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle1.as_mut_ptr()) };
3614
3615 ::fidl_next::Encode::encode(self.handle2, encoder_, handle2, ())?;
3616
3617 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle2.as_mut_ptr()) };
3618
3619 ::fidl_next::Encode::encode(self.data2, encoder_, data2, ())?;
3620
3621 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data2.as_mut_ptr()) };
3622
3623 Ok(())
3624 }
3625 }
3626
3627 unsafe impl<___E>
3628 ::fidl_next::EncodeOption<
3629 ::fidl_next::wire::Box<'static, crate::wire::MultipleNonnullableHandles>,
3630 ___E,
3631 > for MultipleNonnullableHandles
3632 where
3633 ___E: ::fidl_next::Encoder + ?Sized,
3634 MultipleNonnullableHandles:
3635 ::fidl_next::Encode<crate::wire::MultipleNonnullableHandles, ___E>,
3636 {
3637 #[inline]
3638 fn encode_option(
3639 this: ::core::option::Option<Self>,
3640 encoder: &mut ___E,
3641 out: &mut ::core::mem::MaybeUninit<
3642 ::fidl_next::wire::Box<'static, crate::wire::MultipleNonnullableHandles>,
3643 >,
3644 _: (),
3645 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3646 if let Some(inner) = this {
3647 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3648 ::fidl_next::wire::Box::encode_present(out);
3649 } else {
3650 ::fidl_next::wire::Box::encode_absent(out);
3651 }
3652
3653 Ok(())
3654 }
3655 }
3656
3657 impl ::fidl_next::FromWire<crate::wire::MultipleNonnullableHandles> for MultipleNonnullableHandles {
3658 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3659 crate::wire::MultipleNonnullableHandles,
3660 Self,
3661 > = unsafe {
3662 ::fidl_next::CopyOptimization::enable_if(
3663 true
3664 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
3665 .is_enabled()
3666 && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::FromWire<
3667 ::fidl_next::wire::fuchsia::NullableHandle,
3668 >>::COPY_OPTIMIZATION
3669 .is_enabled()
3670 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
3671 .is_enabled()
3672 && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3673 ::fidl_next::wire::fuchsia::Channel,
3674 >>::COPY_OPTIMIZATION
3675 .is_enabled()
3676 && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
3677 ::fidl_next::wire::fuchsia::Event,
3678 >>::COPY_OPTIMIZATION
3679 .is_enabled()
3680 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
3681 .is_enabled(),
3682 )
3683 };
3684
3685 #[inline]
3686 fn from_wire(wire: crate::wire::MultipleNonnullableHandles) -> Self {
3687 Self {
3688 data0: ::fidl_next::FromWire::from_wire(wire.data0),
3689
3690 handle0: ::fidl_next::FromWire::from_wire(wire.handle0),
3691
3692 data1: ::fidl_next::FromWire::from_wire(wire.data1),
3693
3694 handle1: ::fidl_next::FromWire::from_wire(wire.handle1),
3695
3696 handle2: ::fidl_next::FromWire::from_wire(wire.handle2),
3697
3698 data2: ::fidl_next::FromWire::from_wire(wire.data2),
3699 }
3700 }
3701 }
3702
3703 #[derive(Debug, PartialEq)]
3704 #[repr(C)]
3705 pub struct MultipleNullableHandles {
3706 pub data0: u32,
3707
3708 pub handle0: ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>,
3709
3710 pub data1: u64,
3711
3712 pub handle1: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
3713
3714 pub handle2: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
3715
3716 pub data2: u64,
3717 }
3718
3719 unsafe impl<___E> ::fidl_next::Encode<crate::wire::MultipleNullableHandles, ___E>
3720 for MultipleNullableHandles
3721 where
3722 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3723 ___E: ::fidl_next::fuchsia::HandleEncoder,
3724 {
3725 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3726 Self,
3727 crate::wire::MultipleNullableHandles,
3728 > = unsafe {
3729 ::fidl_next::CopyOptimization::enable_if(
3730 true
3731
3732 && <
3733 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
3734 >::COPY_OPTIMIZATION.is_enabled()
3735
3736 && <
3737 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>
3738 >::COPY_OPTIMIZATION.is_enabled()
3739
3740 && <
3741 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
3742 >::COPY_OPTIMIZATION.is_enabled()
3743
3744 && <
3745 ::core::option::Option<::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalChannel, ___E>
3746 >::COPY_OPTIMIZATION.is_enabled()
3747
3748 && <
3749 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>
3750 >::COPY_OPTIMIZATION.is_enabled()
3751
3752 && <
3753 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
3754 >::COPY_OPTIMIZATION.is_enabled()
3755
3756 )
3757 };
3758
3759 #[inline]
3760 fn encode(
3761 self,
3762 encoder_: &mut ___E,
3763 out_: &mut ::core::mem::MaybeUninit<crate::wire::MultipleNullableHandles>,
3764 _: (),
3765 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3766 ::fidl_next::munge! {
3767 let crate::wire::MultipleNullableHandles {
3768 data0,
3769 handle0,
3770 data1,
3771 handle1,
3772 handle2,
3773 data2,
3774
3775 } = out_;
3776 }
3777
3778 ::fidl_next::Encode::encode(self.data0, encoder_, data0, ())?;
3779
3780 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data0.as_mut_ptr()) };
3781
3782 ::fidl_next::Encode::encode(self.handle0, encoder_, handle0, ())?;
3783
3784 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle0.as_mut_ptr()) };
3785
3786 ::fidl_next::Encode::encode(self.data1, encoder_, data1, ())?;
3787
3788 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data1.as_mut_ptr()) };
3789
3790 ::fidl_next::Encode::encode(self.handle1, encoder_, handle1, ())?;
3791
3792 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle1.as_mut_ptr()) };
3793
3794 ::fidl_next::Encode::encode(self.handle2, encoder_, handle2, ())?;
3795
3796 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handle2.as_mut_ptr()) };
3797
3798 ::fidl_next::Encode::encode(self.data2, encoder_, data2, ())?;
3799
3800 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data2.as_mut_ptr()) };
3801
3802 Ok(())
3803 }
3804 }
3805
3806 unsafe impl<___E>
3807 ::fidl_next::EncodeOption<
3808 ::fidl_next::wire::Box<'static, crate::wire::MultipleNullableHandles>,
3809 ___E,
3810 > for MultipleNullableHandles
3811 where
3812 ___E: ::fidl_next::Encoder + ?Sized,
3813 MultipleNullableHandles: ::fidl_next::Encode<crate::wire::MultipleNullableHandles, ___E>,
3814 {
3815 #[inline]
3816 fn encode_option(
3817 this: ::core::option::Option<Self>,
3818 encoder: &mut ___E,
3819 out: &mut ::core::mem::MaybeUninit<
3820 ::fidl_next::wire::Box<'static, crate::wire::MultipleNullableHandles>,
3821 >,
3822 _: (),
3823 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3824 if let Some(inner) = this {
3825 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3826 ::fidl_next::wire::Box::encode_present(out);
3827 } else {
3828 ::fidl_next::wire::Box::encode_absent(out);
3829 }
3830
3831 Ok(())
3832 }
3833 }
3834
3835 impl ::fidl_next::FromWire<crate::wire::MultipleNullableHandles> for MultipleNullableHandles {
3836 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3837 crate::wire::MultipleNullableHandles,
3838 Self,
3839 > = unsafe {
3840 ::fidl_next::CopyOptimization::enable_if(
3841 true
3842
3843 && <
3844 u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>
3845 >::COPY_OPTIMIZATION.is_enabled()
3846
3847 && <
3848 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalNullableHandle>
3849 >::COPY_OPTIMIZATION.is_enabled()
3850
3851 && <
3852 u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>
3853 >::COPY_OPTIMIZATION.is_enabled()
3854
3855 && <
3856 ::core::option::Option<::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalChannel>
3857 >::COPY_OPTIMIZATION.is_enabled()
3858
3859 && <
3860 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalEvent>
3861 >::COPY_OPTIMIZATION.is_enabled()
3862
3863 && <
3864 u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>
3865 >::COPY_OPTIMIZATION.is_enabled()
3866
3867 )
3868 };
3869
3870 #[inline]
3871 fn from_wire(wire: crate::wire::MultipleNullableHandles) -> Self {
3872 Self {
3873 data0: ::fidl_next::FromWire::from_wire(wire.data0),
3874
3875 handle0: ::fidl_next::FromWire::from_wire(wire.handle0),
3876
3877 data1: ::fidl_next::FromWire::from_wire(wire.data1),
3878
3879 handle1: ::fidl_next::FromWire::from_wire(wire.handle1),
3880
3881 handle2: ::fidl_next::FromWire::from_wire(wire.handle2),
3882
3883 data2: ::fidl_next::FromWire::from_wire(wire.data2),
3884 }
3885 }
3886 }
3887
3888 #[derive(Debug, PartialEq)]
3889 #[repr(C)]
3890 pub struct NonnullableHandle {
3891 pub h: ::fidl_next::fuchsia::zx::NullableHandle,
3892 }
3893
3894 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NonnullableHandle, ___E> for NonnullableHandle
3895 where
3896 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3897 ___E: ::fidl_next::fuchsia::HandleEncoder,
3898 {
3899 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3900 Self,
3901 crate::wire::NonnullableHandle,
3902 > = unsafe {
3903 ::fidl_next::CopyOptimization::enable_if(
3904 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::Encode<
3905 ::fidl_next::wire::fuchsia::NullableHandle,
3906 ___E,
3907 >>::COPY_OPTIMIZATION
3908 .is_enabled(),
3909 )
3910 };
3911
3912 #[inline]
3913 fn encode(
3914 self,
3915 encoder_: &mut ___E,
3916 out_: &mut ::core::mem::MaybeUninit<crate::wire::NonnullableHandle>,
3917 _: (),
3918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3919 ::fidl_next::munge! {
3920 let crate::wire::NonnullableHandle {
3921 h,
3922
3923 } = out_;
3924 }
3925
3926 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
3927
3928 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
3929
3930 Ok(())
3931 }
3932 }
3933
3934 unsafe impl<___E>
3935 ::fidl_next::EncodeOption<
3936 ::fidl_next::wire::Box<'static, crate::wire::NonnullableHandle>,
3937 ___E,
3938 > for NonnullableHandle
3939 where
3940 ___E: ::fidl_next::Encoder + ?Sized,
3941 NonnullableHandle: ::fidl_next::Encode<crate::wire::NonnullableHandle, ___E>,
3942 {
3943 #[inline]
3944 fn encode_option(
3945 this: ::core::option::Option<Self>,
3946 encoder: &mut ___E,
3947 out: &mut ::core::mem::MaybeUninit<
3948 ::fidl_next::wire::Box<'static, crate::wire::NonnullableHandle>,
3949 >,
3950 _: (),
3951 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3952 if let Some(inner) = this {
3953 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3954 ::fidl_next::wire::Box::encode_present(out);
3955 } else {
3956 ::fidl_next::wire::Box::encode_absent(out);
3957 }
3958
3959 Ok(())
3960 }
3961 }
3962
3963 impl ::fidl_next::FromWire<crate::wire::NonnullableHandle> for NonnullableHandle {
3964 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3965 crate::wire::NonnullableHandle,
3966 Self,
3967 > = unsafe {
3968 ::fidl_next::CopyOptimization::enable_if(
3969 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::FromWire<
3970 ::fidl_next::wire::fuchsia::NullableHandle,
3971 >>::COPY_OPTIMIZATION
3972 .is_enabled(),
3973 )
3974 };
3975
3976 #[inline]
3977 fn from_wire(wire: crate::wire::NonnullableHandle) -> Self {
3978 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
3979 }
3980 }
3981
3982 #[derive(Debug, PartialEq)]
3983 #[repr(C)]
3984 pub struct NonnullableHandleArray {
3985 pub handles: [::fidl_next::fuchsia::zx::NullableHandle; 4],
3986 }
3987
3988 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NonnullableHandleArray, ___E>
3989 for NonnullableHandleArray
3990 where
3991 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3992 ___E: ::fidl_next::fuchsia::HandleEncoder,
3993 {
3994 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3995 Self,
3996 crate::wire::NonnullableHandleArray,
3997 > = unsafe {
3998 ::fidl_next::CopyOptimization::enable_if(
3999 true && <[::fidl_next::fuchsia::zx::NullableHandle; 4] as ::fidl_next::Encode<
4000 [::fidl_next::wire::fuchsia::NullableHandle; 4],
4001 ___E,
4002 >>::COPY_OPTIMIZATION
4003 .is_enabled(),
4004 )
4005 };
4006
4007 #[inline]
4008 fn encode(
4009 self,
4010 encoder_: &mut ___E,
4011 out_: &mut ::core::mem::MaybeUninit<crate::wire::NonnullableHandleArray>,
4012 _: (),
4013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4014 ::fidl_next::munge! {
4015 let crate::wire::NonnullableHandleArray {
4016 handles,
4017
4018 } = out_;
4019 }
4020
4021 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
4022
4023 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handles.as_mut_ptr()) };
4024
4025 Ok(())
4026 }
4027 }
4028
4029 unsafe impl<___E>
4030 ::fidl_next::EncodeOption<
4031 ::fidl_next::wire::Box<'static, crate::wire::NonnullableHandleArray>,
4032 ___E,
4033 > for NonnullableHandleArray
4034 where
4035 ___E: ::fidl_next::Encoder + ?Sized,
4036 NonnullableHandleArray: ::fidl_next::Encode<crate::wire::NonnullableHandleArray, ___E>,
4037 {
4038 #[inline]
4039 fn encode_option(
4040 this: ::core::option::Option<Self>,
4041 encoder: &mut ___E,
4042 out: &mut ::core::mem::MaybeUninit<
4043 ::fidl_next::wire::Box<'static, crate::wire::NonnullableHandleArray>,
4044 >,
4045 _: (),
4046 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4047 if let Some(inner) = this {
4048 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4049 ::fidl_next::wire::Box::encode_present(out);
4050 } else {
4051 ::fidl_next::wire::Box::encode_absent(out);
4052 }
4053
4054 Ok(())
4055 }
4056 }
4057
4058 impl ::fidl_next::FromWire<crate::wire::NonnullableHandleArray> for NonnullableHandleArray {
4059 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4060 crate::wire::NonnullableHandleArray,
4061 Self,
4062 > = unsafe {
4063 ::fidl_next::CopyOptimization::enable_if(
4064 true && <[::fidl_next::fuchsia::zx::NullableHandle; 4] as ::fidl_next::FromWire<
4065 [::fidl_next::wire::fuchsia::NullableHandle; 4],
4066 >>::COPY_OPTIMIZATION
4067 .is_enabled(),
4068 )
4069 };
4070
4071 #[inline]
4072 fn from_wire(wire: crate::wire::NonnullableHandleArray) -> Self {
4073 Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
4074 }
4075 }
4076
4077 #[derive(Debug, PartialEq)]
4078 #[repr(C)]
4079 pub struct NullableHandle {
4080 pub h: ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>,
4081 }
4082
4083 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NullableHandle, ___E> for NullableHandle
4084 where
4085 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4086 ___E: ::fidl_next::fuchsia::HandleEncoder,
4087 {
4088 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::NullableHandle> = unsafe {
4089 ::fidl_next::CopyOptimization::enable_if(
4090 true
4091
4092 && <
4093 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>
4094 >::COPY_OPTIMIZATION.is_enabled()
4095
4096 )
4097 };
4098
4099 #[inline]
4100 fn encode(
4101 self,
4102 encoder_: &mut ___E,
4103 out_: &mut ::core::mem::MaybeUninit<crate::wire::NullableHandle>,
4104 _: (),
4105 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4106 ::fidl_next::munge! {
4107 let crate::wire::NullableHandle {
4108 h,
4109
4110 } = out_;
4111 }
4112
4113 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
4114
4115 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
4116
4117 Ok(())
4118 }
4119 }
4120
4121 unsafe impl<___E>
4122 ::fidl_next::EncodeOption<
4123 ::fidl_next::wire::Box<'static, crate::wire::NullableHandle>,
4124 ___E,
4125 > for NullableHandle
4126 where
4127 ___E: ::fidl_next::Encoder + ?Sized,
4128 NullableHandle: ::fidl_next::Encode<crate::wire::NullableHandle, ___E>,
4129 {
4130 #[inline]
4131 fn encode_option(
4132 this: ::core::option::Option<Self>,
4133 encoder: &mut ___E,
4134 out: &mut ::core::mem::MaybeUninit<
4135 ::fidl_next::wire::Box<'static, crate::wire::NullableHandle>,
4136 >,
4137 _: (),
4138 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4139 if let Some(inner) = this {
4140 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4141 ::fidl_next::wire::Box::encode_present(out);
4142 } else {
4143 ::fidl_next::wire::Box::encode_absent(out);
4144 }
4145
4146 Ok(())
4147 }
4148 }
4149
4150 impl ::fidl_next::FromWire<crate::wire::NullableHandle> for NullableHandle {
4151 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::NullableHandle, Self> = unsafe {
4152 ::fidl_next::CopyOptimization::enable_if(
4153 true
4154
4155 && <
4156 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalNullableHandle>
4157 >::COPY_OPTIMIZATION.is_enabled()
4158
4159 )
4160 };
4161
4162 #[inline]
4163 fn from_wire(wire: crate::wire::NullableHandle) -> Self {
4164 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
4165 }
4166 }
4167
4168 #[derive(Debug, PartialEq)]
4169 pub struct OutOfLineArrayOfNonnullableHandles {
4170 pub handles:
4171 ::core::option::Option<::std::boxed::Box<crate::natural::NonnullableHandleArray>>,
4172 }
4173
4174 unsafe impl<___E>
4175 ::fidl_next::Encode<crate::wire::OutOfLineArrayOfNonnullableHandles<'static>, ___E>
4176 for OutOfLineArrayOfNonnullableHandles
4177 where
4178 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4179 ___E: ::fidl_next::Encoder,
4180 ___E: ::fidl_next::fuchsia::HandleEncoder,
4181 {
4182 #[inline]
4183 fn encode(
4184 self,
4185 encoder_: &mut ___E,
4186 out_: &mut ::core::mem::MaybeUninit<
4187 crate::wire::OutOfLineArrayOfNonnullableHandles<'static>,
4188 >,
4189 _: (),
4190 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4191 ::fidl_next::munge! {
4192 let crate::wire::OutOfLineArrayOfNonnullableHandles {
4193 handles,
4194
4195 } = out_;
4196 }
4197
4198 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
4199
4200 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(handles.as_mut_ptr()) };
4201
4202 Ok(())
4203 }
4204 }
4205
4206 unsafe impl<___E>
4207 ::fidl_next::EncodeOption<
4208 ::fidl_next::wire::Box<
4209 'static,
4210 crate::wire::OutOfLineArrayOfNonnullableHandles<'static>,
4211 >,
4212 ___E,
4213 > for OutOfLineArrayOfNonnullableHandles
4214 where
4215 ___E: ::fidl_next::Encoder + ?Sized,
4216 OutOfLineArrayOfNonnullableHandles:
4217 ::fidl_next::Encode<crate::wire::OutOfLineArrayOfNonnullableHandles<'static>, ___E>,
4218 {
4219 #[inline]
4220 fn encode_option(
4221 this: ::core::option::Option<Self>,
4222 encoder: &mut ___E,
4223 out: &mut ::core::mem::MaybeUninit<
4224 ::fidl_next::wire::Box<
4225 'static,
4226 crate::wire::OutOfLineArrayOfNonnullableHandles<'static>,
4227 >,
4228 >,
4229 _: (),
4230 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4231 if let Some(inner) = this {
4232 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4233 ::fidl_next::wire::Box::encode_present(out);
4234 } else {
4235 ::fidl_next::wire::Box::encode_absent(out);
4236 }
4237
4238 Ok(())
4239 }
4240 }
4241
4242 impl<'de> ::fidl_next::FromWire<crate::wire::OutOfLineArrayOfNonnullableHandles<'de>>
4243 for OutOfLineArrayOfNonnullableHandles
4244 {
4245 #[inline]
4246 fn from_wire(wire: crate::wire::OutOfLineArrayOfNonnullableHandles<'de>) -> Self {
4247 Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
4248 }
4249 }
4250
4251 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4252 pub enum SampleResourceXUnion {
4253 U(u32),
4254
4255 Su(crate::natural::SimpleUnion),
4256
4257 St(crate::natural::SimpleTable),
4258
4259 UnknownOrdinal_(u64),
4260 }
4261
4262 impl SampleResourceXUnion {
4263 pub fn is_unknown(&self) -> bool {
4264 #[allow(unreachable_patterns)]
4265 match self {
4266 Self::UnknownOrdinal_(_) => true,
4267 _ => false,
4268 }
4269 }
4270 }
4271
4272 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SampleResourceXUnion<'static>, ___E>
4273 for SampleResourceXUnion
4274 where
4275 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4276 ___E: ::fidl_next::Encoder,
4277 ___E: ::fidl_next::fuchsia::HandleEncoder,
4278 {
4279 #[inline]
4280 fn encode(
4281 self,
4282 encoder: &mut ___E,
4283 out: &mut ::core::mem::MaybeUninit<crate::wire::SampleResourceXUnion<'static>>,
4284 _: (),
4285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4286 ::fidl_next::munge!(let crate::wire::SampleResourceXUnion { raw, _phantom: _ } = out);
4287
4288 match self {
4289 Self::U(value) => ::fidl_next::wire::Union::encode_as::<
4290 ___E,
4291 ::fidl_next::wire::Uint32,
4292 >(value, 1, encoder, raw, ())?,
4293
4294 Self::Su(value) => ::fidl_next::wire::Union::encode_as::<
4295 ___E,
4296 crate::wire::SimpleUnion<'static>,
4297 >(value, 2, encoder, raw, ())?,
4298
4299 Self::St(value) => ::fidl_next::wire::Union::encode_as::<
4300 ___E,
4301 crate::wire::SimpleTable<'static>,
4302 >(value, 3, encoder, raw, ())?,
4303
4304 Self::UnknownOrdinal_(ordinal) => {
4305 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
4306 }
4307 }
4308
4309 Ok(())
4310 }
4311 }
4312
4313 unsafe impl<___E>
4314 ::fidl_next::EncodeOption<crate::wire_optional::SampleResourceXUnion<'static>, ___E>
4315 for SampleResourceXUnion
4316 where
4317 ___E: ?Sized,
4318 SampleResourceXUnion: ::fidl_next::Encode<crate::wire::SampleResourceXUnion<'static>, ___E>,
4319 {
4320 #[inline]
4321 fn encode_option(
4322 this: ::core::option::Option<Self>,
4323 encoder: &mut ___E,
4324 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SampleResourceXUnion<'static>>,
4325 _: (),
4326 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4327 ::fidl_next::munge!(let crate::wire_optional::SampleResourceXUnion { raw, _phantom: _ } = &mut *out);
4328
4329 if let Some(inner) = this {
4330 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4331 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4332 } else {
4333 ::fidl_next::wire::Union::encode_absent(raw);
4334 }
4335
4336 Ok(())
4337 }
4338 }
4339
4340 impl<'de> ::fidl_next::FromWire<crate::wire::SampleResourceXUnion<'de>> for SampleResourceXUnion {
4341 #[inline]
4342 fn from_wire(wire: crate::wire::SampleResourceXUnion<'de>) -> Self {
4343 let wire = ::core::mem::ManuallyDrop::new(wire);
4344 match wire.raw.ordinal() {
4345 1 => Self::U(::fidl_next::FromWire::from_wire(unsafe {
4346 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
4347 })),
4348
4349 2 => Self::Su(::fidl_next::FromWire::from_wire(unsafe {
4350 wire.raw.get().read_unchecked::<crate::wire::SimpleUnion<'de>>()
4351 })),
4352
4353 3 => Self::St(::fidl_next::FromWire::from_wire(unsafe {
4354 wire.raw.get().read_unchecked::<crate::wire::SimpleTable<'de>>()
4355 })),
4356
4357 ord => return Self::UnknownOrdinal_(ord as u64),
4358 }
4359 }
4360 }
4361
4362 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SampleResourceXUnion<'de>>
4363 for SampleResourceXUnion
4364 {
4365 #[inline]
4366 fn from_wire_option(
4367 wire: crate::wire_optional::SampleResourceXUnion<'de>,
4368 ) -> ::core::option::Option<Self> {
4369 if let Some(inner) = wire.into_option() {
4370 Some(::fidl_next::FromWire::from_wire(inner))
4371 } else {
4372 None
4373 }
4374 }
4375 }
4376
4377 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SampleResourceXUnion<'de>>
4378 for Box<SampleResourceXUnion>
4379 {
4380 #[inline]
4381 fn from_wire_option(
4382 wire: crate::wire_optional::SampleResourceXUnion<'de>,
4383 ) -> ::core::option::Option<Self> {
4384 <SampleResourceXUnion as ::fidl_next::FromWireOption<
4385 crate::wire_optional::SampleResourceXUnion<'de>,
4386 >>::from_wire_option(wire)
4387 .map(Box::new)
4388 }
4389 }
4390
4391 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4392 pub enum SampleStrictResourceXUnion {
4393 U(u32),
4394
4395 Su(crate::natural::SimpleUnion),
4396
4397 St(crate::natural::SimpleTable),
4398 }
4399
4400 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SampleStrictResourceXUnion<'static>, ___E>
4401 for SampleStrictResourceXUnion
4402 where
4403 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4404 ___E: ::fidl_next::Encoder,
4405 ___E: ::fidl_next::fuchsia::HandleEncoder,
4406 {
4407 #[inline]
4408 fn encode(
4409 self,
4410 encoder: &mut ___E,
4411 out: &mut ::core::mem::MaybeUninit<crate::wire::SampleStrictResourceXUnion<'static>>,
4412 _: (),
4413 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4414 ::fidl_next::munge!(let crate::wire::SampleStrictResourceXUnion { raw, _phantom: _ } = out);
4415
4416 match self {
4417 Self::U(value) => ::fidl_next::wire::Union::encode_as::<
4418 ___E,
4419 ::fidl_next::wire::Uint32,
4420 >(value, 1, encoder, raw, ())?,
4421
4422 Self::Su(value) => ::fidl_next::wire::Union::encode_as::<
4423 ___E,
4424 crate::wire::SimpleUnion<'static>,
4425 >(value, 2, encoder, raw, ())?,
4426
4427 Self::St(value) => ::fidl_next::wire::Union::encode_as::<
4428 ___E,
4429 crate::wire::SimpleTable<'static>,
4430 >(value, 3, encoder, raw, ())?,
4431 }
4432
4433 Ok(())
4434 }
4435 }
4436
4437 unsafe impl<___E>
4438 ::fidl_next::EncodeOption<crate::wire_optional::SampleStrictResourceXUnion<'static>, ___E>
4439 for SampleStrictResourceXUnion
4440 where
4441 ___E: ?Sized,
4442 SampleStrictResourceXUnion:
4443 ::fidl_next::Encode<crate::wire::SampleStrictResourceXUnion<'static>, ___E>,
4444 {
4445 #[inline]
4446 fn encode_option(
4447 this: ::core::option::Option<Self>,
4448 encoder: &mut ___E,
4449 out: &mut ::core::mem::MaybeUninit<
4450 crate::wire_optional::SampleStrictResourceXUnion<'static>,
4451 >,
4452 _: (),
4453 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4454 ::fidl_next::munge!(let crate::wire_optional::SampleStrictResourceXUnion { raw, _phantom: _ } = &mut *out);
4455
4456 if let Some(inner) = this {
4457 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4458 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4459 } else {
4460 ::fidl_next::wire::Union::encode_absent(raw);
4461 }
4462
4463 Ok(())
4464 }
4465 }
4466
4467 impl<'de> ::fidl_next::FromWire<crate::wire::SampleStrictResourceXUnion<'de>>
4468 for SampleStrictResourceXUnion
4469 {
4470 #[inline]
4471 fn from_wire(wire: crate::wire::SampleStrictResourceXUnion<'de>) -> Self {
4472 let wire = ::core::mem::ManuallyDrop::new(wire);
4473 match wire.raw.ordinal() {
4474 1 => Self::U(::fidl_next::FromWire::from_wire(unsafe {
4475 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
4476 })),
4477
4478 2 => Self::Su(::fidl_next::FromWire::from_wire(unsafe {
4479 wire.raw.get().read_unchecked::<crate::wire::SimpleUnion<'de>>()
4480 })),
4481
4482 3 => Self::St(::fidl_next::FromWire::from_wire(unsafe {
4483 wire.raw.get().read_unchecked::<crate::wire::SimpleTable<'de>>()
4484 })),
4485
4486 _ => unsafe { ::core::hint::unreachable_unchecked() },
4487 }
4488 }
4489 }
4490
4491 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SampleStrictResourceXUnion<'de>>
4492 for SampleStrictResourceXUnion
4493 {
4494 #[inline]
4495 fn from_wire_option(
4496 wire: crate::wire_optional::SampleStrictResourceXUnion<'de>,
4497 ) -> ::core::option::Option<Self> {
4498 if let Some(inner) = wire.into_option() {
4499 Some(::fidl_next::FromWire::from_wire(inner))
4500 } else {
4501 None
4502 }
4503 }
4504 }
4505
4506 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SampleStrictResourceXUnion<'de>>
4507 for Box<SampleStrictResourceXUnion>
4508 {
4509 #[inline]
4510 fn from_wire_option(
4511 wire: crate::wire_optional::SampleStrictResourceXUnion<'de>,
4512 ) -> ::core::option::Option<Self> {
4513 <SampleStrictResourceXUnion as ::fidl_next::FromWireOption<
4514 crate::wire_optional::SampleStrictResourceXUnion<'de>,
4515 >>::from_wire_option(wire)
4516 .map(Box::new)
4517 }
4518 }
4519
4520 #[derive(Debug, PartialEq)]
4521 pub enum UnionWithVector {
4522 Unused(u8),
4523
4524 VectorOfUint8(::std::vec::Vec<u8>),
4525
4526 S(::std::string::String),
4527
4528 VectorS3A1(::std::vec::Vec<crate::natural::StructSize3Align1>),
4529
4530 VectorS3A2(::std::vec::Vec<crate::natural::StructSize3Align2>),
4531
4532 Handles(::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>),
4533
4534 ArrayS3A1([crate::natural::StructSize3Align1; 2]),
4535
4536 ArrayS3A2([crate::natural::StructSize3Align2; 2]),
4537
4538 VectorUnion(::std::vec::Vec<crate::natural::UnionSize8Align4>),
4539 }
4540
4541 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnionWithVector<'static>, ___E>
4542 for UnionWithVector
4543 where
4544 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4545 ___E: ::fidl_next::Encoder,
4546 ___E: ::fidl_next::fuchsia::HandleEncoder,
4547 {
4548 #[inline]
4549 fn encode(
4550 self,
4551 encoder: &mut ___E,
4552 out: &mut ::core::mem::MaybeUninit<crate::wire::UnionWithVector<'static>>,
4553 _: (),
4554 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4555 ::fidl_next::munge!(let crate::wire::UnionWithVector { raw, _phantom: _ } = out);
4556
4557 match self {
4558 Self::Unused(value) => {
4559 ::fidl_next::wire::Union::encode_as::<___E, u8>(value, 1, encoder, raw, ())?
4560 }
4561
4562 Self::VectorOfUint8(value) => {
4563 ::fidl_next::wire::Union::encode_as::<
4564 ___E,
4565 ::fidl_next::wire::Vector<'static, u8>,
4566 >(value, 2, encoder, raw, (4294967295, ()))?
4567 }
4568
4569 Self::S(value) => ::fidl_next::wire::Union::encode_as::<
4570 ___E,
4571 ::fidl_next::wire::String<'static>,
4572 >(value, 3, encoder, raw, 4294967295)?,
4573
4574 Self::VectorS3A1(value) => {
4575 ::fidl_next::wire::Union::encode_as::<
4576 ___E,
4577 ::fidl_next::wire::Vector<'static, crate::wire::StructSize3Align1>,
4578 >(value, 4, encoder, raw, (4294967295, ()))?
4579 }
4580
4581 Self::VectorS3A2(value) => {
4582 ::fidl_next::wire::Union::encode_as::<
4583 ___E,
4584 ::fidl_next::wire::Vector<'static, crate::wire::StructSize3Align2>,
4585 >(value, 5, encoder, raw, (4294967295, ()))?
4586 }
4587
4588 Self::Handles(value) => ::fidl_next::wire::Union::encode_as::<
4589 ___E,
4590 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
4591 >(value, 6, encoder, raw, (4294967295, ()))?,
4592
4593 Self::ArrayS3A1(value) => ::fidl_next::wire::Union::encode_as::<
4594 ___E,
4595 [crate::wire::StructSize3Align1; 2],
4596 >(value, 7, encoder, raw, ())?,
4597
4598 Self::ArrayS3A2(value) => ::fidl_next::wire::Union::encode_as::<
4599 ___E,
4600 [crate::wire::StructSize3Align2; 2],
4601 >(value, 8, encoder, raw, ())?,
4602
4603 Self::VectorUnion(value) => {
4604 ::fidl_next::wire::Union::encode_as::<
4605 ___E,
4606 ::fidl_next::wire::Vector<'static, crate::wire::UnionSize8Align4>,
4607 >(value, 9, encoder, raw, (4294967295, ()))?
4608 }
4609 }
4610
4611 Ok(())
4612 }
4613 }
4614
4615 unsafe impl<___E>
4616 ::fidl_next::EncodeOption<crate::wire_optional::UnionWithVector<'static>, ___E>
4617 for UnionWithVector
4618 where
4619 ___E: ?Sized,
4620 UnionWithVector: ::fidl_next::Encode<crate::wire::UnionWithVector<'static>, ___E>,
4621 {
4622 #[inline]
4623 fn encode_option(
4624 this: ::core::option::Option<Self>,
4625 encoder: &mut ___E,
4626 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::UnionWithVector<'static>>,
4627 _: (),
4628 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4629 ::fidl_next::munge!(let crate::wire_optional::UnionWithVector { raw, _phantom: _ } = &mut *out);
4630
4631 if let Some(inner) = this {
4632 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4633 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4634 } else {
4635 ::fidl_next::wire::Union::encode_absent(raw);
4636 }
4637
4638 Ok(())
4639 }
4640 }
4641
4642 impl<'de> ::fidl_next::FromWire<crate::wire::UnionWithVector<'de>> for UnionWithVector {
4643 #[inline]
4644 fn from_wire(wire: crate::wire::UnionWithVector<'de>) -> Self {
4645 let wire = ::core::mem::ManuallyDrop::new(wire);
4646 match wire.raw.ordinal() {
4647 1 => Self::Unused(::fidl_next::FromWire::from_wire(unsafe {
4648 wire.raw.get().read_unchecked::<u8>()
4649 })),
4650
4651 2 => Self::VectorOfUint8(::fidl_next::FromWire::from_wire(unsafe {
4652 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
4653 })),
4654
4655 3 => Self::S(::fidl_next::FromWire::from_wire(unsafe {
4656 wire.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
4657 })),
4658
4659 4 => Self::VectorS3A1(::fidl_next::FromWire::from_wire(unsafe {
4660 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>>()
4661 })),
4662
4663 5 => Self::VectorS3A2(::fidl_next::FromWire::from_wire(unsafe {
4664 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>>()
4665 })),
4666
4667 6 => Self::Handles(::fidl_next::FromWire::from_wire(unsafe {
4668 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>>()
4669 })),
4670
4671 7 => Self::ArrayS3A1(::fidl_next::FromWire::from_wire(unsafe {
4672 wire.raw.get().read_unchecked::<[crate::wire::StructSize3Align1; 2]>()
4673 })),
4674
4675 8 => Self::ArrayS3A2(::fidl_next::FromWire::from_wire(unsafe {
4676 wire.raw.get().read_unchecked::<[crate::wire::StructSize3Align2; 2]>()
4677 })),
4678
4679 9 => Self::VectorUnion(::fidl_next::FromWire::from_wire(unsafe {
4680 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>>()
4681 })),
4682
4683 _ => unsafe { ::core::hint::unreachable_unchecked() },
4684 }
4685 }
4686 }
4687
4688 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::UnionWithVector<'de>>
4689 for UnionWithVector
4690 {
4691 #[inline]
4692 fn from_wire_option(
4693 wire: crate::wire_optional::UnionWithVector<'de>,
4694 ) -> ::core::option::Option<Self> {
4695 if let Some(inner) = wire.into_option() {
4696 Some(::fidl_next::FromWire::from_wire(inner))
4697 } else {
4698 None
4699 }
4700 }
4701 }
4702
4703 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::UnionWithVector<'de>>
4704 for Box<UnionWithVector>
4705 {
4706 #[inline]
4707 fn from_wire_option(
4708 wire: crate::wire_optional::UnionWithVector<'de>,
4709 ) -> ::core::option::Option<Self> {
4710 <UnionWithVector as ::fidl_next::FromWireOption<
4711 crate::wire_optional::UnionWithVector<'de>,
4712 >>::from_wire_option(wire)
4713 .map(Box::new)
4714 }
4715 }
4716
4717 #[derive(Debug, PartialEq)]
4718 pub struct Sandwich6 {
4719 pub before: u32,
4720
4721 pub the_union: crate::natural::UnionWithVector,
4722
4723 pub after: u32,
4724 }
4725
4726 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Sandwich6<'static>, ___E> for Sandwich6
4727 where
4728 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4729 ___E: ::fidl_next::Encoder,
4730 ___E: ::fidl_next::fuchsia::HandleEncoder,
4731 {
4732 #[inline]
4733 fn encode(
4734 self,
4735 encoder_: &mut ___E,
4736 out_: &mut ::core::mem::MaybeUninit<crate::wire::Sandwich6<'static>>,
4737 _: (),
4738 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4739 ::fidl_next::munge! {
4740 let crate::wire::Sandwich6 {
4741 before,
4742 the_union,
4743 after,
4744
4745 } = out_;
4746 }
4747
4748 ::fidl_next::Encode::encode(self.before, encoder_, before, ())?;
4749
4750 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(before.as_mut_ptr()) };
4751
4752 ::fidl_next::Encode::encode(self.the_union, encoder_, the_union, ())?;
4753
4754 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(the_union.as_mut_ptr()) };
4755
4756 ::fidl_next::Encode::encode(self.after, encoder_, after, ())?;
4757
4758 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(after.as_mut_ptr()) };
4759
4760 Ok(())
4761 }
4762 }
4763
4764 unsafe impl<___E>
4765 ::fidl_next::EncodeOption<
4766 ::fidl_next::wire::Box<'static, crate::wire::Sandwich6<'static>>,
4767 ___E,
4768 > for Sandwich6
4769 where
4770 ___E: ::fidl_next::Encoder + ?Sized,
4771 Sandwich6: ::fidl_next::Encode<crate::wire::Sandwich6<'static>, ___E>,
4772 {
4773 #[inline]
4774 fn encode_option(
4775 this: ::core::option::Option<Self>,
4776 encoder: &mut ___E,
4777 out: &mut ::core::mem::MaybeUninit<
4778 ::fidl_next::wire::Box<'static, crate::wire::Sandwich6<'static>>,
4779 >,
4780 _: (),
4781 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4782 if let Some(inner) = this {
4783 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4784 ::fidl_next::wire::Box::encode_present(out);
4785 } else {
4786 ::fidl_next::wire::Box::encode_absent(out);
4787 }
4788
4789 Ok(())
4790 }
4791 }
4792
4793 impl<'de> ::fidl_next::FromWire<crate::wire::Sandwich6<'de>> for Sandwich6 {
4794 #[inline]
4795 fn from_wire(wire: crate::wire::Sandwich6<'de>) -> Self {
4796 Self {
4797 before: ::fidl_next::FromWire::from_wire(wire.before),
4798
4799 the_union: ::fidl_next::FromWire::from_wire(wire.the_union),
4800
4801 after: ::fidl_next::FromWire::from_wire(wire.after),
4802 }
4803 }
4804 }
4805
4806 #[derive(Debug, PartialEq)]
4807 pub struct ShortStringThenHandle {
4808 pub s: ::std::string::String,
4809
4810 pub h: ::fidl_next::fuchsia::zx::NullableHandle,
4811 }
4812
4813 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ShortStringThenHandle<'static>, ___E>
4814 for ShortStringThenHandle
4815 where
4816 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4817 ___E: ::fidl_next::Encoder,
4818 ___E: ::fidl_next::fuchsia::HandleEncoder,
4819 {
4820 #[inline]
4821 fn encode(
4822 self,
4823 encoder_: &mut ___E,
4824 out_: &mut ::core::mem::MaybeUninit<crate::wire::ShortStringThenHandle<'static>>,
4825 _: (),
4826 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4827 ::fidl_next::munge! {
4828 let crate::wire::ShortStringThenHandle {
4829 s,
4830 h,
4831
4832 } = out_;
4833 }
4834
4835 ::fidl_next::Encode::encode(self.s, encoder_, s, 1)?;
4836
4837 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4838 ::fidl_next::Constrained::validate(_field, 1)?;
4839
4840 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
4841
4842 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
4843
4844 Ok(())
4845 }
4846 }
4847
4848 unsafe impl<___E>
4849 ::fidl_next::EncodeOption<
4850 ::fidl_next::wire::Box<'static, crate::wire::ShortStringThenHandle<'static>>,
4851 ___E,
4852 > for ShortStringThenHandle
4853 where
4854 ___E: ::fidl_next::Encoder + ?Sized,
4855 ShortStringThenHandle:
4856 ::fidl_next::Encode<crate::wire::ShortStringThenHandle<'static>, ___E>,
4857 {
4858 #[inline]
4859 fn encode_option(
4860 this: ::core::option::Option<Self>,
4861 encoder: &mut ___E,
4862 out: &mut ::core::mem::MaybeUninit<
4863 ::fidl_next::wire::Box<'static, crate::wire::ShortStringThenHandle<'static>>,
4864 >,
4865 _: (),
4866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4867 if let Some(inner) = this {
4868 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4869 ::fidl_next::wire::Box::encode_present(out);
4870 } else {
4871 ::fidl_next::wire::Box::encode_absent(out);
4872 }
4873
4874 Ok(())
4875 }
4876 }
4877
4878 impl<'de> ::fidl_next::FromWire<crate::wire::ShortStringThenHandle<'de>> for ShortStringThenHandle {
4879 #[inline]
4880 fn from_wire(wire: crate::wire::ShortStringThenHandle<'de>) -> Self {
4881 Self {
4882 s: ::fidl_next::FromWire::from_wire(wire.s),
4883
4884 h: ::fidl_next::FromWire::from_wire(wire.h),
4885 }
4886 }
4887 }
4888
4889 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4890 pub struct SimpleResourceTable {
4891 pub x: ::core::option::Option<i64>,
4892
4893 pub y: ::core::option::Option<i64>,
4894 }
4895
4896 impl SimpleResourceTable {
4897 fn __max_ordinal(&self) -> usize {
4898 if self.y.is_some() {
4899 return 5;
4900 }
4901
4902 if self.x.is_some() {
4903 return 1;
4904 }
4905
4906 0
4907 }
4908 }
4909
4910 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SimpleResourceTable<'static>, ___E>
4911 for SimpleResourceTable
4912 where
4913 ___E: ::fidl_next::Encoder + ?Sized,
4914 ___E: ::fidl_next::fuchsia::HandleEncoder,
4915 {
4916 #[inline]
4917 fn encode(
4918 mut self,
4919 encoder: &mut ___E,
4920 out: &mut ::core::mem::MaybeUninit<crate::wire::SimpleResourceTable<'static>>,
4921 _: (),
4922 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4923 ::fidl_next::munge!(let crate::wire::SimpleResourceTable { table } = out);
4924
4925 let max_ord = self.__max_ordinal();
4926
4927 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
4928 ::fidl_next::Wire::zero_padding(&mut out);
4929
4930 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
4931 ::fidl_next::wire::Envelope,
4932 >(encoder, max_ord);
4933
4934 for i in 1..=max_ord {
4935 match i {
4936 5 => {
4937 if let Some(value) = self.y.take() {
4938 ::fidl_next::wire::Envelope::encode_value::<
4939 ::fidl_next::wire::Int64,
4940 ___E,
4941 >(
4942 value, preallocated.encoder, &mut out, ()
4943 )?;
4944 } else {
4945 ::fidl_next::wire::Envelope::encode_zero(&mut out)
4946 }
4947 }
4948
4949 1 => {
4950 if let Some(value) = self.x.take() {
4951 ::fidl_next::wire::Envelope::encode_value::<
4952 ::fidl_next::wire::Int64,
4953 ___E,
4954 >(
4955 value, preallocated.encoder, &mut out, ()
4956 )?;
4957 } else {
4958 ::fidl_next::wire::Envelope::encode_zero(&mut out)
4959 }
4960 }
4961
4962 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
4963 }
4964 unsafe {
4965 preallocated.write_next(out.assume_init_ref());
4966 }
4967 }
4968
4969 ::fidl_next::wire::Table::encode_len(table, max_ord);
4970
4971 Ok(())
4972 }
4973 }
4974
4975 impl<'de> ::fidl_next::FromWire<crate::wire::SimpleResourceTable<'de>> for SimpleResourceTable {
4976 #[inline]
4977 fn from_wire(wire_: crate::wire::SimpleResourceTable<'de>) -> Self {
4978 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
4979
4980 let x = wire_.table.get(1);
4981
4982 let y = wire_.table.get(5);
4983
4984 Self {
4985 x: x.map(|envelope| {
4986 ::fidl_next::FromWire::from_wire(unsafe {
4987 envelope.read_unchecked::<::fidl_next::wire::Int64>()
4988 })
4989 }),
4990
4991 y: y.map(|envelope| {
4992 ::fidl_next::FromWire::from_wire(unsafe {
4993 envelope.read_unchecked::<::fidl_next::wire::Int64>()
4994 })
4995 }),
4996 }
4997 }
4998 }
4999
5000 #[derive(Debug, PartialEq)]
5001 #[repr(C)]
5002 pub struct SingleHandle {
5003 pub h: ::fidl_next::fuchsia::zx::NullableHandle,
5004 }
5005
5006 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SingleHandle, ___E> for SingleHandle
5007 where
5008 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5009 ___E: ::fidl_next::fuchsia::HandleEncoder,
5010 {
5011 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::SingleHandle> = unsafe {
5012 ::fidl_next::CopyOptimization::enable_if(
5013 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::Encode<
5014 ::fidl_next::wire::fuchsia::NullableHandle,
5015 ___E,
5016 >>::COPY_OPTIMIZATION
5017 .is_enabled(),
5018 )
5019 };
5020
5021 #[inline]
5022 fn encode(
5023 self,
5024 encoder_: &mut ___E,
5025 out_: &mut ::core::mem::MaybeUninit<crate::wire::SingleHandle>,
5026 _: (),
5027 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5028 ::fidl_next::munge! {
5029 let crate::wire::SingleHandle {
5030 h,
5031
5032 } = out_;
5033 }
5034
5035 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
5036
5037 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
5038
5039 Ok(())
5040 }
5041 }
5042
5043 unsafe impl<___E>
5044 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::SingleHandle>, ___E>
5045 for SingleHandle
5046 where
5047 ___E: ::fidl_next::Encoder + ?Sized,
5048 SingleHandle: ::fidl_next::Encode<crate::wire::SingleHandle, ___E>,
5049 {
5050 #[inline]
5051 fn encode_option(
5052 this: ::core::option::Option<Self>,
5053 encoder: &mut ___E,
5054 out: &mut ::core::mem::MaybeUninit<
5055 ::fidl_next::wire::Box<'static, crate::wire::SingleHandle>,
5056 >,
5057 _: (),
5058 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5059 if let Some(inner) = this {
5060 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5061 ::fidl_next::wire::Box::encode_present(out);
5062 } else {
5063 ::fidl_next::wire::Box::encode_absent(out);
5064 }
5065
5066 Ok(())
5067 }
5068 }
5069
5070 impl ::fidl_next::FromWire<crate::wire::SingleHandle> for SingleHandle {
5071 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::SingleHandle, Self> = unsafe {
5072 ::fidl_next::CopyOptimization::enable_if(
5073 true && <::fidl_next::fuchsia::zx::NullableHandle as ::fidl_next::FromWire<
5074 ::fidl_next::wire::fuchsia::NullableHandle,
5075 >>::COPY_OPTIMIZATION
5076 .is_enabled(),
5077 )
5078 };
5079
5080 #[inline]
5081 fn from_wire(wire: crate::wire::SingleHandle) -> Self {
5082 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
5083 }
5084 }
5085
5086 #[derive(Debug, PartialEq)]
5087 #[repr(C)]
5088 pub struct SingleOptionalHandle {
5089 pub h: ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>,
5090 }
5091
5092 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SingleOptionalHandle, ___E>
5093 for SingleOptionalHandle
5094 where
5095 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5096 ___E: ::fidl_next::fuchsia::HandleEncoder,
5097 {
5098 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5099 Self,
5100 crate::wire::SingleOptionalHandle,
5101 > = unsafe {
5102 ::fidl_next::CopyOptimization::enable_if(
5103 true
5104
5105 && <
5106 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>
5107 >::COPY_OPTIMIZATION.is_enabled()
5108
5109 )
5110 };
5111
5112 #[inline]
5113 fn encode(
5114 self,
5115 encoder_: &mut ___E,
5116 out_: &mut ::core::mem::MaybeUninit<crate::wire::SingleOptionalHandle>,
5117 _: (),
5118 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5119 ::fidl_next::munge! {
5120 let crate::wire::SingleOptionalHandle {
5121 h,
5122
5123 } = out_;
5124 }
5125
5126 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
5127
5128 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
5129
5130 Ok(())
5131 }
5132 }
5133
5134 unsafe impl<___E>
5135 ::fidl_next::EncodeOption<
5136 ::fidl_next::wire::Box<'static, crate::wire::SingleOptionalHandle>,
5137 ___E,
5138 > for SingleOptionalHandle
5139 where
5140 ___E: ::fidl_next::Encoder + ?Sized,
5141 SingleOptionalHandle: ::fidl_next::Encode<crate::wire::SingleOptionalHandle, ___E>,
5142 {
5143 #[inline]
5144 fn encode_option(
5145 this: ::core::option::Option<Self>,
5146 encoder: &mut ___E,
5147 out: &mut ::core::mem::MaybeUninit<
5148 ::fidl_next::wire::Box<'static, crate::wire::SingleOptionalHandle>,
5149 >,
5150 _: (),
5151 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5152 if let Some(inner) = this {
5153 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5154 ::fidl_next::wire::Box::encode_present(out);
5155 } else {
5156 ::fidl_next::wire::Box::encode_absent(out);
5157 }
5158
5159 Ok(())
5160 }
5161 }
5162
5163 impl ::fidl_next::FromWire<crate::wire::SingleOptionalHandle> for SingleOptionalHandle {
5164 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5165 crate::wire::SingleOptionalHandle,
5166 Self,
5167 > = unsafe {
5168 ::fidl_next::CopyOptimization::enable_if(
5169 true
5170
5171 && <
5172 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalNullableHandle>
5173 >::COPY_OPTIMIZATION.is_enabled()
5174
5175 )
5176 };
5177
5178 #[inline]
5179 fn from_wire(wire: crate::wire::SingleOptionalHandle) -> Self {
5180 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
5181 }
5182 }
5183
5184 #[derive(Debug, PartialEq)]
5185 #[repr(C)]
5186 pub struct StructOfEndpoints {
5187 pub client_end: ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>,
5188
5189 pub optional_client_end: ::core::option::Option<
5190 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>,
5191 >,
5192
5193 pub server_end: ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>,
5194
5195 pub optional_server_end: ::core::option::Option<
5196 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>,
5197 >,
5198 }
5199
5200 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StructOfEndpoints, ___E> for StructOfEndpoints
5201 where
5202 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5203 ___E: ::fidl_next::fuchsia::HandleEncoder,
5204 {
5205 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5206 Self,
5207 crate::wire::StructOfEndpoints,
5208 > = unsafe {
5209 ::fidl_next::CopyOptimization::enable_if(
5210 true
5211
5212 && <
5213 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>, ___E>
5214 >::COPY_OPTIMIZATION.is_enabled()
5215
5216 && <
5217 ::core::option::Option<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::Encode<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::OptionalChannel>, ___E>
5218 >::COPY_OPTIMIZATION.is_enabled()
5219
5220 && <
5221 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>, ___E>
5222 >::COPY_OPTIMIZATION.is_enabled()
5223
5224 && <
5225 ::core::option::Option<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::OptionalChannel>, ___E>
5226 >::COPY_OPTIMIZATION.is_enabled()
5227
5228 )
5229 };
5230
5231 #[inline]
5232 fn encode(
5233 self,
5234 encoder_: &mut ___E,
5235 out_: &mut ::core::mem::MaybeUninit<crate::wire::StructOfEndpoints>,
5236 _: (),
5237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5238 ::fidl_next::munge! {
5239 let crate::wire::StructOfEndpoints {
5240 client_end,
5241 optional_client_end,
5242 server_end,
5243 optional_server_end,
5244
5245 } = out_;
5246 }
5247
5248 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
5249
5250 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
5251
5252 ::fidl_next::Encode::encode(
5253 self.optional_client_end,
5254 encoder_,
5255 optional_client_end,
5256 (),
5257 )?;
5258
5259 let mut _field =
5260 unsafe { ::fidl_next::Slot::new_unchecked(optional_client_end.as_mut_ptr()) };
5261
5262 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
5263
5264 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
5265
5266 ::fidl_next::Encode::encode(
5267 self.optional_server_end,
5268 encoder_,
5269 optional_server_end,
5270 (),
5271 )?;
5272
5273 let mut _field =
5274 unsafe { ::fidl_next::Slot::new_unchecked(optional_server_end.as_mut_ptr()) };
5275
5276 Ok(())
5277 }
5278 }
5279
5280 unsafe impl<___E>
5281 ::fidl_next::EncodeOption<
5282 ::fidl_next::wire::Box<'static, crate::wire::StructOfEndpoints>,
5283 ___E,
5284 > for StructOfEndpoints
5285 where
5286 ___E: ::fidl_next::Encoder + ?Sized,
5287 StructOfEndpoints: ::fidl_next::Encode<crate::wire::StructOfEndpoints, ___E>,
5288 {
5289 #[inline]
5290 fn encode_option(
5291 this: ::core::option::Option<Self>,
5292 encoder: &mut ___E,
5293 out: &mut ::core::mem::MaybeUninit<
5294 ::fidl_next::wire::Box<'static, crate::wire::StructOfEndpoints>,
5295 >,
5296 _: (),
5297 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5298 if let Some(inner) = this {
5299 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5300 ::fidl_next::wire::Box::encode_present(out);
5301 } else {
5302 ::fidl_next::wire::Box::encode_absent(out);
5303 }
5304
5305 Ok(())
5306 }
5307 }
5308
5309 impl ::fidl_next::FromWire<crate::wire::StructOfEndpoints> for StructOfEndpoints {
5310 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5311 crate::wire::StructOfEndpoints,
5312 Self,
5313 > = unsafe {
5314 ::fidl_next::CopyOptimization::enable_if(
5315 true
5316
5317 && <
5318 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>
5319 >::COPY_OPTIMIZATION.is_enabled()
5320
5321 && <
5322 ::core::option::Option<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::FromWire<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::OptionalChannel>>
5323 >::COPY_OPTIMIZATION.is_enabled()
5324
5325 && <
5326 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>
5327 >::COPY_OPTIMIZATION.is_enabled()
5328
5329 && <
5330 ::core::option::Option<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::OptionalChannel>>
5331 >::COPY_OPTIMIZATION.is_enabled()
5332
5333 )
5334 };
5335
5336 #[inline]
5337 fn from_wire(wire: crate::wire::StructOfEndpoints) -> Self {
5338 Self {
5339 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
5340
5341 optional_client_end: ::fidl_next::FromWire::from_wire(wire.optional_client_end),
5342
5343 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
5344
5345 optional_server_end: ::fidl_next::FromWire::from_wire(wire.optional_server_end),
5346 }
5347 }
5348 }
5349
5350 #[derive(Debug, PartialEq)]
5351 #[repr(C)]
5352 pub struct StructOfOptionalUnionOfHandle {
5353 pub u: ::core::option::Option<::std::boxed::Box<crate::natural::UnionOfHandle>>,
5354 }
5355
5356 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StructOfOptionalUnionOfHandle, ___E>
5357 for StructOfOptionalUnionOfHandle
5358 where
5359 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5360 ___E: ::fidl_next::fuchsia::HandleEncoder,
5361 {
5362 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5363 Self,
5364 crate::wire::StructOfOptionalUnionOfHandle,
5365 > = unsafe {
5366 ::fidl_next::CopyOptimization::enable_if(
5367 true
5368
5369 && <
5370 ::core::option::Option<::std::boxed::Box<crate::natural::UnionOfHandle>> as ::fidl_next::Encode<crate::wire_optional::UnionOfHandle, ___E>
5371 >::COPY_OPTIMIZATION.is_enabled()
5372
5373 )
5374 };
5375
5376 #[inline]
5377 fn encode(
5378 self,
5379 encoder_: &mut ___E,
5380 out_: &mut ::core::mem::MaybeUninit<crate::wire::StructOfOptionalUnionOfHandle>,
5381 _: (),
5382 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5383 ::fidl_next::munge! {
5384 let crate::wire::StructOfOptionalUnionOfHandle {
5385 u,
5386
5387 } = out_;
5388 }
5389
5390 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
5391
5392 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(u.as_mut_ptr()) };
5393
5394 Ok(())
5395 }
5396 }
5397
5398 unsafe impl<___E>
5399 ::fidl_next::EncodeOption<
5400 ::fidl_next::wire::Box<'static, crate::wire::StructOfOptionalUnionOfHandle>,
5401 ___E,
5402 > for StructOfOptionalUnionOfHandle
5403 where
5404 ___E: ::fidl_next::Encoder + ?Sized,
5405 StructOfOptionalUnionOfHandle:
5406 ::fidl_next::Encode<crate::wire::StructOfOptionalUnionOfHandle, ___E>,
5407 {
5408 #[inline]
5409 fn encode_option(
5410 this: ::core::option::Option<Self>,
5411 encoder: &mut ___E,
5412 out: &mut ::core::mem::MaybeUninit<
5413 ::fidl_next::wire::Box<'static, crate::wire::StructOfOptionalUnionOfHandle>,
5414 >,
5415 _: (),
5416 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5417 if let Some(inner) = this {
5418 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5419 ::fidl_next::wire::Box::encode_present(out);
5420 } else {
5421 ::fidl_next::wire::Box::encode_absent(out);
5422 }
5423
5424 Ok(())
5425 }
5426 }
5427
5428 impl ::fidl_next::FromWire<crate::wire::StructOfOptionalUnionOfHandle>
5429 for StructOfOptionalUnionOfHandle
5430 {
5431 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5432 crate::wire::StructOfOptionalUnionOfHandle,
5433 Self,
5434 > = unsafe {
5435 ::fidl_next::CopyOptimization::enable_if(
5436 true
5437
5438 && <
5439 ::core::option::Option<::std::boxed::Box<crate::natural::UnionOfHandle>> as ::fidl_next::FromWire<crate::wire_optional::UnionOfHandle>
5440 >::COPY_OPTIMIZATION.is_enabled()
5441
5442 )
5443 };
5444
5445 #[inline]
5446 fn from_wire(wire: crate::wire::StructOfOptionalUnionOfHandle) -> Self {
5447 Self { u: ::fidl_next::FromWire::from_wire(wire.u) }
5448 }
5449 }
5450
5451 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5452 pub struct StructOfSimpleResourceTable {
5453 pub table: crate::natural::SimpleResourceTable,
5454 }
5455
5456 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StructOfSimpleResourceTable<'static>, ___E>
5457 for StructOfSimpleResourceTable
5458 where
5459 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5460 ___E: ::fidl_next::Encoder,
5461 ___E: ::fidl_next::fuchsia::HandleEncoder,
5462 {
5463 #[inline]
5464 fn encode(
5465 self,
5466 encoder_: &mut ___E,
5467 out_: &mut ::core::mem::MaybeUninit<crate::wire::StructOfSimpleResourceTable<'static>>,
5468 _: (),
5469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5470 ::fidl_next::munge! {
5471 let crate::wire::StructOfSimpleResourceTable {
5472 table,
5473
5474 } = out_;
5475 }
5476
5477 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
5478
5479 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(table.as_mut_ptr()) };
5480
5481 Ok(())
5482 }
5483 }
5484
5485 unsafe impl<___E>
5486 ::fidl_next::EncodeOption<
5487 ::fidl_next::wire::Box<'static, crate::wire::StructOfSimpleResourceTable<'static>>,
5488 ___E,
5489 > for StructOfSimpleResourceTable
5490 where
5491 ___E: ::fidl_next::Encoder + ?Sized,
5492 StructOfSimpleResourceTable:
5493 ::fidl_next::Encode<crate::wire::StructOfSimpleResourceTable<'static>, ___E>,
5494 {
5495 #[inline]
5496 fn encode_option(
5497 this: ::core::option::Option<Self>,
5498 encoder: &mut ___E,
5499 out: &mut ::core::mem::MaybeUninit<
5500 ::fidl_next::wire::Box<'static, crate::wire::StructOfSimpleResourceTable<'static>>,
5501 >,
5502 _: (),
5503 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5504 if let Some(inner) = this {
5505 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5506 ::fidl_next::wire::Box::encode_present(out);
5507 } else {
5508 ::fidl_next::wire::Box::encode_absent(out);
5509 }
5510
5511 Ok(())
5512 }
5513 }
5514
5515 impl<'de> ::fidl_next::FromWire<crate::wire::StructOfSimpleResourceTable<'de>>
5516 for StructOfSimpleResourceTable
5517 {
5518 #[inline]
5519 fn from_wire(wire: crate::wire::StructOfSimpleResourceTable<'de>) -> Self {
5520 Self { table: ::fidl_next::FromWire::from_wire(wire.table) }
5521 }
5522 }
5523
5524 #[derive(Debug, Default, PartialEq)]
5525 pub struct TableFieldInlinedHandle {
5526 pub f: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
5527 }
5528
5529 impl TableFieldInlinedHandle {
5530 fn __max_ordinal(&self) -> usize {
5531 if self.f.is_some() {
5532 return 1;
5533 }
5534
5535 0
5536 }
5537 }
5538
5539 unsafe impl<___E> ::fidl_next::Encode<crate::wire::TableFieldInlinedHandle<'static>, ___E>
5540 for TableFieldInlinedHandle
5541 where
5542 ___E: ::fidl_next::Encoder + ?Sized,
5543 ___E: ::fidl_next::fuchsia::HandleEncoder,
5544 {
5545 #[inline]
5546 fn encode(
5547 mut self,
5548 encoder: &mut ___E,
5549 out: &mut ::core::mem::MaybeUninit<crate::wire::TableFieldInlinedHandle<'static>>,
5550 _: (),
5551 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5552 ::fidl_next::munge!(let crate::wire::TableFieldInlinedHandle { table } = out);
5553
5554 let max_ord = self.__max_ordinal();
5555
5556 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5557 ::fidl_next::Wire::zero_padding(&mut out);
5558
5559 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5560 ::fidl_next::wire::Envelope,
5561 >(encoder, max_ord);
5562
5563 for i in 1..=max_ord {
5564 match i {
5565 1 => {
5566 if let Some(value) = self.f.take() {
5567 ::fidl_next::wire::Envelope::encode_value::<
5568 ::fidl_next::wire::fuchsia::Channel,
5569 ___E,
5570 >(
5571 value, preallocated.encoder, &mut out, ()
5572 )?;
5573 } else {
5574 ::fidl_next::wire::Envelope::encode_zero(&mut out)
5575 }
5576 }
5577
5578 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5579 }
5580 unsafe {
5581 preallocated.write_next(out.assume_init_ref());
5582 }
5583 }
5584
5585 ::fidl_next::wire::Table::encode_len(table, max_ord);
5586
5587 Ok(())
5588 }
5589 }
5590
5591 impl<'de> ::fidl_next::FromWire<crate::wire::TableFieldInlinedHandle<'de>>
5592 for TableFieldInlinedHandle
5593 {
5594 #[inline]
5595 fn from_wire(wire_: crate::wire::TableFieldInlinedHandle<'de>) -> Self {
5596 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5597
5598 let f = wire_.table.get(1);
5599
5600 Self {
5601 f: f.map(|envelope| {
5602 ::fidl_next::FromWire::from_wire(unsafe {
5603 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
5604 })
5605 }),
5606 }
5607 }
5608 }
5609
5610 #[derive(Debug, PartialEq)]
5611 pub struct TableFieldInlinedHandleStruct {
5612 pub t: crate::natural::TableFieldInlinedHandle,
5613 }
5614
5615 unsafe impl<___E> ::fidl_next::Encode<crate::wire::TableFieldInlinedHandleStruct<'static>, ___E>
5616 for TableFieldInlinedHandleStruct
5617 where
5618 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5619 ___E: ::fidl_next::Encoder,
5620 ___E: ::fidl_next::fuchsia::HandleEncoder,
5621 {
5622 #[inline]
5623 fn encode(
5624 self,
5625 encoder_: &mut ___E,
5626 out_: &mut ::core::mem::MaybeUninit<
5627 crate::wire::TableFieldInlinedHandleStruct<'static>,
5628 >,
5629 _: (),
5630 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5631 ::fidl_next::munge! {
5632 let crate::wire::TableFieldInlinedHandleStruct {
5633 t,
5634
5635 } = out_;
5636 }
5637
5638 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
5639
5640 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
5641
5642 Ok(())
5643 }
5644 }
5645
5646 unsafe impl<___E>
5647 ::fidl_next::EncodeOption<
5648 ::fidl_next::wire::Box<'static, crate::wire::TableFieldInlinedHandleStruct<'static>>,
5649 ___E,
5650 > for TableFieldInlinedHandleStruct
5651 where
5652 ___E: ::fidl_next::Encoder + ?Sized,
5653 TableFieldInlinedHandleStruct:
5654 ::fidl_next::Encode<crate::wire::TableFieldInlinedHandleStruct<'static>, ___E>,
5655 {
5656 #[inline]
5657 fn encode_option(
5658 this: ::core::option::Option<Self>,
5659 encoder: &mut ___E,
5660 out: &mut ::core::mem::MaybeUninit<
5661 ::fidl_next::wire::Box<
5662 'static,
5663 crate::wire::TableFieldInlinedHandleStruct<'static>,
5664 >,
5665 >,
5666 _: (),
5667 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5668 if let Some(inner) = this {
5669 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5670 ::fidl_next::wire::Box::encode_present(out);
5671 } else {
5672 ::fidl_next::wire::Box::encode_absent(out);
5673 }
5674
5675 Ok(())
5676 }
5677 }
5678
5679 impl<'de> ::fidl_next::FromWire<crate::wire::TableFieldInlinedHandleStruct<'de>>
5680 for TableFieldInlinedHandleStruct
5681 {
5682 #[inline]
5683 fn from_wire(wire: crate::wire::TableFieldInlinedHandleStruct<'de>) -> Self {
5684 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
5685 }
5686 }
5687
5688 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5689 pub struct TableFieldUnknownResource {}
5690
5691 impl TableFieldUnknownResource {
5692 fn __max_ordinal(&self) -> usize {
5693 0
5694 }
5695 }
5696
5697 unsafe impl<___E> ::fidl_next::Encode<crate::wire::TableFieldUnknownResource<'static>, ___E>
5698 for TableFieldUnknownResource
5699 where
5700 ___E: ::fidl_next::Encoder + ?Sized,
5701 ___E: ::fidl_next::fuchsia::HandleEncoder,
5702 {
5703 #[inline]
5704 fn encode(
5705 mut self,
5706 encoder: &mut ___E,
5707 out: &mut ::core::mem::MaybeUninit<crate::wire::TableFieldUnknownResource<'static>>,
5708 _: (),
5709 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5710 ::fidl_next::munge!(let crate::wire::TableFieldUnknownResource { table } = out);
5711
5712 let max_ord = self.__max_ordinal();
5713
5714 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5715 ::fidl_next::Wire::zero_padding(&mut out);
5716
5717 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5718 ::fidl_next::wire::Envelope,
5719 >(encoder, max_ord);
5720
5721 for i in 1..=max_ord {
5722 match i {
5723 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5724 }
5725 unsafe {
5726 preallocated.write_next(out.assume_init_ref());
5727 }
5728 }
5729
5730 ::fidl_next::wire::Table::encode_len(table, max_ord);
5731
5732 Ok(())
5733 }
5734 }
5735
5736 impl<'de> ::fidl_next::FromWire<crate::wire::TableFieldUnknownResource<'de>>
5737 for TableFieldUnknownResource
5738 {
5739 #[inline]
5740 fn from_wire(wire_: crate::wire::TableFieldUnknownResource<'de>) -> Self {
5741 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5742
5743 Self {}
5744 }
5745 }
5746
5747 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5748 pub struct TableFieldUnknownResourceStruct {
5749 pub t: crate::natural::TableFieldUnknownResource,
5750 }
5751
5752 unsafe impl<___E>
5753 ::fidl_next::Encode<crate::wire::TableFieldUnknownResourceStruct<'static>, ___E>
5754 for TableFieldUnknownResourceStruct
5755 where
5756 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5757 ___E: ::fidl_next::Encoder,
5758 ___E: ::fidl_next::fuchsia::HandleEncoder,
5759 {
5760 #[inline]
5761 fn encode(
5762 self,
5763 encoder_: &mut ___E,
5764 out_: &mut ::core::mem::MaybeUninit<
5765 crate::wire::TableFieldUnknownResourceStruct<'static>,
5766 >,
5767 _: (),
5768 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5769 ::fidl_next::munge! {
5770 let crate::wire::TableFieldUnknownResourceStruct {
5771 t,
5772
5773 } = out_;
5774 }
5775
5776 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
5777
5778 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
5779
5780 Ok(())
5781 }
5782 }
5783
5784 unsafe impl<___E>
5785 ::fidl_next::EncodeOption<
5786 ::fidl_next::wire::Box<'static, crate::wire::TableFieldUnknownResourceStruct<'static>>,
5787 ___E,
5788 > for TableFieldUnknownResourceStruct
5789 where
5790 ___E: ::fidl_next::Encoder + ?Sized,
5791 TableFieldUnknownResourceStruct:
5792 ::fidl_next::Encode<crate::wire::TableFieldUnknownResourceStruct<'static>, ___E>,
5793 {
5794 #[inline]
5795 fn encode_option(
5796 this: ::core::option::Option<Self>,
5797 encoder: &mut ___E,
5798 out: &mut ::core::mem::MaybeUninit<
5799 ::fidl_next::wire::Box<
5800 'static,
5801 crate::wire::TableFieldUnknownResourceStruct<'static>,
5802 >,
5803 >,
5804 _: (),
5805 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5806 if let Some(inner) = this {
5807 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5808 ::fidl_next::wire::Box::encode_present(out);
5809 } else {
5810 ::fidl_next::wire::Box::encode_absent(out);
5811 }
5812
5813 Ok(())
5814 }
5815 }
5816
5817 impl<'de> ::fidl_next::FromWire<crate::wire::TableFieldUnknownResourceStruct<'de>>
5818 for TableFieldUnknownResourceStruct
5819 {
5820 #[inline]
5821 fn from_wire(wire: crate::wire::TableFieldUnknownResourceStruct<'de>) -> Self {
5822 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
5823 }
5824 }
5825
5826 #[derive(Debug, Default, PartialEq)]
5827 pub struct TableOfEndpointsTable {
5828 pub client_end: ::core::option::Option<
5829 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>,
5830 >,
5831
5832 pub server_end: ::core::option::Option<
5833 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>,
5834 >,
5835 }
5836
5837 impl TableOfEndpointsTable {
5838 fn __max_ordinal(&self) -> usize {
5839 if self.server_end.is_some() {
5840 return 2;
5841 }
5842
5843 if self.client_end.is_some() {
5844 return 1;
5845 }
5846
5847 0
5848 }
5849 }
5850
5851 unsafe impl<___E> ::fidl_next::Encode<crate::wire::TableOfEndpointsTable<'static>, ___E>
5852 for TableOfEndpointsTable
5853 where
5854 ___E: ::fidl_next::Encoder + ?Sized,
5855 ___E: ::fidl_next::fuchsia::HandleEncoder,
5856 {
5857 #[inline]
5858 fn encode(
5859 mut self,
5860 encoder: &mut ___E,
5861 out: &mut ::core::mem::MaybeUninit<crate::wire::TableOfEndpointsTable<'static>>,
5862 _: (),
5863 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5864 ::fidl_next::munge!(let crate::wire::TableOfEndpointsTable { table } = out);
5865
5866 let max_ord = self.__max_ordinal();
5867
5868 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5869 ::fidl_next::Wire::zero_padding(&mut out);
5870
5871 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5872 ::fidl_next::wire::Envelope,
5873 >(encoder, max_ord);
5874
5875 for i in 1..=max_ord {
5876 match i {
5877 2 => {
5878 if let Some(value) = self.server_end.take() {
5879 ::fidl_next::wire::Envelope::encode_value::<
5880 ::fidl_next::ServerEnd<
5881 crate::Protocol,
5882 ::fidl_next::wire::fuchsia::Channel,
5883 >,
5884 ___E,
5885 >(
5886 value, preallocated.encoder, &mut out, ()
5887 )?;
5888 } else {
5889 ::fidl_next::wire::Envelope::encode_zero(&mut out)
5890 }
5891 }
5892
5893 1 => {
5894 if let Some(value) = self.client_end.take() {
5895 ::fidl_next::wire::Envelope::encode_value::<
5896 ::fidl_next::ClientEnd<
5897 crate::Protocol,
5898 ::fidl_next::wire::fuchsia::Channel,
5899 >,
5900 ___E,
5901 >(
5902 value, preallocated.encoder, &mut out, ()
5903 )?;
5904 } else {
5905 ::fidl_next::wire::Envelope::encode_zero(&mut out)
5906 }
5907 }
5908
5909 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5910 }
5911 unsafe {
5912 preallocated.write_next(out.assume_init_ref());
5913 }
5914 }
5915
5916 ::fidl_next::wire::Table::encode_len(table, max_ord);
5917
5918 Ok(())
5919 }
5920 }
5921
5922 impl<'de> ::fidl_next::FromWire<crate::wire::TableOfEndpointsTable<'de>> for TableOfEndpointsTable {
5923 #[inline]
5924 fn from_wire(wire_: crate::wire::TableOfEndpointsTable<'de>) -> Self {
5925 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5926
5927 let client_end = wire_.table.get(1);
5928
5929 let server_end = wire_.table.get(2);
5930
5931 Self {
5932 client_end: client_end.map(|envelope| {
5933 ::fidl_next::FromWire::from_wire(unsafe {
5934 envelope.read_unchecked::<::fidl_next::ClientEnd<
5935 crate::Protocol,
5936 ::fidl_next::wire::fuchsia::Channel,
5937 >>()
5938 })
5939 }),
5940
5941 server_end: server_end.map(|envelope| {
5942 ::fidl_next::FromWire::from_wire(unsafe {
5943 envelope.read_unchecked::<::fidl_next::ServerEnd<
5944 crate::Protocol,
5945 ::fidl_next::wire::fuchsia::Channel,
5946 >>()
5947 })
5948 }),
5949 }
5950 }
5951 }
5952
5953 #[derive(Debug, PartialEq)]
5954 pub struct TableOfEndpoints {
5955 pub t: crate::natural::TableOfEndpointsTable,
5956 }
5957
5958 unsafe impl<___E> ::fidl_next::Encode<crate::wire::TableOfEndpoints<'static>, ___E>
5959 for TableOfEndpoints
5960 where
5961 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5962 ___E: ::fidl_next::Encoder,
5963 ___E: ::fidl_next::fuchsia::HandleEncoder,
5964 {
5965 #[inline]
5966 fn encode(
5967 self,
5968 encoder_: &mut ___E,
5969 out_: &mut ::core::mem::MaybeUninit<crate::wire::TableOfEndpoints<'static>>,
5970 _: (),
5971 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5972 ::fidl_next::munge! {
5973 let crate::wire::TableOfEndpoints {
5974 t,
5975
5976 } = out_;
5977 }
5978
5979 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
5980
5981 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
5982
5983 Ok(())
5984 }
5985 }
5986
5987 unsafe impl<___E>
5988 ::fidl_next::EncodeOption<
5989 ::fidl_next::wire::Box<'static, crate::wire::TableOfEndpoints<'static>>,
5990 ___E,
5991 > for TableOfEndpoints
5992 where
5993 ___E: ::fidl_next::Encoder + ?Sized,
5994 TableOfEndpoints: ::fidl_next::Encode<crate::wire::TableOfEndpoints<'static>, ___E>,
5995 {
5996 #[inline]
5997 fn encode_option(
5998 this: ::core::option::Option<Self>,
5999 encoder: &mut ___E,
6000 out: &mut ::core::mem::MaybeUninit<
6001 ::fidl_next::wire::Box<'static, crate::wire::TableOfEndpoints<'static>>,
6002 >,
6003 _: (),
6004 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6005 if let Some(inner) = this {
6006 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6007 ::fidl_next::wire::Box::encode_present(out);
6008 } else {
6009 ::fidl_next::wire::Box::encode_absent(out);
6010 }
6011
6012 Ok(())
6013 }
6014 }
6015
6016 impl<'de> ::fidl_next::FromWire<crate::wire::TableOfEndpoints<'de>> for TableOfEndpoints {
6017 #[inline]
6018 fn from_wire(wire: crate::wire::TableOfEndpoints<'de>) -> Self {
6019 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
6020 }
6021 }
6022
6023 #[derive(Debug, Default, PartialEq)]
6024 pub struct TableUnionWithVectorReservedSandwich {
6025 pub uv: ::core::option::Option<crate::natural::UnionWithVector>,
6026 }
6027
6028 impl TableUnionWithVectorReservedSandwich {
6029 fn __max_ordinal(&self) -> usize {
6030 if self.uv.is_some() {
6031 return 2;
6032 }
6033
6034 0
6035 }
6036 }
6037
6038 unsafe impl<___E>
6039 ::fidl_next::Encode<crate::wire::TableUnionWithVectorReservedSandwich<'static>, ___E>
6040 for TableUnionWithVectorReservedSandwich
6041 where
6042 ___E: ::fidl_next::Encoder + ?Sized,
6043 ___E: ::fidl_next::fuchsia::HandleEncoder,
6044 {
6045 #[inline]
6046 fn encode(
6047 mut self,
6048 encoder: &mut ___E,
6049 out: &mut ::core::mem::MaybeUninit<
6050 crate::wire::TableUnionWithVectorReservedSandwich<'static>,
6051 >,
6052 _: (),
6053 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6054 ::fidl_next::munge!(let crate::wire::TableUnionWithVectorReservedSandwich { table } = out);
6055
6056 let max_ord = self.__max_ordinal();
6057
6058 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6059 ::fidl_next::Wire::zero_padding(&mut out);
6060
6061 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6062 ::fidl_next::wire::Envelope,
6063 >(encoder, max_ord);
6064
6065 for i in 1..=max_ord {
6066 match i {
6067 2 => {
6068 if let Some(value) = self.uv.take() {
6069 ::fidl_next::wire::Envelope::encode_value::<
6070 crate::wire::UnionWithVector<'static>,
6071 ___E,
6072 >(
6073 value, preallocated.encoder, &mut out, ()
6074 )?;
6075 } else {
6076 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6077 }
6078 }
6079
6080 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6081 }
6082 unsafe {
6083 preallocated.write_next(out.assume_init_ref());
6084 }
6085 }
6086
6087 ::fidl_next::wire::Table::encode_len(table, max_ord);
6088
6089 Ok(())
6090 }
6091 }
6092
6093 impl<'de> ::fidl_next::FromWire<crate::wire::TableUnionWithVectorReservedSandwich<'de>>
6094 for TableUnionWithVectorReservedSandwich
6095 {
6096 #[inline]
6097 fn from_wire(wire_: crate::wire::TableUnionWithVectorReservedSandwich<'de>) -> Self {
6098 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6099
6100 let uv = wire_.table.get(2);
6101
6102 Self {
6103 uv: uv.map(|envelope| {
6104 ::fidl_next::FromWire::from_wire(unsafe {
6105 envelope.read_unchecked::<crate::wire::UnionWithVector<'de>>()
6106 })
6107 }),
6108 }
6109 }
6110 }
6111
6112 #[derive(Debug, PartialEq)]
6113 pub struct TableUnionWithVectorReservedSandwichStruct {
6114 pub table: crate::natural::TableUnionWithVectorReservedSandwich,
6115 }
6116
6117 unsafe impl<___E>
6118 ::fidl_next::Encode<crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>, ___E>
6119 for TableUnionWithVectorReservedSandwichStruct
6120 where
6121 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6122 ___E: ::fidl_next::Encoder,
6123 ___E: ::fidl_next::fuchsia::HandleEncoder,
6124 {
6125 #[inline]
6126 fn encode(
6127 self,
6128 encoder_: &mut ___E,
6129 out_: &mut ::core::mem::MaybeUninit<
6130 crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>,
6131 >,
6132 _: (),
6133 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6134 ::fidl_next::munge! {
6135 let crate::wire::TableUnionWithVectorReservedSandwichStruct {
6136 table,
6137
6138 } = out_;
6139 }
6140
6141 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
6142
6143 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(table.as_mut_ptr()) };
6144
6145 Ok(())
6146 }
6147 }
6148
6149 unsafe impl<___E>
6150 ::fidl_next::EncodeOption<
6151 ::fidl_next::wire::Box<
6152 'static,
6153 crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>,
6154 >,
6155 ___E,
6156 > for TableUnionWithVectorReservedSandwichStruct
6157 where
6158 ___E: ::fidl_next::Encoder + ?Sized,
6159 TableUnionWithVectorReservedSandwichStruct: ::fidl_next::Encode<
6160 crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>,
6161 ___E,
6162 >,
6163 {
6164 #[inline]
6165 fn encode_option(
6166 this: ::core::option::Option<Self>,
6167 encoder: &mut ___E,
6168 out: &mut ::core::mem::MaybeUninit<
6169 ::fidl_next::wire::Box<
6170 'static,
6171 crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>,
6172 >,
6173 >,
6174 _: (),
6175 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6176 if let Some(inner) = this {
6177 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6178 ::fidl_next::wire::Box::encode_present(out);
6179 } else {
6180 ::fidl_next::wire::Box::encode_absent(out);
6181 }
6182
6183 Ok(())
6184 }
6185 }
6186
6187 impl<'de> ::fidl_next::FromWire<crate::wire::TableUnionWithVectorReservedSandwichStruct<'de>>
6188 for TableUnionWithVectorReservedSandwichStruct
6189 {
6190 #[inline]
6191 fn from_wire(wire: crate::wire::TableUnionWithVectorReservedSandwichStruct<'de>) -> Self {
6192 Self { table: ::fidl_next::FromWire::from_wire(wire.table) }
6193 }
6194 }
6195
6196 #[derive(Debug, Default, PartialEq)]
6197 pub struct TableUnionWithVectorStructSandwich {
6198 pub s1: ::core::option::Option<crate::natural::StructSize3Align1>,
6199
6200 pub uv: ::core::option::Option<crate::natural::UnionWithVector>,
6201
6202 pub s2: ::core::option::Option<crate::natural::StructSize3Align1>,
6203 }
6204
6205 impl TableUnionWithVectorStructSandwich {
6206 fn __max_ordinal(&self) -> usize {
6207 if self.s2.is_some() {
6208 return 3;
6209 }
6210
6211 if self.uv.is_some() {
6212 return 2;
6213 }
6214
6215 if self.s1.is_some() {
6216 return 1;
6217 }
6218
6219 0
6220 }
6221 }
6222
6223 unsafe impl<___E>
6224 ::fidl_next::Encode<crate::wire::TableUnionWithVectorStructSandwich<'static>, ___E>
6225 for TableUnionWithVectorStructSandwich
6226 where
6227 ___E: ::fidl_next::Encoder + ?Sized,
6228 ___E: ::fidl_next::fuchsia::HandleEncoder,
6229 {
6230 #[inline]
6231 fn encode(
6232 mut self,
6233 encoder: &mut ___E,
6234 out: &mut ::core::mem::MaybeUninit<
6235 crate::wire::TableUnionWithVectorStructSandwich<'static>,
6236 >,
6237 _: (),
6238 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6239 ::fidl_next::munge!(let crate::wire::TableUnionWithVectorStructSandwich { table } = out);
6240
6241 let max_ord = self.__max_ordinal();
6242
6243 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6244 ::fidl_next::Wire::zero_padding(&mut out);
6245
6246 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6247 ::fidl_next::wire::Envelope,
6248 >(encoder, max_ord);
6249
6250 for i in 1..=max_ord {
6251 match i {
6252 3 => {
6253 if let Some(value) = self.s2.take() {
6254 ::fidl_next::wire::Envelope::encode_value::<
6255 crate::wire::StructSize3Align1,
6256 ___E,
6257 >(
6258 value, preallocated.encoder, &mut out, ()
6259 )?;
6260 } else {
6261 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6262 }
6263 }
6264
6265 2 => {
6266 if let Some(value) = self.uv.take() {
6267 ::fidl_next::wire::Envelope::encode_value::<
6268 crate::wire::UnionWithVector<'static>,
6269 ___E,
6270 >(
6271 value, preallocated.encoder, &mut out, ()
6272 )?;
6273 } else {
6274 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6275 }
6276 }
6277
6278 1 => {
6279 if let Some(value) = self.s1.take() {
6280 ::fidl_next::wire::Envelope::encode_value::<
6281 crate::wire::StructSize3Align1,
6282 ___E,
6283 >(
6284 value, preallocated.encoder, &mut out, ()
6285 )?;
6286 } else {
6287 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6288 }
6289 }
6290
6291 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6292 }
6293 unsafe {
6294 preallocated.write_next(out.assume_init_ref());
6295 }
6296 }
6297
6298 ::fidl_next::wire::Table::encode_len(table, max_ord);
6299
6300 Ok(())
6301 }
6302 }
6303
6304 impl<'de> ::fidl_next::FromWire<crate::wire::TableUnionWithVectorStructSandwich<'de>>
6305 for TableUnionWithVectorStructSandwich
6306 {
6307 #[inline]
6308 fn from_wire(wire_: crate::wire::TableUnionWithVectorStructSandwich<'de>) -> Self {
6309 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6310
6311 let s1 = wire_.table.get(1);
6312
6313 let uv = wire_.table.get(2);
6314
6315 let s2 = wire_.table.get(3);
6316
6317 Self {
6318 s1: s1.map(|envelope| {
6319 ::fidl_next::FromWire::from_wire(unsafe {
6320 envelope.read_unchecked::<crate::wire::StructSize3Align1>()
6321 })
6322 }),
6323
6324 uv: uv.map(|envelope| {
6325 ::fidl_next::FromWire::from_wire(unsafe {
6326 envelope.read_unchecked::<crate::wire::UnionWithVector<'de>>()
6327 })
6328 }),
6329
6330 s2: s2.map(|envelope| {
6331 ::fidl_next::FromWire::from_wire(unsafe {
6332 envelope.read_unchecked::<crate::wire::StructSize3Align1>()
6333 })
6334 }),
6335 }
6336 }
6337 }
6338
6339 #[derive(Debug, PartialEq)]
6340 pub struct TableUnionWithVectorStructSandwichStruct {
6341 pub table: crate::natural::TableUnionWithVectorStructSandwich,
6342 }
6343
6344 unsafe impl<___E>
6345 ::fidl_next::Encode<crate::wire::TableUnionWithVectorStructSandwichStruct<'static>, ___E>
6346 for TableUnionWithVectorStructSandwichStruct
6347 where
6348 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6349 ___E: ::fidl_next::Encoder,
6350 ___E: ::fidl_next::fuchsia::HandleEncoder,
6351 {
6352 #[inline]
6353 fn encode(
6354 self,
6355 encoder_: &mut ___E,
6356 out_: &mut ::core::mem::MaybeUninit<
6357 crate::wire::TableUnionWithVectorStructSandwichStruct<'static>,
6358 >,
6359 _: (),
6360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6361 ::fidl_next::munge! {
6362 let crate::wire::TableUnionWithVectorStructSandwichStruct {
6363 table,
6364
6365 } = out_;
6366 }
6367
6368 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
6369
6370 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(table.as_mut_ptr()) };
6371
6372 Ok(())
6373 }
6374 }
6375
6376 unsafe impl<___E>
6377 ::fidl_next::EncodeOption<
6378 ::fidl_next::wire::Box<
6379 'static,
6380 crate::wire::TableUnionWithVectorStructSandwichStruct<'static>,
6381 >,
6382 ___E,
6383 > for TableUnionWithVectorStructSandwichStruct
6384 where
6385 ___E: ::fidl_next::Encoder + ?Sized,
6386 TableUnionWithVectorStructSandwichStruct: ::fidl_next::Encode<
6387 crate::wire::TableUnionWithVectorStructSandwichStruct<'static>,
6388 ___E,
6389 >,
6390 {
6391 #[inline]
6392 fn encode_option(
6393 this: ::core::option::Option<Self>,
6394 encoder: &mut ___E,
6395 out: &mut ::core::mem::MaybeUninit<
6396 ::fidl_next::wire::Box<
6397 'static,
6398 crate::wire::TableUnionWithVectorStructSandwichStruct<'static>,
6399 >,
6400 >,
6401 _: (),
6402 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6403 if let Some(inner) = this {
6404 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6405 ::fidl_next::wire::Box::encode_present(out);
6406 } else {
6407 ::fidl_next::wire::Box::encode_absent(out);
6408 }
6409
6410 Ok(())
6411 }
6412 }
6413
6414 impl<'de> ::fidl_next::FromWire<crate::wire::TableUnionWithVectorStructSandwichStruct<'de>>
6415 for TableUnionWithVectorStructSandwichStruct
6416 {
6417 #[inline]
6418 fn from_wire(wire: crate::wire::TableUnionWithVectorStructSandwichStruct<'de>) -> Self {
6419 Self { table: ::fidl_next::FromWire::from_wire(wire.table) }
6420 }
6421 }
6422
6423 #[derive(Debug, Default, PartialEq)]
6424 pub struct TableWithUnknownEnvelopesAfterKnownEnvelopes {
6425 pub a: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
6426 }
6427
6428 impl TableWithUnknownEnvelopesAfterKnownEnvelopes {
6429 fn __max_ordinal(&self) -> usize {
6430 if self.a.is_some() {
6431 return 1;
6432 }
6433
6434 0
6435 }
6436 }
6437
6438 unsafe impl<___E>
6439 ::fidl_next::Encode<
6440 crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes<'static>,
6441 ___E,
6442 > for TableWithUnknownEnvelopesAfterKnownEnvelopes
6443 where
6444 ___E: ::fidl_next::Encoder + ?Sized,
6445 ___E: ::fidl_next::fuchsia::HandleEncoder,
6446 {
6447 #[inline]
6448 fn encode(
6449 mut self,
6450 encoder: &mut ___E,
6451 out: &mut ::core::mem::MaybeUninit<
6452 crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes<'static>,
6453 >,
6454 _: (),
6455 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6456 ::fidl_next::munge!(let crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes { table } = out);
6457
6458 let max_ord = self.__max_ordinal();
6459
6460 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6461 ::fidl_next::Wire::zero_padding(&mut out);
6462
6463 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6464 ::fidl_next::wire::Envelope,
6465 >(encoder, max_ord);
6466
6467 for i in 1..=max_ord {
6468 match i {
6469 1 => {
6470 if let Some(value) = self.a.take() {
6471 ::fidl_next::wire::Envelope::encode_value::<
6472 ::fidl_next::wire::fuchsia::Event,
6473 ___E,
6474 >(
6475 value, preallocated.encoder, &mut out, ()
6476 )?;
6477 } else {
6478 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6479 }
6480 }
6481
6482 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6483 }
6484 unsafe {
6485 preallocated.write_next(out.assume_init_ref());
6486 }
6487 }
6488
6489 ::fidl_next::wire::Table::encode_len(table, max_ord);
6490
6491 Ok(())
6492 }
6493 }
6494
6495 impl<'de> ::fidl_next::FromWire<crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes<'de>>
6496 for TableWithUnknownEnvelopesAfterKnownEnvelopes
6497 {
6498 #[inline]
6499 fn from_wire(
6500 wire_: crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes<'de>,
6501 ) -> Self {
6502 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6503
6504 let a = wire_.table.get(1);
6505
6506 Self {
6507 a: a.map(|envelope| {
6508 ::fidl_next::FromWire::from_wire(unsafe {
6509 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
6510 })
6511 }),
6512 }
6513 }
6514 }
6515
6516 #[derive(Debug, PartialEq)]
6517 pub struct TableWithUnknownEnveloepsAfterKnownEnvelopesStruct {
6518 pub t: crate::natural::TableWithUnknownEnvelopesAfterKnownEnvelopes,
6519 }
6520
6521 unsafe impl<___E>
6522 ::fidl_next::Encode<
6523 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
6524 ___E,
6525 > for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct
6526 where
6527 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6528 ___E: ::fidl_next::Encoder,
6529 ___E: ::fidl_next::fuchsia::HandleEncoder,
6530 {
6531 #[inline]
6532 fn encode(
6533 self,
6534 encoder_: &mut ___E,
6535 out_: &mut ::core::mem::MaybeUninit<
6536 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
6537 >,
6538 _: (),
6539 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6540 ::fidl_next::munge! {
6541 let crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct {
6542 t,
6543
6544 } = out_;
6545 }
6546
6547 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
6548
6549 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
6550
6551 Ok(())
6552 }
6553 }
6554
6555 unsafe impl<___E>
6556 ::fidl_next::EncodeOption<
6557 ::fidl_next::wire::Box<
6558 'static,
6559 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
6560 >,
6561 ___E,
6562 > for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct
6563 where
6564 ___E: ::fidl_next::Encoder + ?Sized,
6565 TableWithUnknownEnveloepsAfterKnownEnvelopesStruct: ::fidl_next::Encode<
6566 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
6567 ___E,
6568 >,
6569 {
6570 #[inline]
6571 fn encode_option(
6572 this: ::core::option::Option<Self>,
6573 encoder: &mut ___E,
6574 out: &mut ::core::mem::MaybeUninit<
6575 ::fidl_next::wire::Box<
6576 'static,
6577 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
6578 >,
6579 >,
6580 _: (),
6581 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6582 if let Some(inner) = this {
6583 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6584 ::fidl_next::wire::Box::encode_present(out);
6585 } else {
6586 ::fidl_next::wire::Box::encode_absent(out);
6587 }
6588
6589 Ok(())
6590 }
6591 }
6592
6593 impl<'de>
6594 ::fidl_next::FromWire<crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'de>>
6595 for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct
6596 {
6597 #[inline]
6598 fn from_wire(
6599 wire: crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'de>,
6600 ) -> Self {
6601 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
6602 }
6603 }
6604
6605 #[derive(Debug, Default, PartialEq)]
6606 pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopes {
6607 pub b: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
6608 }
6609
6610 impl TableWithUnknownEnvelopesBeforeKnownEnvelopes {
6611 fn __max_ordinal(&self) -> usize {
6612 if self.b.is_some() {
6613 return 2;
6614 }
6615
6616 0
6617 }
6618 }
6619
6620 unsafe impl<___E>
6621 ::fidl_next::Encode<
6622 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes<'static>,
6623 ___E,
6624 > for TableWithUnknownEnvelopesBeforeKnownEnvelopes
6625 where
6626 ___E: ::fidl_next::Encoder + ?Sized,
6627 ___E: ::fidl_next::fuchsia::HandleEncoder,
6628 {
6629 #[inline]
6630 fn encode(
6631 mut self,
6632 encoder: &mut ___E,
6633 out: &mut ::core::mem::MaybeUninit<
6634 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes<'static>,
6635 >,
6636 _: (),
6637 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6638 ::fidl_next::munge!(let crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes { table } = out);
6639
6640 let max_ord = self.__max_ordinal();
6641
6642 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6643 ::fidl_next::Wire::zero_padding(&mut out);
6644
6645 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6646 ::fidl_next::wire::Envelope,
6647 >(encoder, max_ord);
6648
6649 for i in 1..=max_ord {
6650 match i {
6651 2 => {
6652 if let Some(value) = self.b.take() {
6653 ::fidl_next::wire::Envelope::encode_value::<
6654 ::fidl_next::wire::fuchsia::Event,
6655 ___E,
6656 >(
6657 value, preallocated.encoder, &mut out, ()
6658 )?;
6659 } else {
6660 ::fidl_next::wire::Envelope::encode_zero(&mut out)
6661 }
6662 }
6663
6664 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6665 }
6666 unsafe {
6667 preallocated.write_next(out.assume_init_ref());
6668 }
6669 }
6670
6671 ::fidl_next::wire::Table::encode_len(table, max_ord);
6672
6673 Ok(())
6674 }
6675 }
6676
6677 impl<'de> ::fidl_next::FromWire<crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de>>
6678 for TableWithUnknownEnvelopesBeforeKnownEnvelopes
6679 {
6680 #[inline]
6681 fn from_wire(
6682 wire_: crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de>,
6683 ) -> Self {
6684 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6685
6686 let b = wire_.table.get(2);
6687
6688 Self {
6689 b: b.map(|envelope| {
6690 ::fidl_next::FromWire::from_wire(unsafe {
6691 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
6692 })
6693 }),
6694 }
6695 }
6696 }
6697
6698 #[derive(Debug, PartialEq)]
6699 pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct {
6700 pub t: crate::natural::TableWithUnknownEnvelopesBeforeKnownEnvelopes,
6701 }
6702
6703 unsafe impl<___E>
6704 ::fidl_next::Encode<
6705 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
6706 ___E,
6707 > for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct
6708 where
6709 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6710 ___E: ::fidl_next::Encoder,
6711 ___E: ::fidl_next::fuchsia::HandleEncoder,
6712 {
6713 #[inline]
6714 fn encode(
6715 self,
6716 encoder_: &mut ___E,
6717 out_: &mut ::core::mem::MaybeUninit<
6718 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
6719 >,
6720 _: (),
6721 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6722 ::fidl_next::munge! {
6723 let crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct {
6724 t,
6725
6726 } = out_;
6727 }
6728
6729 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
6730
6731 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
6732
6733 Ok(())
6734 }
6735 }
6736
6737 unsafe impl<___E>
6738 ::fidl_next::EncodeOption<
6739 ::fidl_next::wire::Box<
6740 'static,
6741 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
6742 >,
6743 ___E,
6744 > for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct
6745 where
6746 ___E: ::fidl_next::Encoder + ?Sized,
6747 TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct: ::fidl_next::Encode<
6748 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
6749 ___E,
6750 >,
6751 {
6752 #[inline]
6753 fn encode_option(
6754 this: ::core::option::Option<Self>,
6755 encoder: &mut ___E,
6756 out: &mut ::core::mem::MaybeUninit<
6757 ::fidl_next::wire::Box<
6758 'static,
6759 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
6760 >,
6761 >,
6762 _: (),
6763 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6764 if let Some(inner) = this {
6765 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6766 ::fidl_next::wire::Box::encode_present(out);
6767 } else {
6768 ::fidl_next::wire::Box::encode_absent(out);
6769 }
6770
6771 Ok(())
6772 }
6773 }
6774
6775 impl<'de>
6776 ::fidl_next::FromWire<crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'de>>
6777 for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct
6778 {
6779 #[inline]
6780 fn from_wire(
6781 wire: crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'de>,
6782 ) -> Self {
6783 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
6784 }
6785 }
6786
6787 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6788 pub struct TestFlexibleResourceXUnionInStruct {
6789 pub xu: crate::natural::SampleResourceXUnion,
6790 }
6791
6792 unsafe impl<___E>
6793 ::fidl_next::Encode<crate::wire::TestFlexibleResourceXUnionInStruct<'static>, ___E>
6794 for TestFlexibleResourceXUnionInStruct
6795 where
6796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6797 ___E: ::fidl_next::Encoder,
6798 ___E: ::fidl_next::fuchsia::HandleEncoder,
6799 {
6800 #[inline]
6801 fn encode(
6802 self,
6803 encoder_: &mut ___E,
6804 out_: &mut ::core::mem::MaybeUninit<
6805 crate::wire::TestFlexibleResourceXUnionInStruct<'static>,
6806 >,
6807 _: (),
6808 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6809 ::fidl_next::munge! {
6810 let crate::wire::TestFlexibleResourceXUnionInStruct {
6811 xu,
6812
6813 } = out_;
6814 }
6815
6816 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
6817
6818 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(xu.as_mut_ptr()) };
6819
6820 Ok(())
6821 }
6822 }
6823
6824 unsafe impl<___E>
6825 ::fidl_next::EncodeOption<
6826 ::fidl_next::wire::Box<
6827 'static,
6828 crate::wire::TestFlexibleResourceXUnionInStruct<'static>,
6829 >,
6830 ___E,
6831 > for TestFlexibleResourceXUnionInStruct
6832 where
6833 ___E: ::fidl_next::Encoder + ?Sized,
6834 TestFlexibleResourceXUnionInStruct:
6835 ::fidl_next::Encode<crate::wire::TestFlexibleResourceXUnionInStruct<'static>, ___E>,
6836 {
6837 #[inline]
6838 fn encode_option(
6839 this: ::core::option::Option<Self>,
6840 encoder: &mut ___E,
6841 out: &mut ::core::mem::MaybeUninit<
6842 ::fidl_next::wire::Box<
6843 'static,
6844 crate::wire::TestFlexibleResourceXUnionInStruct<'static>,
6845 >,
6846 >,
6847 _: (),
6848 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6849 if let Some(inner) = this {
6850 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6851 ::fidl_next::wire::Box::encode_present(out);
6852 } else {
6853 ::fidl_next::wire::Box::encode_absent(out);
6854 }
6855
6856 Ok(())
6857 }
6858 }
6859
6860 impl<'de> ::fidl_next::FromWire<crate::wire::TestFlexibleResourceXUnionInStruct<'de>>
6861 for TestFlexibleResourceXUnionInStruct
6862 {
6863 #[inline]
6864 fn from_wire(wire: crate::wire::TestFlexibleResourceXUnionInStruct<'de>) -> Self {
6865 Self { xu: ::fidl_next::FromWire::from_wire(wire.xu) }
6866 }
6867 }
6868
6869 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6870 pub struct TestOptionalFlexibleResourceXUnionInStruct {
6871 pub xu: ::core::option::Option<::std::boxed::Box<crate::natural::SampleResourceXUnion>>,
6872 }
6873
6874 unsafe impl<___E>
6875 ::fidl_next::Encode<crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>, ___E>
6876 for TestOptionalFlexibleResourceXUnionInStruct
6877 where
6878 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6879 ___E: ::fidl_next::Encoder,
6880 ___E: ::fidl_next::fuchsia::HandleEncoder,
6881 {
6882 #[inline]
6883 fn encode(
6884 self,
6885 encoder_: &mut ___E,
6886 out_: &mut ::core::mem::MaybeUninit<
6887 crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>,
6888 >,
6889 _: (),
6890 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6891 ::fidl_next::munge! {
6892 let crate::wire::TestOptionalFlexibleResourceXUnionInStruct {
6893 xu,
6894
6895 } = out_;
6896 }
6897
6898 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
6899
6900 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(xu.as_mut_ptr()) };
6901
6902 Ok(())
6903 }
6904 }
6905
6906 unsafe impl<___E>
6907 ::fidl_next::EncodeOption<
6908 ::fidl_next::wire::Box<
6909 'static,
6910 crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>,
6911 >,
6912 ___E,
6913 > for TestOptionalFlexibleResourceXUnionInStruct
6914 where
6915 ___E: ::fidl_next::Encoder + ?Sized,
6916 TestOptionalFlexibleResourceXUnionInStruct: ::fidl_next::Encode<
6917 crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>,
6918 ___E,
6919 >,
6920 {
6921 #[inline]
6922 fn encode_option(
6923 this: ::core::option::Option<Self>,
6924 encoder: &mut ___E,
6925 out: &mut ::core::mem::MaybeUninit<
6926 ::fidl_next::wire::Box<
6927 'static,
6928 crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>,
6929 >,
6930 >,
6931 _: (),
6932 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6933 if let Some(inner) = this {
6934 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6935 ::fidl_next::wire::Box::encode_present(out);
6936 } else {
6937 ::fidl_next::wire::Box::encode_absent(out);
6938 }
6939
6940 Ok(())
6941 }
6942 }
6943
6944 impl<'de> ::fidl_next::FromWire<crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'de>>
6945 for TestOptionalFlexibleResourceXUnionInStruct
6946 {
6947 #[inline]
6948 fn from_wire(wire: crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'de>) -> Self {
6949 Self { xu: ::fidl_next::FromWire::from_wire(wire.xu) }
6950 }
6951 }
6952
6953 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6954 pub struct TestOptionalStrictResourceXUnionInStruct {
6955 pub xu:
6956 ::core::option::Option<::std::boxed::Box<crate::natural::SampleStrictResourceXUnion>>,
6957 }
6958
6959 unsafe impl<___E>
6960 ::fidl_next::Encode<crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>, ___E>
6961 for TestOptionalStrictResourceXUnionInStruct
6962 where
6963 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6964 ___E: ::fidl_next::Encoder,
6965 ___E: ::fidl_next::fuchsia::HandleEncoder,
6966 {
6967 #[inline]
6968 fn encode(
6969 self,
6970 encoder_: &mut ___E,
6971 out_: &mut ::core::mem::MaybeUninit<
6972 crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>,
6973 >,
6974 _: (),
6975 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6976 ::fidl_next::munge! {
6977 let crate::wire::TestOptionalStrictResourceXUnionInStruct {
6978 xu,
6979
6980 } = out_;
6981 }
6982
6983 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
6984
6985 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(xu.as_mut_ptr()) };
6986
6987 Ok(())
6988 }
6989 }
6990
6991 unsafe impl<___E>
6992 ::fidl_next::EncodeOption<
6993 ::fidl_next::wire::Box<
6994 'static,
6995 crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>,
6996 >,
6997 ___E,
6998 > for TestOptionalStrictResourceXUnionInStruct
6999 where
7000 ___E: ::fidl_next::Encoder + ?Sized,
7001 TestOptionalStrictResourceXUnionInStruct: ::fidl_next::Encode<
7002 crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>,
7003 ___E,
7004 >,
7005 {
7006 #[inline]
7007 fn encode_option(
7008 this: ::core::option::Option<Self>,
7009 encoder: &mut ___E,
7010 out: &mut ::core::mem::MaybeUninit<
7011 ::fidl_next::wire::Box<
7012 'static,
7013 crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>,
7014 >,
7015 >,
7016 _: (),
7017 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7018 if let Some(inner) = this {
7019 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7020 ::fidl_next::wire::Box::encode_present(out);
7021 } else {
7022 ::fidl_next::wire::Box::encode_absent(out);
7023 }
7024
7025 Ok(())
7026 }
7027 }
7028
7029 impl<'de> ::fidl_next::FromWire<crate::wire::TestOptionalStrictResourceXUnionInStruct<'de>>
7030 for TestOptionalStrictResourceXUnionInStruct
7031 {
7032 #[inline]
7033 fn from_wire(wire: crate::wire::TestOptionalStrictResourceXUnionInStruct<'de>) -> Self {
7034 Self { xu: ::fidl_next::FromWire::from_wire(wire.xu) }
7035 }
7036 }
7037
7038 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7039 pub struct TestPackageResolverResolveRequest {
7040 pub package_url: ::std::string::String,
7041
7042 pub selectors: ::std::vec::Vec<::std::string::String>,
7043
7044 pub update_policy: crate::natural::UpdatePolicy,
7045
7046 pub this_should_be_a_handle: u32,
7047 }
7048
7049 unsafe impl<___E>
7050 ::fidl_next::Encode<crate::wire::TestPackageResolverResolveRequest<'static>, ___E>
7051 for TestPackageResolverResolveRequest
7052 where
7053 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7054 ___E: ::fidl_next::Encoder,
7055 ___E: ::fidl_next::fuchsia::HandleEncoder,
7056 {
7057 #[inline]
7058 fn encode(
7059 self,
7060 encoder_: &mut ___E,
7061 out_: &mut ::core::mem::MaybeUninit<
7062 crate::wire::TestPackageResolverResolveRequest<'static>,
7063 >,
7064 _: (),
7065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7066 ::fidl_next::munge! {
7067 let crate::wire::TestPackageResolverResolveRequest {
7068 package_url,
7069 selectors,
7070 update_policy,
7071 this_should_be_a_handle,
7072
7073 } = out_;
7074 }
7075
7076 ::fidl_next::Encode::encode(self.package_url, encoder_, package_url, 4294967295)?;
7077
7078 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(package_url.as_mut_ptr()) };
7079 ::fidl_next::Constrained::validate(_field, 4294967295)?;
7080
7081 ::fidl_next::Encode::encode(
7082 self.selectors,
7083 encoder_,
7084 selectors,
7085 (4294967295, 4294967295),
7086 )?;
7087
7088 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(selectors.as_mut_ptr()) };
7089 ::fidl_next::Constrained::validate(_field, (4294967295, 4294967295))?;
7090
7091 ::fidl_next::Encode::encode(self.update_policy, encoder_, update_policy, ())?;
7092
7093 let mut _field =
7094 unsafe { ::fidl_next::Slot::new_unchecked(update_policy.as_mut_ptr()) };
7095
7096 ::fidl_next::Encode::encode(
7097 self.this_should_be_a_handle,
7098 encoder_,
7099 this_should_be_a_handle,
7100 (),
7101 )?;
7102
7103 let mut _field =
7104 unsafe { ::fidl_next::Slot::new_unchecked(this_should_be_a_handle.as_mut_ptr()) };
7105
7106 Ok(())
7107 }
7108 }
7109
7110 unsafe impl<___E>
7111 ::fidl_next::EncodeOption<
7112 ::fidl_next::wire::Box<
7113 'static,
7114 crate::wire::TestPackageResolverResolveRequest<'static>,
7115 >,
7116 ___E,
7117 > for TestPackageResolverResolveRequest
7118 where
7119 ___E: ::fidl_next::Encoder + ?Sized,
7120 TestPackageResolverResolveRequest:
7121 ::fidl_next::Encode<crate::wire::TestPackageResolverResolveRequest<'static>, ___E>,
7122 {
7123 #[inline]
7124 fn encode_option(
7125 this: ::core::option::Option<Self>,
7126 encoder: &mut ___E,
7127 out: &mut ::core::mem::MaybeUninit<
7128 ::fidl_next::wire::Box<
7129 'static,
7130 crate::wire::TestPackageResolverResolveRequest<'static>,
7131 >,
7132 >,
7133 _: (),
7134 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7135 if let Some(inner) = this {
7136 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7137 ::fidl_next::wire::Box::encode_present(out);
7138 } else {
7139 ::fidl_next::wire::Box::encode_absent(out);
7140 }
7141
7142 Ok(())
7143 }
7144 }
7145
7146 impl<'de> ::fidl_next::FromWire<crate::wire::TestPackageResolverResolveRequest<'de>>
7147 for TestPackageResolverResolveRequest
7148 {
7149 #[inline]
7150 fn from_wire(wire: crate::wire::TestPackageResolverResolveRequest<'de>) -> Self {
7151 Self {
7152 package_url: ::fidl_next::FromWire::from_wire(wire.package_url),
7153
7154 selectors: ::fidl_next::FromWire::from_wire(wire.selectors),
7155
7156 update_policy: ::fidl_next::FromWire::from_wire(wire.update_policy),
7157
7158 this_should_be_a_handle: ::fidl_next::FromWire::from_wire(
7159 wire.this_should_be_a_handle,
7160 ),
7161 }
7162 }
7163 }
7164
7165 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7166 pub struct TestStrictResourceXUnionInStruct {
7167 pub xu: crate::natural::SampleStrictResourceXUnion,
7168 }
7169
7170 unsafe impl<___E>
7171 ::fidl_next::Encode<crate::wire::TestStrictResourceXUnionInStruct<'static>, ___E>
7172 for TestStrictResourceXUnionInStruct
7173 where
7174 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7175 ___E: ::fidl_next::Encoder,
7176 ___E: ::fidl_next::fuchsia::HandleEncoder,
7177 {
7178 #[inline]
7179 fn encode(
7180 self,
7181 encoder_: &mut ___E,
7182 out_: &mut ::core::mem::MaybeUninit<
7183 crate::wire::TestStrictResourceXUnionInStruct<'static>,
7184 >,
7185 _: (),
7186 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7187 ::fidl_next::munge! {
7188 let crate::wire::TestStrictResourceXUnionInStruct {
7189 xu,
7190
7191 } = out_;
7192 }
7193
7194 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
7195
7196 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(xu.as_mut_ptr()) };
7197
7198 Ok(())
7199 }
7200 }
7201
7202 unsafe impl<___E>
7203 ::fidl_next::EncodeOption<
7204 ::fidl_next::wire::Box<'static, crate::wire::TestStrictResourceXUnionInStruct<'static>>,
7205 ___E,
7206 > for TestStrictResourceXUnionInStruct
7207 where
7208 ___E: ::fidl_next::Encoder + ?Sized,
7209 TestStrictResourceXUnionInStruct:
7210 ::fidl_next::Encode<crate::wire::TestStrictResourceXUnionInStruct<'static>, ___E>,
7211 {
7212 #[inline]
7213 fn encode_option(
7214 this: ::core::option::Option<Self>,
7215 encoder: &mut ___E,
7216 out: &mut ::core::mem::MaybeUninit<
7217 ::fidl_next::wire::Box<
7218 'static,
7219 crate::wire::TestStrictResourceXUnionInStruct<'static>,
7220 >,
7221 >,
7222 _: (),
7223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7224 if let Some(inner) = this {
7225 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7226 ::fidl_next::wire::Box::encode_present(out);
7227 } else {
7228 ::fidl_next::wire::Box::encode_absent(out);
7229 }
7230
7231 Ok(())
7232 }
7233 }
7234
7235 impl<'de> ::fidl_next::FromWire<crate::wire::TestStrictResourceXUnionInStruct<'de>>
7236 for TestStrictResourceXUnionInStruct
7237 {
7238 #[inline]
7239 fn from_wire(wire: crate::wire::TestStrictResourceXUnionInStruct<'de>) -> Self {
7240 Self { xu: ::fidl_next::FromWire::from_wire(wire.xu) }
7241 }
7242 }
7243
7244 #[derive(Debug, PartialEq)]
7245 pub struct UnboundedNonnullableVectorOfHandles {
7246 pub vh0: ::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>,
7247 }
7248
7249 unsafe impl<___E>
7250 ::fidl_next::Encode<crate::wire::UnboundedNonnullableVectorOfHandles<'static>, ___E>
7251 for UnboundedNonnullableVectorOfHandles
7252 where
7253 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7254 ___E: ::fidl_next::Encoder,
7255 ___E: ::fidl_next::fuchsia::HandleEncoder,
7256 {
7257 #[inline]
7258 fn encode(
7259 self,
7260 encoder_: &mut ___E,
7261 out_: &mut ::core::mem::MaybeUninit<
7262 crate::wire::UnboundedNonnullableVectorOfHandles<'static>,
7263 >,
7264 _: (),
7265 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7266 ::fidl_next::munge! {
7267 let crate::wire::UnboundedNonnullableVectorOfHandles {
7268 vh0,
7269
7270 } = out_;
7271 }
7272
7273 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (4294967295, ()))?;
7274
7275 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh0.as_mut_ptr()) };
7276 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
7277
7278 Ok(())
7279 }
7280 }
7281
7282 unsafe impl<___E>
7283 ::fidl_next::EncodeOption<
7284 ::fidl_next::wire::Box<
7285 'static,
7286 crate::wire::UnboundedNonnullableVectorOfHandles<'static>,
7287 >,
7288 ___E,
7289 > for UnboundedNonnullableVectorOfHandles
7290 where
7291 ___E: ::fidl_next::Encoder + ?Sized,
7292 UnboundedNonnullableVectorOfHandles:
7293 ::fidl_next::Encode<crate::wire::UnboundedNonnullableVectorOfHandles<'static>, ___E>,
7294 {
7295 #[inline]
7296 fn encode_option(
7297 this: ::core::option::Option<Self>,
7298 encoder: &mut ___E,
7299 out: &mut ::core::mem::MaybeUninit<
7300 ::fidl_next::wire::Box<
7301 'static,
7302 crate::wire::UnboundedNonnullableVectorOfHandles<'static>,
7303 >,
7304 >,
7305 _: (),
7306 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7307 if let Some(inner) = this {
7308 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7309 ::fidl_next::wire::Box::encode_present(out);
7310 } else {
7311 ::fidl_next::wire::Box::encode_absent(out);
7312 }
7313
7314 Ok(())
7315 }
7316 }
7317
7318 impl<'de> ::fidl_next::FromWire<crate::wire::UnboundedNonnullableVectorOfHandles<'de>>
7319 for UnboundedNonnullableVectorOfHandles
7320 {
7321 #[inline]
7322 fn from_wire(wire: crate::wire::UnboundedNonnullableVectorOfHandles<'de>) -> Self {
7323 Self { vh0: ::fidl_next::FromWire::from_wire(wire.vh0) }
7324 }
7325 }
7326
7327 #[derive(Debug, PartialEq)]
7328 pub struct UnboundedNullableVectorOfHandles {
7329 pub vh0: ::core::option::Option<::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>>,
7330 }
7331
7332 unsafe impl<___E>
7333 ::fidl_next::Encode<crate::wire::UnboundedNullableVectorOfHandles<'static>, ___E>
7334 for UnboundedNullableVectorOfHandles
7335 where
7336 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7337 ___E: ::fidl_next::Encoder,
7338 ___E: ::fidl_next::fuchsia::HandleEncoder,
7339 {
7340 #[inline]
7341 fn encode(
7342 self,
7343 encoder_: &mut ___E,
7344 out_: &mut ::core::mem::MaybeUninit<
7345 crate::wire::UnboundedNullableVectorOfHandles<'static>,
7346 >,
7347 _: (),
7348 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7349 ::fidl_next::munge! {
7350 let crate::wire::UnboundedNullableVectorOfHandles {
7351 vh0,
7352
7353 } = out_;
7354 }
7355
7356 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (4294967295, ()))?;
7357
7358 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vh0.as_mut_ptr()) };
7359 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
7360
7361 Ok(())
7362 }
7363 }
7364
7365 unsafe impl<___E>
7366 ::fidl_next::EncodeOption<
7367 ::fidl_next::wire::Box<'static, crate::wire::UnboundedNullableVectorOfHandles<'static>>,
7368 ___E,
7369 > for UnboundedNullableVectorOfHandles
7370 where
7371 ___E: ::fidl_next::Encoder + ?Sized,
7372 UnboundedNullableVectorOfHandles:
7373 ::fidl_next::Encode<crate::wire::UnboundedNullableVectorOfHandles<'static>, ___E>,
7374 {
7375 #[inline]
7376 fn encode_option(
7377 this: ::core::option::Option<Self>,
7378 encoder: &mut ___E,
7379 out: &mut ::core::mem::MaybeUninit<
7380 ::fidl_next::wire::Box<
7381 'static,
7382 crate::wire::UnboundedNullableVectorOfHandles<'static>,
7383 >,
7384 >,
7385 _: (),
7386 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7387 if let Some(inner) = this {
7388 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7389 ::fidl_next::wire::Box::encode_present(out);
7390 } else {
7391 ::fidl_next::wire::Box::encode_absent(out);
7392 }
7393
7394 Ok(())
7395 }
7396 }
7397
7398 impl<'de> ::fidl_next::FromWire<crate::wire::UnboundedNullableVectorOfHandles<'de>>
7399 for UnboundedNullableVectorOfHandles
7400 {
7401 #[inline]
7402 fn from_wire(wire: crate::wire::UnboundedNullableVectorOfHandles<'de>) -> Self {
7403 Self { vh0: ::fidl_next::FromWire::from_wire(wire.vh0) }
7404 }
7405 }
7406
7407 #[derive(Debug, PartialEq)]
7408 pub enum UnionOfEndpointsUnion {
7409 ClientEnd(::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>),
7410
7411 ServerEnd(::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::fuchsia::zx::Channel>),
7412
7413 UnknownOrdinal_(u64),
7414 }
7415
7416 impl UnionOfEndpointsUnion {
7417 pub fn is_unknown(&self) -> bool {
7418 #[allow(unreachable_patterns)]
7419 match self {
7420 Self::UnknownOrdinal_(_) => true,
7421 _ => false,
7422 }
7423 }
7424 }
7425
7426 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnionOfEndpointsUnion<'static>, ___E>
7427 for UnionOfEndpointsUnion
7428 where
7429 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7430 ___E: ::fidl_next::Encoder,
7431 ___E: ::fidl_next::fuchsia::HandleEncoder,
7432 {
7433 #[inline]
7434 fn encode(
7435 self,
7436 encoder: &mut ___E,
7437 out: &mut ::core::mem::MaybeUninit<crate::wire::UnionOfEndpointsUnion<'static>>,
7438 _: (),
7439 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7440 ::fidl_next::munge!(let crate::wire::UnionOfEndpointsUnion { raw, _phantom: _ } = out);
7441
7442 match self {
7443 Self::ClientEnd(value) => ::fidl_next::wire::Union::encode_as::<
7444 ___E,
7445 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
7446 >(value, 1, encoder, raw, ())?,
7447
7448 Self::ServerEnd(value) => ::fidl_next::wire::Union::encode_as::<
7449 ___E,
7450 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
7451 >(value, 2, encoder, raw, ())?,
7452
7453 Self::UnknownOrdinal_(ordinal) => {
7454 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
7455 }
7456 }
7457
7458 Ok(())
7459 }
7460 }
7461
7462 unsafe impl<___E>
7463 ::fidl_next::EncodeOption<crate::wire_optional::UnionOfEndpointsUnion<'static>, ___E>
7464 for UnionOfEndpointsUnion
7465 where
7466 ___E: ?Sized,
7467 UnionOfEndpointsUnion:
7468 ::fidl_next::Encode<crate::wire::UnionOfEndpointsUnion<'static>, ___E>,
7469 {
7470 #[inline]
7471 fn encode_option(
7472 this: ::core::option::Option<Self>,
7473 encoder: &mut ___E,
7474 out: &mut ::core::mem::MaybeUninit<
7475 crate::wire_optional::UnionOfEndpointsUnion<'static>,
7476 >,
7477 _: (),
7478 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7479 ::fidl_next::munge!(let crate::wire_optional::UnionOfEndpointsUnion { raw, _phantom: _ } = &mut *out);
7480
7481 if let Some(inner) = this {
7482 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7483 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7484 } else {
7485 ::fidl_next::wire::Union::encode_absent(raw);
7486 }
7487
7488 Ok(())
7489 }
7490 }
7491
7492 impl<'de> ::fidl_next::FromWire<crate::wire::UnionOfEndpointsUnion<'de>> for UnionOfEndpointsUnion {
7493 #[inline]
7494 fn from_wire(wire: crate::wire::UnionOfEndpointsUnion<'de>) -> Self {
7495 let wire = ::core::mem::ManuallyDrop::new(wire);
7496 match wire.raw.ordinal() {
7497 1 => Self::ClientEnd(::fidl_next::FromWire::from_wire(unsafe {
7498 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
7499 })),
7500
7501 2 => Self::ServerEnd(::fidl_next::FromWire::from_wire(unsafe {
7502 wire.raw.get().read_unchecked::<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
7503 })),
7504
7505 ord => return Self::UnknownOrdinal_(ord as u64),
7506 }
7507 }
7508 }
7509
7510 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::UnionOfEndpointsUnion<'de>>
7511 for UnionOfEndpointsUnion
7512 {
7513 #[inline]
7514 fn from_wire_option(
7515 wire: crate::wire_optional::UnionOfEndpointsUnion<'de>,
7516 ) -> ::core::option::Option<Self> {
7517 if let Some(inner) = wire.into_option() {
7518 Some(::fidl_next::FromWire::from_wire(inner))
7519 } else {
7520 None
7521 }
7522 }
7523 }
7524
7525 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::UnionOfEndpointsUnion<'de>>
7526 for Box<UnionOfEndpointsUnion>
7527 {
7528 #[inline]
7529 fn from_wire_option(
7530 wire: crate::wire_optional::UnionOfEndpointsUnion<'de>,
7531 ) -> ::core::option::Option<Self> {
7532 <UnionOfEndpointsUnion as ::fidl_next::FromWireOption<
7533 crate::wire_optional::UnionOfEndpointsUnion<'de>,
7534 >>::from_wire_option(wire)
7535 .map(Box::new)
7536 }
7537 }
7538
7539 #[derive(Debug, PartialEq)]
7540 pub struct UnionOfEndpoints {
7541 pub u: crate::natural::UnionOfEndpointsUnion,
7542 }
7543
7544 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnionOfEndpoints<'static>, ___E>
7545 for UnionOfEndpoints
7546 where
7547 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7548 ___E: ::fidl_next::Encoder,
7549 ___E: ::fidl_next::fuchsia::HandleEncoder,
7550 {
7551 #[inline]
7552 fn encode(
7553 self,
7554 encoder_: &mut ___E,
7555 out_: &mut ::core::mem::MaybeUninit<crate::wire::UnionOfEndpoints<'static>>,
7556 _: (),
7557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7558 ::fidl_next::munge! {
7559 let crate::wire::UnionOfEndpoints {
7560 u,
7561
7562 } = out_;
7563 }
7564
7565 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
7566
7567 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(u.as_mut_ptr()) };
7568
7569 Ok(())
7570 }
7571 }
7572
7573 unsafe impl<___E>
7574 ::fidl_next::EncodeOption<
7575 ::fidl_next::wire::Box<'static, crate::wire::UnionOfEndpoints<'static>>,
7576 ___E,
7577 > for UnionOfEndpoints
7578 where
7579 ___E: ::fidl_next::Encoder + ?Sized,
7580 UnionOfEndpoints: ::fidl_next::Encode<crate::wire::UnionOfEndpoints<'static>, ___E>,
7581 {
7582 #[inline]
7583 fn encode_option(
7584 this: ::core::option::Option<Self>,
7585 encoder: &mut ___E,
7586 out: &mut ::core::mem::MaybeUninit<
7587 ::fidl_next::wire::Box<'static, crate::wire::UnionOfEndpoints<'static>>,
7588 >,
7589 _: (),
7590 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7591 if let Some(inner) = this {
7592 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7593 ::fidl_next::wire::Box::encode_present(out);
7594 } else {
7595 ::fidl_next::wire::Box::encode_absent(out);
7596 }
7597
7598 Ok(())
7599 }
7600 }
7601
7602 impl<'de> ::fidl_next::FromWire<crate::wire::UnionOfEndpoints<'de>> for UnionOfEndpoints {
7603 #[inline]
7604 fn from_wire(wire: crate::wire::UnionOfEndpoints<'de>) -> Self {
7605 Self { u: ::fidl_next::FromWire::from_wire(wire.u) }
7606 }
7607 }
7608
7609 #[derive(Debug, PartialEq)]
7610 pub enum UnionOfHandle {
7611 H(::fidl_next::fuchsia::zx::NullableHandle),
7612 }
7613
7614 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnionOfHandle, ___E> for UnionOfHandle
7615 where
7616 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7617 ___E: ::fidl_next::fuchsia::HandleEncoder,
7618 {
7619 #[inline]
7620 fn encode(
7621 self,
7622 encoder: &mut ___E,
7623 out: &mut ::core::mem::MaybeUninit<crate::wire::UnionOfHandle>,
7624 _: (),
7625 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7626 ::fidl_next::munge!(let crate::wire::UnionOfHandle { raw, _phantom: _ } = out);
7627
7628 match self {
7629 Self::H(value) => ::fidl_next::wire::Union::encode_as_static::<
7630 ___E,
7631 ::fidl_next::wire::fuchsia::NullableHandle,
7632 >(value, 1, encoder, raw, ())?,
7633 }
7634
7635 Ok(())
7636 }
7637 }
7638
7639 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::UnionOfHandle, ___E>
7640 for UnionOfHandle
7641 where
7642 ___E: ?Sized,
7643 UnionOfHandle: ::fidl_next::Encode<crate::wire::UnionOfHandle, ___E>,
7644 {
7645 #[inline]
7646 fn encode_option(
7647 this: ::core::option::Option<Self>,
7648 encoder: &mut ___E,
7649 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::UnionOfHandle>,
7650 _: (),
7651 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7652 ::fidl_next::munge!(let crate::wire_optional::UnionOfHandle { raw, _phantom: _ } = &mut *out);
7653
7654 if let Some(inner) = this {
7655 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7656 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7657 } else {
7658 ::fidl_next::wire::Union::encode_absent(raw);
7659 }
7660
7661 Ok(())
7662 }
7663 }
7664
7665 impl ::fidl_next::FromWire<crate::wire::UnionOfHandle> for UnionOfHandle {
7666 #[inline]
7667 fn from_wire(wire: crate::wire::UnionOfHandle) -> Self {
7668 let wire = ::core::mem::ManuallyDrop::new(wire);
7669 match wire.raw.ordinal() {
7670 1 => Self::H(::fidl_next::FromWire::from_wire(unsafe {
7671 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
7672 })),
7673
7674 _ => unsafe { ::core::hint::unreachable_unchecked() },
7675 }
7676 }
7677 }
7678
7679 impl ::fidl_next::FromWireOption<crate::wire_optional::UnionOfHandle> for UnionOfHandle {
7680 #[inline]
7681 fn from_wire_option(
7682 wire: crate::wire_optional::UnionOfHandle,
7683 ) -> ::core::option::Option<Self> {
7684 if let Some(inner) = wire.into_option() {
7685 Some(::fidl_next::FromWire::from_wire(inner))
7686 } else {
7687 None
7688 }
7689 }
7690 }
7691
7692 impl ::fidl_next::FromWireOption<crate::wire_optional::UnionOfHandle> for Box<UnionOfHandle> {
7693 #[inline]
7694 fn from_wire_option(
7695 wire: crate::wire_optional::UnionOfHandle,
7696 ) -> ::core::option::Option<Self> {
7697 <
7698 UnionOfHandle as ::fidl_next::FromWireOption<crate::wire_optional::UnionOfHandle>
7699 >::from_wire_option(wire).map(Box::new)
7700 }
7701 }
7702
7703 #[derive(Debug, PartialEq)]
7704 pub struct VectorOfArrayOfEventInStructWithDefaultRights {
7705 pub h: ::std::vec::Vec<[::fidl_next::fuchsia::zx::Event; 1]>,
7706 }
7707
7708 unsafe impl<___E>
7709 ::fidl_next::Encode<
7710 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
7711 ___E,
7712 > for VectorOfArrayOfEventInStructWithDefaultRights
7713 where
7714 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7715 ___E: ::fidl_next::Encoder,
7716 ___E: ::fidl_next::fuchsia::HandleEncoder,
7717 {
7718 #[inline]
7719 fn encode(
7720 self,
7721 encoder_: &mut ___E,
7722 out_: &mut ::core::mem::MaybeUninit<
7723 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
7724 >,
7725 _: (),
7726 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7727 ::fidl_next::munge! {
7728 let crate::wire::VectorOfArrayOfEventInStructWithDefaultRights {
7729 h,
7730
7731 } = out_;
7732 }
7733
7734 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
7735
7736 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
7737 ::fidl_next::Constrained::validate(_field, (1, ()))?;
7738
7739 Ok(())
7740 }
7741 }
7742
7743 unsafe impl<___E>
7744 ::fidl_next::EncodeOption<
7745 ::fidl_next::wire::Box<
7746 'static,
7747 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
7748 >,
7749 ___E,
7750 > for VectorOfArrayOfEventInStructWithDefaultRights
7751 where
7752 ___E: ::fidl_next::Encoder + ?Sized,
7753 VectorOfArrayOfEventInStructWithDefaultRights: ::fidl_next::Encode<
7754 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
7755 ___E,
7756 >,
7757 {
7758 #[inline]
7759 fn encode_option(
7760 this: ::core::option::Option<Self>,
7761 encoder: &mut ___E,
7762 out: &mut ::core::mem::MaybeUninit<
7763 ::fidl_next::wire::Box<
7764 'static,
7765 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
7766 >,
7767 >,
7768 _: (),
7769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7770 if let Some(inner) = this {
7771 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7772 ::fidl_next::wire::Box::encode_present(out);
7773 } else {
7774 ::fidl_next::wire::Box::encode_absent(out);
7775 }
7776
7777 Ok(())
7778 }
7779 }
7780
7781 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'de>>
7782 for VectorOfArrayOfEventInStructWithDefaultRights
7783 {
7784 #[inline]
7785 fn from_wire(
7786 wire: crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'de>,
7787 ) -> Self {
7788 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
7789 }
7790 }
7791
7792 #[derive(Debug, PartialEq)]
7793 pub struct VectorOfArrayOfEventInStructWithReducedRights {
7794 pub h: ::std::vec::Vec<[::fidl_next::fuchsia::zx::Event; 1]>,
7795 }
7796
7797 unsafe impl<___E>
7798 ::fidl_next::Encode<
7799 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
7800 ___E,
7801 > for VectorOfArrayOfEventInStructWithReducedRights
7802 where
7803 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7804 ___E: ::fidl_next::Encoder,
7805 ___E: ::fidl_next::fuchsia::HandleEncoder,
7806 {
7807 #[inline]
7808 fn encode(
7809 self,
7810 encoder_: &mut ___E,
7811 out_: &mut ::core::mem::MaybeUninit<
7812 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
7813 >,
7814 _: (),
7815 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7816 ::fidl_next::munge! {
7817 let crate::wire::VectorOfArrayOfEventInStructWithReducedRights {
7818 h,
7819
7820 } = out_;
7821 }
7822
7823 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
7824
7825 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(h.as_mut_ptr()) };
7826 ::fidl_next::Constrained::validate(_field, (1, ()))?;
7827
7828 Ok(())
7829 }
7830 }
7831
7832 unsafe impl<___E>
7833 ::fidl_next::EncodeOption<
7834 ::fidl_next::wire::Box<
7835 'static,
7836 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
7837 >,
7838 ___E,
7839 > for VectorOfArrayOfEventInStructWithReducedRights
7840 where
7841 ___E: ::fidl_next::Encoder + ?Sized,
7842 VectorOfArrayOfEventInStructWithReducedRights: ::fidl_next::Encode<
7843 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
7844 ___E,
7845 >,
7846 {
7847 #[inline]
7848 fn encode_option(
7849 this: ::core::option::Option<Self>,
7850 encoder: &mut ___E,
7851 out: &mut ::core::mem::MaybeUninit<
7852 ::fidl_next::wire::Box<
7853 'static,
7854 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
7855 >,
7856 >,
7857 _: (),
7858 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7859 if let Some(inner) = this {
7860 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7861 ::fidl_next::wire::Box::encode_present(out);
7862 } else {
7863 ::fidl_next::wire::Box::encode_absent(out);
7864 }
7865
7866 Ok(())
7867 }
7868 }
7869
7870 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'de>>
7871 for VectorOfArrayOfEventInStructWithReducedRights
7872 {
7873 #[inline]
7874 fn from_wire(
7875 wire: crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'de>,
7876 ) -> Self {
7877 Self { h: ::fidl_next::FromWire::from_wire(wire.h) }
7878 }
7879 }
7880
7881 #[derive(Debug, Default, PartialEq)]
7882 pub struct VectorOfArrayOfEventInTableWithReducedRights {
7883 pub h: ::core::option::Option<::std::vec::Vec<[::fidl_next::fuchsia::zx::Event; 1]>>,
7884 }
7885
7886 impl VectorOfArrayOfEventInTableWithReducedRights {
7887 fn __max_ordinal(&self) -> usize {
7888 if self.h.is_some() {
7889 return 1;
7890 }
7891
7892 0
7893 }
7894 }
7895
7896 unsafe impl<___E>
7897 ::fidl_next::Encode<
7898 crate::wire::VectorOfArrayOfEventInTableWithReducedRights<'static>,
7899 ___E,
7900 > for VectorOfArrayOfEventInTableWithReducedRights
7901 where
7902 ___E: ::fidl_next::Encoder + ?Sized,
7903 ___E: ::fidl_next::fuchsia::HandleEncoder,
7904 {
7905 #[inline]
7906 fn encode(
7907 mut self,
7908 encoder: &mut ___E,
7909 out: &mut ::core::mem::MaybeUninit<
7910 crate::wire::VectorOfArrayOfEventInTableWithReducedRights<'static>,
7911 >,
7912 _: (),
7913 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7914 ::fidl_next::munge!(let crate::wire::VectorOfArrayOfEventInTableWithReducedRights { table } = out);
7915
7916 let max_ord = self.__max_ordinal();
7917
7918 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7919 ::fidl_next::Wire::zero_padding(&mut out);
7920
7921 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7922 ::fidl_next::wire::Envelope,
7923 >(encoder, max_ord);
7924
7925 for i in 1..=max_ord {
7926 match i {
7927 1 => {
7928 if let Some(value) = self.h.take() {
7929 ::fidl_next::wire::Envelope::encode_value::<
7930 ::fidl_next::wire::Vector<
7931 'static,
7932 [::fidl_next::wire::fuchsia::Event; 1],
7933 >,
7934 ___E,
7935 >(
7936 value, preallocated.encoder, &mut out, (1, ())
7937 )?;
7938 } else {
7939 ::fidl_next::wire::Envelope::encode_zero(&mut out)
7940 }
7941 }
7942
7943 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7944 }
7945 unsafe {
7946 preallocated.write_next(out.assume_init_ref());
7947 }
7948 }
7949
7950 ::fidl_next::wire::Table::encode_len(table, max_ord);
7951
7952 Ok(())
7953 }
7954 }
7955
7956 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfArrayOfEventInTableWithReducedRights<'de>>
7957 for VectorOfArrayOfEventInTableWithReducedRights
7958 {
7959 #[inline]
7960 fn from_wire(
7961 wire_: crate::wire::VectorOfArrayOfEventInTableWithReducedRights<'de>,
7962 ) -> Self {
7963 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
7964
7965 let h = wire_.table.get(1);
7966
7967 Self {
7968 h:
7969 h.map(|envelope| {
7970 ::fidl_next::FromWire::from_wire(unsafe {
7971 envelope.read_unchecked::<::fidl_next::wire::Vector<
7972 'de,
7973 [::fidl_next::wire::fuchsia::Event; 1],
7974 >>()
7975 })
7976 }),
7977 }
7978 }
7979 }
7980
7981 #[derive(Debug, PartialEq)]
7982 pub struct VectorOfArrayOfEventInTableWithReducedRightsStruct {
7983 pub t: crate::natural::VectorOfArrayOfEventInTableWithReducedRights,
7984 }
7985
7986 unsafe impl<___E>
7987 ::fidl_next::Encode<
7988 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
7989 ___E,
7990 > for VectorOfArrayOfEventInTableWithReducedRightsStruct
7991 where
7992 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7993 ___E: ::fidl_next::Encoder,
7994 ___E: ::fidl_next::fuchsia::HandleEncoder,
7995 {
7996 #[inline]
7997 fn encode(
7998 self,
7999 encoder_: &mut ___E,
8000 out_: &mut ::core::mem::MaybeUninit<
8001 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
8002 >,
8003 _: (),
8004 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8005 ::fidl_next::munge! {
8006 let crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct {
8007 t,
8008
8009 } = out_;
8010 }
8011
8012 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
8013
8014 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(t.as_mut_ptr()) };
8015
8016 Ok(())
8017 }
8018 }
8019
8020 unsafe impl<___E>
8021 ::fidl_next::EncodeOption<
8022 ::fidl_next::wire::Box<
8023 'static,
8024 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
8025 >,
8026 ___E,
8027 > for VectorOfArrayOfEventInTableWithReducedRightsStruct
8028 where
8029 ___E: ::fidl_next::Encoder + ?Sized,
8030 VectorOfArrayOfEventInTableWithReducedRightsStruct: ::fidl_next::Encode<
8031 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
8032 ___E,
8033 >,
8034 {
8035 #[inline]
8036 fn encode_option(
8037 this: ::core::option::Option<Self>,
8038 encoder: &mut ___E,
8039 out: &mut ::core::mem::MaybeUninit<
8040 ::fidl_next::wire::Box<
8041 'static,
8042 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
8043 >,
8044 >,
8045 _: (),
8046 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8047 if let Some(inner) = this {
8048 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8049 ::fidl_next::wire::Box::encode_present(out);
8050 } else {
8051 ::fidl_next::wire::Box::encode_absent(out);
8052 }
8053
8054 Ok(())
8055 }
8056 }
8057
8058 impl<'de>
8059 ::fidl_next::FromWire<crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'de>>
8060 for VectorOfArrayOfEventInTableWithReducedRightsStruct
8061 {
8062 #[inline]
8063 fn from_wire(
8064 wire: crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'de>,
8065 ) -> Self {
8066 Self { t: ::fidl_next::FromWire::from_wire(wire.t) }
8067 }
8068 }
8069
8070 #[derive(Debug, PartialEq)]
8071 pub enum VectorOfArrayOfEventInUnionWithReducedRights {
8072 H(::std::vec::Vec<[::fidl_next::fuchsia::zx::Event; 1]>),
8073 }
8074
8075 unsafe impl<___E>
8076 ::fidl_next::Encode<
8077 crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'static>,
8078 ___E,
8079 > for VectorOfArrayOfEventInUnionWithReducedRights
8080 where
8081 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8082 ___E: ::fidl_next::Encoder,
8083 ___E: ::fidl_next::fuchsia::HandleEncoder,
8084 {
8085 #[inline]
8086 fn encode(
8087 self,
8088 encoder: &mut ___E,
8089 out: &mut ::core::mem::MaybeUninit<
8090 crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'static>,
8091 >,
8092 _: (),
8093 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8094 ::fidl_next::munge!(let crate::wire::VectorOfArrayOfEventInUnionWithReducedRights { raw, _phantom: _ } = out);
8095
8096 match self {
8097 Self::H(value) => ::fidl_next::wire::Union::encode_as::<
8098 ___E,
8099 ::fidl_next::wire::Vector<'static, [::fidl_next::wire::fuchsia::Event; 1]>,
8100 >(value, 1, encoder, raw, (1, ()))?,
8101 }
8102
8103 Ok(())
8104 }
8105 }
8106
8107 unsafe impl<___E>
8108 ::fidl_next::EncodeOption<
8109 crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'static>,
8110 ___E,
8111 > for VectorOfArrayOfEventInUnionWithReducedRights
8112 where
8113 ___E: ?Sized,
8114 VectorOfArrayOfEventInUnionWithReducedRights: ::fidl_next::Encode<
8115 crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'static>,
8116 ___E,
8117 >,
8118 {
8119 #[inline]
8120 fn encode_option(
8121 this: ::core::option::Option<Self>,
8122 encoder: &mut ___E,
8123 out: &mut ::core::mem::MaybeUninit<
8124 crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'static>,
8125 >,
8126 _: (),
8127 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8128 ::fidl_next::munge!(let crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights { raw, _phantom: _ } = &mut *out);
8129
8130 if let Some(inner) = this {
8131 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
8132 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
8133 } else {
8134 ::fidl_next::wire::Union::encode_absent(raw);
8135 }
8136
8137 Ok(())
8138 }
8139 }
8140
8141 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'de>>
8142 for VectorOfArrayOfEventInUnionWithReducedRights
8143 {
8144 #[inline]
8145 fn from_wire(wire: crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'de>) -> Self {
8146 let wire = ::core::mem::ManuallyDrop::new(wire);
8147 match wire.raw.ordinal() {
8148 1 => Self::H(::fidl_next::FromWire::from_wire(unsafe {
8149 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>>()
8150 })),
8151
8152 _ => unsafe { ::core::hint::unreachable_unchecked() },
8153 }
8154 }
8155 }
8156
8157 impl<'de>
8158 ::fidl_next::FromWireOption<
8159 crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'de>,
8160 > for VectorOfArrayOfEventInUnionWithReducedRights
8161 {
8162 #[inline]
8163 fn from_wire_option(
8164 wire: crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'de>,
8165 ) -> ::core::option::Option<Self> {
8166 if let Some(inner) = wire.into_option() {
8167 Some(::fidl_next::FromWire::from_wire(inner))
8168 } else {
8169 None
8170 }
8171 }
8172 }
8173
8174 impl<'de>
8175 ::fidl_next::FromWireOption<
8176 crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'de>,
8177 > for Box<VectorOfArrayOfEventInUnionWithReducedRights>
8178 {
8179 #[inline]
8180 fn from_wire_option(
8181 wire: crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'de>,
8182 ) -> ::core::option::Option<Self> {
8183 <VectorOfArrayOfEventInUnionWithReducedRights as ::fidl_next::FromWireOption<
8184 crate::wire_optional::VectorOfArrayOfEventInUnionWithReducedRights<'de>,
8185 >>::from_wire_option(wire)
8186 .map(Box::new)
8187 }
8188 }
8189
8190 #[derive(Debug, PartialEq)]
8191 pub struct VectorOfArrayOfEventInUnionWithReducedRightsStruct {
8192 pub u: crate::natural::VectorOfArrayOfEventInUnionWithReducedRights,
8193 }
8194
8195 unsafe impl<___E>
8196 ::fidl_next::Encode<
8197 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
8198 ___E,
8199 > for VectorOfArrayOfEventInUnionWithReducedRightsStruct
8200 where
8201 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8202 ___E: ::fidl_next::Encoder,
8203 ___E: ::fidl_next::fuchsia::HandleEncoder,
8204 {
8205 #[inline]
8206 fn encode(
8207 self,
8208 encoder_: &mut ___E,
8209 out_: &mut ::core::mem::MaybeUninit<
8210 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
8211 >,
8212 _: (),
8213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8214 ::fidl_next::munge! {
8215 let crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct {
8216 u,
8217
8218 } = out_;
8219 }
8220
8221 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
8222
8223 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(u.as_mut_ptr()) };
8224
8225 Ok(())
8226 }
8227 }
8228
8229 unsafe impl<___E>
8230 ::fidl_next::EncodeOption<
8231 ::fidl_next::wire::Box<
8232 'static,
8233 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
8234 >,
8235 ___E,
8236 > for VectorOfArrayOfEventInUnionWithReducedRightsStruct
8237 where
8238 ___E: ::fidl_next::Encoder + ?Sized,
8239 VectorOfArrayOfEventInUnionWithReducedRightsStruct: ::fidl_next::Encode<
8240 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
8241 ___E,
8242 >,
8243 {
8244 #[inline]
8245 fn encode_option(
8246 this: ::core::option::Option<Self>,
8247 encoder: &mut ___E,
8248 out: &mut ::core::mem::MaybeUninit<
8249 ::fidl_next::wire::Box<
8250 'static,
8251 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
8252 >,
8253 >,
8254 _: (),
8255 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8256 if let Some(inner) = this {
8257 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8258 ::fidl_next::wire::Box::encode_present(out);
8259 } else {
8260 ::fidl_next::wire::Box::encode_absent(out);
8261 }
8262
8263 Ok(())
8264 }
8265 }
8266
8267 impl<'de>
8268 ::fidl_next::FromWire<crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'de>>
8269 for VectorOfArrayOfEventInUnionWithReducedRightsStruct
8270 {
8271 #[inline]
8272 fn from_wire(
8273 wire: crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'de>,
8274 ) -> Self {
8275 Self { u: ::fidl_next::FromWire::from_wire(wire.u) }
8276 }
8277 }
8278
8279 #[derive(Debug, PartialEq)]
8280 pub struct VectorOfHandles {
8281 pub v: ::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>,
8282 }
8283
8284 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VectorOfHandles<'static>, ___E>
8285 for VectorOfHandles
8286 where
8287 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8288 ___E: ::fidl_next::Encoder,
8289 ___E: ::fidl_next::fuchsia::HandleEncoder,
8290 {
8291 #[inline]
8292 fn encode(
8293 self,
8294 encoder_: &mut ___E,
8295 out_: &mut ::core::mem::MaybeUninit<crate::wire::VectorOfHandles<'static>>,
8296 _: (),
8297 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8298 ::fidl_next::munge! {
8299 let crate::wire::VectorOfHandles {
8300 v,
8301
8302 } = out_;
8303 }
8304
8305 ::fidl_next::Encode::encode(self.v, encoder_, v, (4294967295, ()))?;
8306
8307 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(v.as_mut_ptr()) };
8308 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
8309
8310 Ok(())
8311 }
8312 }
8313
8314 unsafe impl<___E>
8315 ::fidl_next::EncodeOption<
8316 ::fidl_next::wire::Box<'static, crate::wire::VectorOfHandles<'static>>,
8317 ___E,
8318 > for VectorOfHandles
8319 where
8320 ___E: ::fidl_next::Encoder + ?Sized,
8321 VectorOfHandles: ::fidl_next::Encode<crate::wire::VectorOfHandles<'static>, ___E>,
8322 {
8323 #[inline]
8324 fn encode_option(
8325 this: ::core::option::Option<Self>,
8326 encoder: &mut ___E,
8327 out: &mut ::core::mem::MaybeUninit<
8328 ::fidl_next::wire::Box<'static, crate::wire::VectorOfHandles<'static>>,
8329 >,
8330 _: (),
8331 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8332 if let Some(inner) = this {
8333 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8334 ::fidl_next::wire::Box::encode_present(out);
8335 } else {
8336 ::fidl_next::wire::Box::encode_absent(out);
8337 }
8338
8339 Ok(())
8340 }
8341 }
8342
8343 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfHandles<'de>> for VectorOfHandles {
8344 #[inline]
8345 fn from_wire(wire: crate::wire::VectorOfHandles<'de>) -> Self {
8346 Self { v: ::fidl_next::FromWire::from_wire(wire.v) }
8347 }
8348 }
8349
8350 #[derive(Debug, PartialEq)]
8351 pub struct VectorOfOptionalHandles {
8352 pub v: ::std::vec::Vec<::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>>,
8353 }
8354
8355 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VectorOfOptionalHandles<'static>, ___E>
8356 for VectorOfOptionalHandles
8357 where
8358 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8359 ___E: ::fidl_next::Encoder,
8360 ___E: ::fidl_next::fuchsia::HandleEncoder,
8361 {
8362 #[inline]
8363 fn encode(
8364 self,
8365 encoder_: &mut ___E,
8366 out_: &mut ::core::mem::MaybeUninit<crate::wire::VectorOfOptionalHandles<'static>>,
8367 _: (),
8368 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8369 ::fidl_next::munge! {
8370 let crate::wire::VectorOfOptionalHandles {
8371 v,
8372
8373 } = out_;
8374 }
8375
8376 ::fidl_next::Encode::encode(self.v, encoder_, v, (4294967295, ()))?;
8377
8378 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(v.as_mut_ptr()) };
8379 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
8380
8381 Ok(())
8382 }
8383 }
8384
8385 unsafe impl<___E>
8386 ::fidl_next::EncodeOption<
8387 ::fidl_next::wire::Box<'static, crate::wire::VectorOfOptionalHandles<'static>>,
8388 ___E,
8389 > for VectorOfOptionalHandles
8390 where
8391 ___E: ::fidl_next::Encoder + ?Sized,
8392 VectorOfOptionalHandles:
8393 ::fidl_next::Encode<crate::wire::VectorOfOptionalHandles<'static>, ___E>,
8394 {
8395 #[inline]
8396 fn encode_option(
8397 this: ::core::option::Option<Self>,
8398 encoder: &mut ___E,
8399 out: &mut ::core::mem::MaybeUninit<
8400 ::fidl_next::wire::Box<'static, crate::wire::VectorOfOptionalHandles<'static>>,
8401 >,
8402 _: (),
8403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8404 if let Some(inner) = this {
8405 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8406 ::fidl_next::wire::Box::encode_present(out);
8407 } else {
8408 ::fidl_next::wire::Box::encode_absent(out);
8409 }
8410
8411 Ok(())
8412 }
8413 }
8414
8415 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfOptionalHandles<'de>>
8416 for VectorOfOptionalHandles
8417 {
8418 #[inline]
8419 fn from_wire(wire: crate::wire::VectorOfOptionalHandles<'de>) -> Self {
8420 Self { v: ::fidl_next::FromWire::from_wire(wire.v) }
8421 }
8422 }
8423
8424 #[derive(Debug, PartialEq)]
8425 pub struct VectorOfUpTo2Handles {
8426 pub v: ::std::vec::Vec<::fidl_next::fuchsia::zx::NullableHandle>,
8427 }
8428
8429 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VectorOfUpTo2Handles<'static>, ___E>
8430 for VectorOfUpTo2Handles
8431 where
8432 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8433 ___E: ::fidl_next::Encoder,
8434 ___E: ::fidl_next::fuchsia::HandleEncoder,
8435 {
8436 #[inline]
8437 fn encode(
8438 self,
8439 encoder_: &mut ___E,
8440 out_: &mut ::core::mem::MaybeUninit<crate::wire::VectorOfUpTo2Handles<'static>>,
8441 _: (),
8442 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8443 ::fidl_next::munge! {
8444 let crate::wire::VectorOfUpTo2Handles {
8445 v,
8446
8447 } = out_;
8448 }
8449
8450 ::fidl_next::Encode::encode(self.v, encoder_, v, (2, ()))?;
8451
8452 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(v.as_mut_ptr()) };
8453 ::fidl_next::Constrained::validate(_field, (2, ()))?;
8454
8455 Ok(())
8456 }
8457 }
8458
8459 unsafe impl<___E>
8460 ::fidl_next::EncodeOption<
8461 ::fidl_next::wire::Box<'static, crate::wire::VectorOfUpTo2Handles<'static>>,
8462 ___E,
8463 > for VectorOfUpTo2Handles
8464 where
8465 ___E: ::fidl_next::Encoder + ?Sized,
8466 VectorOfUpTo2Handles: ::fidl_next::Encode<crate::wire::VectorOfUpTo2Handles<'static>, ___E>,
8467 {
8468 #[inline]
8469 fn encode_option(
8470 this: ::core::option::Option<Self>,
8471 encoder: &mut ___E,
8472 out: &mut ::core::mem::MaybeUninit<
8473 ::fidl_next::wire::Box<'static, crate::wire::VectorOfUpTo2Handles<'static>>,
8474 >,
8475 _: (),
8476 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8477 if let Some(inner) = this {
8478 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8479 ::fidl_next::wire::Box::encode_present(out);
8480 } else {
8481 ::fidl_next::wire::Box::encode_absent(out);
8482 }
8483
8484 Ok(())
8485 }
8486 }
8487
8488 impl<'de> ::fidl_next::FromWire<crate::wire::VectorOfUpTo2Handles<'de>> for VectorOfUpTo2Handles {
8489 #[inline]
8490 fn from_wire(wire: crate::wire::VectorOfUpTo2Handles<'de>) -> Self {
8491 Self { v: ::fidl_next::FromWire::from_wire(wire.v) }
8492 }
8493 }
8494}
8495
8496pub mod wire {
8497
8498 pub use fidl_next_common_test_conformance::wire::*;
8499
8500 #[derive(Debug)]
8502 #[repr(C)]
8503 pub struct AlternatingHandlesAndFailures<'de> {
8504 pub h1: ::fidl_next::wire::fuchsia::NullableHandle,
8505
8506 pub failure_trigger1: ::fidl_next::wire::String<'de>,
8507
8508 pub h2: ::fidl_next::wire::fuchsia::NullableHandle,
8509
8510 pub failure_trigger2: ::fidl_next::wire::String<'de>,
8511
8512 pub h3: ::fidl_next::wire::fuchsia::NullableHandle,
8513 }
8514
8515 static_assertions::const_assert_eq!(
8516 std::mem::size_of::<AlternatingHandlesAndFailures<'_>>(),
8517 56
8518 );
8519 static_assertions::const_assert_eq!(
8520 std::mem::align_of::<AlternatingHandlesAndFailures<'_>>(),
8521 8
8522 );
8523
8524 static_assertions::const_assert_eq!(
8525 std::mem::offset_of!(AlternatingHandlesAndFailures<'_>, h1),
8526 0
8527 );
8528
8529 static_assertions::const_assert_eq!(
8530 std::mem::offset_of!(AlternatingHandlesAndFailures<'_>, failure_trigger1),
8531 8
8532 );
8533
8534 static_assertions::const_assert_eq!(
8535 std::mem::offset_of!(AlternatingHandlesAndFailures<'_>, h2),
8536 24
8537 );
8538
8539 static_assertions::const_assert_eq!(
8540 std::mem::offset_of!(AlternatingHandlesAndFailures<'_>, failure_trigger2),
8541 32
8542 );
8543
8544 static_assertions::const_assert_eq!(
8545 std::mem::offset_of!(AlternatingHandlesAndFailures<'_>, h3),
8546 48
8547 );
8548
8549 impl ::fidl_next::Constrained for AlternatingHandlesAndFailures<'_> {
8550 type Constraint = ();
8551
8552 fn validate(
8553 _: ::fidl_next::Slot<'_, Self>,
8554 _: Self::Constraint,
8555 ) -> Result<(), ::fidl_next::ValidationError> {
8556 Ok(())
8557 }
8558 }
8559
8560 unsafe impl ::fidl_next::Wire for AlternatingHandlesAndFailures<'static> {
8561 type Narrowed<'de> = AlternatingHandlesAndFailures<'de>;
8562
8563 #[inline]
8564 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8565 ::fidl_next::munge! {
8566 let Self {
8567 h1,
8568 failure_trigger1,
8569 h2,
8570 failure_trigger2,
8571 h3,
8572
8573 } = &mut *out_;
8574 }
8575
8576 ::fidl_next::Wire::zero_padding(h1);
8577
8578 ::fidl_next::Wire::zero_padding(failure_trigger1);
8579
8580 ::fidl_next::Wire::zero_padding(h2);
8581
8582 ::fidl_next::Wire::zero_padding(failure_trigger2);
8583
8584 ::fidl_next::Wire::zero_padding(h3);
8585
8586 unsafe {
8587 out_.as_mut_ptr().cast::<u8>().add(52).write_bytes(0, 4);
8588 }
8589
8590 unsafe {
8591 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
8592 }
8593
8594 unsafe {
8595 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
8596 }
8597 }
8598 }
8599
8600 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AlternatingHandlesAndFailures<'de>
8601 where
8602 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8603 ___D: ::fidl_next::Decoder<'de>,
8604 ___D: ::fidl_next::fuchsia::HandleDecoder,
8605 {
8606 fn decode(
8607 slot_: ::fidl_next::Slot<'_, Self>,
8608 decoder_: &mut ___D,
8609 _: (),
8610 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8611 if slot_.as_bytes()[52..56] != [0u8; 4] {
8612 return Err(::fidl_next::DecodeError::InvalidPadding);
8613 }
8614
8615 if slot_.as_bytes()[28..32] != [0u8; 4] {
8616 return Err(::fidl_next::DecodeError::InvalidPadding);
8617 }
8618
8619 if slot_.as_bytes()[4..8] != [0u8; 4] {
8620 return Err(::fidl_next::DecodeError::InvalidPadding);
8621 }
8622
8623 ::fidl_next::munge! {
8624 let Self {
8625 mut h1,
8626 mut failure_trigger1,
8627 mut h2,
8628 mut failure_trigger2,
8629 mut h3,
8630
8631 } = slot_;
8632 }
8633
8634 let _field = h1.as_mut();
8635
8636 ::fidl_next::Decode::decode(h1.as_mut(), decoder_, ())?;
8637
8638 let _field = failure_trigger1.as_mut();
8639 ::fidl_next::Constrained::validate(_field, 1)?;
8640 ::fidl_next::Decode::decode(failure_trigger1.as_mut(), decoder_, 1)?;
8641
8642 let failure_trigger1 = unsafe { failure_trigger1.deref_unchecked() };
8643
8644 if failure_trigger1.len() > 1 {
8645 return Err(::fidl_next::DecodeError::VectorTooLong {
8646 size: failure_trigger1.len() as u64,
8647 limit: 1,
8648 });
8649 }
8650
8651 let _field = h2.as_mut();
8652
8653 ::fidl_next::Decode::decode(h2.as_mut(), decoder_, ())?;
8654
8655 let _field = failure_trigger2.as_mut();
8656 ::fidl_next::Constrained::validate(_field, 1)?;
8657 ::fidl_next::Decode::decode(failure_trigger2.as_mut(), decoder_, 1)?;
8658
8659 let failure_trigger2 = unsafe { failure_trigger2.deref_unchecked() };
8660
8661 if failure_trigger2.len() > 1 {
8662 return Err(::fidl_next::DecodeError::VectorTooLong {
8663 size: failure_trigger2.len() as u64,
8664 limit: 1,
8665 });
8666 }
8667
8668 let _field = h3.as_mut();
8669
8670 ::fidl_next::Decode::decode(h3.as_mut(), decoder_, ())?;
8671
8672 Ok(())
8673 }
8674 }
8675
8676 impl<'de> ::fidl_next::IntoNatural for AlternatingHandlesAndFailures<'de> {
8677 type Natural = crate::natural::AlternatingHandlesAndFailures;
8678 }
8679
8680 #[derive(Debug)]
8682 #[repr(C)]
8683 pub struct ArrayOfArrayOfNonnullableHandles {
8684 pub handles: [[::fidl_next::wire::fuchsia::NullableHandle; 3]; 4],
8685 }
8686
8687 static_assertions::const_assert_eq!(
8688 std::mem::size_of::<ArrayOfArrayOfNonnullableHandles>(),
8689 48
8690 );
8691 static_assertions::const_assert_eq!(
8692 std::mem::align_of::<ArrayOfArrayOfNonnullableHandles>(),
8693 4
8694 );
8695
8696 static_assertions::const_assert_eq!(
8697 std::mem::offset_of!(ArrayOfArrayOfNonnullableHandles, handles),
8698 0
8699 );
8700
8701 impl ::fidl_next::Constrained for ArrayOfArrayOfNonnullableHandles {
8702 type Constraint = ();
8703
8704 fn validate(
8705 _: ::fidl_next::Slot<'_, Self>,
8706 _: Self::Constraint,
8707 ) -> Result<(), ::fidl_next::ValidationError> {
8708 Ok(())
8709 }
8710 }
8711
8712 unsafe impl ::fidl_next::Wire for ArrayOfArrayOfNonnullableHandles {
8713 type Narrowed<'de> = ArrayOfArrayOfNonnullableHandles;
8714
8715 #[inline]
8716 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8717 ::fidl_next::munge! {
8718 let Self {
8719 handles,
8720
8721 } = &mut *out_;
8722 }
8723
8724 ::fidl_next::Wire::zero_padding(handles);
8725 }
8726 }
8727
8728 unsafe impl<___D> ::fidl_next::Decode<___D> for ArrayOfArrayOfNonnullableHandles
8729 where
8730 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8731 ___D: ::fidl_next::fuchsia::HandleDecoder,
8732 {
8733 fn decode(
8734 slot_: ::fidl_next::Slot<'_, Self>,
8735 decoder_: &mut ___D,
8736 _: (),
8737 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8738 ::fidl_next::munge! {
8739 let Self {
8740 mut handles,
8741
8742 } = slot_;
8743 }
8744
8745 let _field = handles.as_mut();
8746
8747 ::fidl_next::Decode::decode(handles.as_mut(), decoder_, ())?;
8748
8749 Ok(())
8750 }
8751 }
8752
8753 impl ::fidl_next::IntoNatural for ArrayOfArrayOfNonnullableHandles {
8754 type Natural = crate::natural::ArrayOfArrayOfNonnullableHandles;
8755 }
8756
8757 #[derive(Debug)]
8759 #[repr(C)]
8760 pub struct ArrayOfHandles {
8761 pub a: [::fidl_next::wire::fuchsia::NullableHandle; 3],
8762 }
8763
8764 static_assertions::const_assert_eq!(std::mem::size_of::<ArrayOfHandles>(), 12);
8765 static_assertions::const_assert_eq!(std::mem::align_of::<ArrayOfHandles>(), 4);
8766
8767 static_assertions::const_assert_eq!(std::mem::offset_of!(ArrayOfHandles, a), 0);
8768
8769 impl ::fidl_next::Constrained for ArrayOfHandles {
8770 type Constraint = ();
8771
8772 fn validate(
8773 _: ::fidl_next::Slot<'_, Self>,
8774 _: Self::Constraint,
8775 ) -> Result<(), ::fidl_next::ValidationError> {
8776 Ok(())
8777 }
8778 }
8779
8780 unsafe impl ::fidl_next::Wire for ArrayOfHandles {
8781 type Narrowed<'de> = ArrayOfHandles;
8782
8783 #[inline]
8784 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8785 ::fidl_next::munge! {
8786 let Self {
8787 a,
8788
8789 } = &mut *out_;
8790 }
8791
8792 ::fidl_next::Wire::zero_padding(a);
8793 }
8794 }
8795
8796 unsafe impl<___D> ::fidl_next::Decode<___D> for ArrayOfHandles
8797 where
8798 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8799 ___D: ::fidl_next::fuchsia::HandleDecoder,
8800 {
8801 fn decode(
8802 slot_: ::fidl_next::Slot<'_, Self>,
8803 decoder_: &mut ___D,
8804 _: (),
8805 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8806 ::fidl_next::munge! {
8807 let Self {
8808 mut a,
8809
8810 } = slot_;
8811 }
8812
8813 let _field = a.as_mut();
8814
8815 ::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
8816
8817 Ok(())
8818 }
8819 }
8820
8821 impl ::fidl_next::IntoNatural for ArrayOfHandles {
8822 type Natural = crate::natural::ArrayOfHandles;
8823 }
8824
8825 #[derive(Debug)]
8827 #[repr(C)]
8828 pub struct ArrayOfNonnullableHandles {
8829 pub handles: [::fidl_next::wire::fuchsia::NullableHandle; 4],
8830 }
8831
8832 static_assertions::const_assert_eq!(std::mem::size_of::<ArrayOfNonnullableHandles>(), 16);
8833 static_assertions::const_assert_eq!(std::mem::align_of::<ArrayOfNonnullableHandles>(), 4);
8834
8835 static_assertions::const_assert_eq!(
8836 std::mem::offset_of!(ArrayOfNonnullableHandles, handles),
8837 0
8838 );
8839
8840 impl ::fidl_next::Constrained for ArrayOfNonnullableHandles {
8841 type Constraint = ();
8842
8843 fn validate(
8844 _: ::fidl_next::Slot<'_, Self>,
8845 _: Self::Constraint,
8846 ) -> Result<(), ::fidl_next::ValidationError> {
8847 Ok(())
8848 }
8849 }
8850
8851 unsafe impl ::fidl_next::Wire for ArrayOfNonnullableHandles {
8852 type Narrowed<'de> = ArrayOfNonnullableHandles;
8853
8854 #[inline]
8855 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8856 ::fidl_next::munge! {
8857 let Self {
8858 handles,
8859
8860 } = &mut *out_;
8861 }
8862
8863 ::fidl_next::Wire::zero_padding(handles);
8864 }
8865 }
8866
8867 unsafe impl<___D> ::fidl_next::Decode<___D> for ArrayOfNonnullableHandles
8868 where
8869 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8870 ___D: ::fidl_next::fuchsia::HandleDecoder,
8871 {
8872 fn decode(
8873 slot_: ::fidl_next::Slot<'_, Self>,
8874 decoder_: &mut ___D,
8875 _: (),
8876 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8877 ::fidl_next::munge! {
8878 let Self {
8879 mut handles,
8880
8881 } = slot_;
8882 }
8883
8884 let _field = handles.as_mut();
8885
8886 ::fidl_next::Decode::decode(handles.as_mut(), decoder_, ())?;
8887
8888 Ok(())
8889 }
8890 }
8891
8892 impl ::fidl_next::IntoNatural for ArrayOfNonnullableHandles {
8893 type Natural = crate::natural::ArrayOfNonnullableHandles;
8894 }
8895
8896 #[derive(Debug)]
8898 #[repr(C)]
8899 pub struct ArrayOfNullableHandles {
8900 pub handles: [::fidl_next::wire::fuchsia::OptionalNullableHandle; 5],
8901 }
8902
8903 static_assertions::const_assert_eq!(std::mem::size_of::<ArrayOfNullableHandles>(), 20);
8904 static_assertions::const_assert_eq!(std::mem::align_of::<ArrayOfNullableHandles>(), 4);
8905
8906 static_assertions::const_assert_eq!(std::mem::offset_of!(ArrayOfNullableHandles, handles), 0);
8907
8908 impl ::fidl_next::Constrained for ArrayOfNullableHandles {
8909 type Constraint = ();
8910
8911 fn validate(
8912 _: ::fidl_next::Slot<'_, Self>,
8913 _: Self::Constraint,
8914 ) -> Result<(), ::fidl_next::ValidationError> {
8915 Ok(())
8916 }
8917 }
8918
8919 unsafe impl ::fidl_next::Wire for ArrayOfNullableHandles {
8920 type Narrowed<'de> = ArrayOfNullableHandles;
8921
8922 #[inline]
8923 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8924 ::fidl_next::munge! {
8925 let Self {
8926 handles,
8927
8928 } = &mut *out_;
8929 }
8930
8931 ::fidl_next::Wire::zero_padding(handles);
8932 }
8933 }
8934
8935 unsafe impl<___D> ::fidl_next::Decode<___D> for ArrayOfNullableHandles
8936 where
8937 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8938 ___D: ::fidl_next::fuchsia::HandleDecoder,
8939 {
8940 fn decode(
8941 slot_: ::fidl_next::Slot<'_, Self>,
8942 decoder_: &mut ___D,
8943 _: (),
8944 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8945 ::fidl_next::munge! {
8946 let Self {
8947 mut handles,
8948
8949 } = slot_;
8950 }
8951
8952 let _field = handles.as_mut();
8953
8954 ::fidl_next::Decode::decode(handles.as_mut(), decoder_, ())?;
8955
8956 Ok(())
8957 }
8958 }
8959
8960 impl ::fidl_next::IntoNatural for ArrayOfNullableHandles {
8961 type Natural = crate::natural::ArrayOfNullableHandles;
8962 }
8963
8964 #[derive(Debug)]
8966 #[repr(C)]
8967 pub struct ArrayOfOptionalHandles {
8968 pub a: [::fidl_next::wire::fuchsia::OptionalNullableHandle; 3],
8969 }
8970
8971 static_assertions::const_assert_eq!(std::mem::size_of::<ArrayOfOptionalHandles>(), 12);
8972 static_assertions::const_assert_eq!(std::mem::align_of::<ArrayOfOptionalHandles>(), 4);
8973
8974 static_assertions::const_assert_eq!(std::mem::offset_of!(ArrayOfOptionalHandles, a), 0);
8975
8976 impl ::fidl_next::Constrained for ArrayOfOptionalHandles {
8977 type Constraint = ();
8978
8979 fn validate(
8980 _: ::fidl_next::Slot<'_, Self>,
8981 _: Self::Constraint,
8982 ) -> Result<(), ::fidl_next::ValidationError> {
8983 Ok(())
8984 }
8985 }
8986
8987 unsafe impl ::fidl_next::Wire for ArrayOfOptionalHandles {
8988 type Narrowed<'de> = ArrayOfOptionalHandles;
8989
8990 #[inline]
8991 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8992 ::fidl_next::munge! {
8993 let Self {
8994 a,
8995
8996 } = &mut *out_;
8997 }
8998
8999 ::fidl_next::Wire::zero_padding(a);
9000 }
9001 }
9002
9003 unsafe impl<___D> ::fidl_next::Decode<___D> for ArrayOfOptionalHandles
9004 where
9005 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9006 ___D: ::fidl_next::fuchsia::HandleDecoder,
9007 {
9008 fn decode(
9009 slot_: ::fidl_next::Slot<'_, Self>,
9010 decoder_: &mut ___D,
9011 _: (),
9012 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9013 ::fidl_next::munge! {
9014 let Self {
9015 mut a,
9016
9017 } = slot_;
9018 }
9019
9020 let _field = a.as_mut();
9021
9022 ::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
9023
9024 Ok(())
9025 }
9026 }
9027
9028 impl ::fidl_next::IntoNatural for ArrayOfOptionalHandles {
9029 type Natural = crate::natural::ArrayOfOptionalHandles;
9030 }
9031
9032 #[derive(Debug)]
9034 #[repr(C)]
9035 pub struct ArrayOfVectorOfEventInStructWithDefaultRights<'de> {
9036 pub h: [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9037 }
9038
9039 static_assertions::const_assert_eq!(
9040 std::mem::size_of::<ArrayOfVectorOfEventInStructWithDefaultRights<'_>>(),
9041 16
9042 );
9043 static_assertions::const_assert_eq!(
9044 std::mem::align_of::<ArrayOfVectorOfEventInStructWithDefaultRights<'_>>(),
9045 8
9046 );
9047
9048 static_assertions::const_assert_eq!(
9049 std::mem::offset_of!(ArrayOfVectorOfEventInStructWithDefaultRights<'_>, h),
9050 0
9051 );
9052
9053 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInStructWithDefaultRights<'_> {
9054 type Constraint = ();
9055
9056 fn validate(
9057 _: ::fidl_next::Slot<'_, Self>,
9058 _: Self::Constraint,
9059 ) -> Result<(), ::fidl_next::ValidationError> {
9060 Ok(())
9061 }
9062 }
9063
9064 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInStructWithDefaultRights<'static> {
9065 type Narrowed<'de> = ArrayOfVectorOfEventInStructWithDefaultRights<'de>;
9066
9067 #[inline]
9068 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9069 ::fidl_next::munge! {
9070 let Self {
9071 h,
9072
9073 } = &mut *out_;
9074 }
9075
9076 ::fidl_next::Wire::zero_padding(h);
9077 }
9078 }
9079
9080 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9081 for ArrayOfVectorOfEventInStructWithDefaultRights<'de>
9082 where
9083 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9084 ___D: ::fidl_next::Decoder<'de>,
9085 ___D: ::fidl_next::fuchsia::HandleDecoder,
9086 {
9087 fn decode(
9088 slot_: ::fidl_next::Slot<'_, Self>,
9089 decoder_: &mut ___D,
9090 _: (),
9091 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9092 ::fidl_next::munge! {
9093 let Self {
9094 mut h,
9095
9096 } = slot_;
9097 }
9098
9099 let _field = h.as_mut();
9100 ::fidl_next::Constrained::validate(_field, (1, ()))?;
9101 ::fidl_next::Decode::decode(h.as_mut(), decoder_, (1, ()))?;
9102
9103 Ok(())
9104 }
9105 }
9106
9107 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInStructWithDefaultRights<'de> {
9108 type Natural = crate::natural::ArrayOfVectorOfEventInStructWithDefaultRights;
9109 }
9110
9111 #[derive(Debug)]
9113 #[repr(C)]
9114 pub struct ArrayOfVectorOfEventInStructWithReducedRights<'de> {
9115 pub h: [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9116 }
9117
9118 static_assertions::const_assert_eq!(
9119 std::mem::size_of::<ArrayOfVectorOfEventInStructWithReducedRights<'_>>(),
9120 16
9121 );
9122 static_assertions::const_assert_eq!(
9123 std::mem::align_of::<ArrayOfVectorOfEventInStructWithReducedRights<'_>>(),
9124 8
9125 );
9126
9127 static_assertions::const_assert_eq!(
9128 std::mem::offset_of!(ArrayOfVectorOfEventInStructWithReducedRights<'_>, h),
9129 0
9130 );
9131
9132 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInStructWithReducedRights<'_> {
9133 type Constraint = ();
9134
9135 fn validate(
9136 _: ::fidl_next::Slot<'_, Self>,
9137 _: Self::Constraint,
9138 ) -> Result<(), ::fidl_next::ValidationError> {
9139 Ok(())
9140 }
9141 }
9142
9143 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInStructWithReducedRights<'static> {
9144 type Narrowed<'de> = ArrayOfVectorOfEventInStructWithReducedRights<'de>;
9145
9146 #[inline]
9147 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9148 ::fidl_next::munge! {
9149 let Self {
9150 h,
9151
9152 } = &mut *out_;
9153 }
9154
9155 ::fidl_next::Wire::zero_padding(h);
9156 }
9157 }
9158
9159 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9160 for ArrayOfVectorOfEventInStructWithReducedRights<'de>
9161 where
9162 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9163 ___D: ::fidl_next::Decoder<'de>,
9164 ___D: ::fidl_next::fuchsia::HandleDecoder,
9165 {
9166 fn decode(
9167 slot_: ::fidl_next::Slot<'_, Self>,
9168 decoder_: &mut ___D,
9169 _: (),
9170 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9171 ::fidl_next::munge! {
9172 let Self {
9173 mut h,
9174
9175 } = slot_;
9176 }
9177
9178 let _field = h.as_mut();
9179 ::fidl_next::Constrained::validate(_field, (1, ()))?;
9180 ::fidl_next::Decode::decode(h.as_mut(), decoder_, (1, ()))?;
9181
9182 Ok(())
9183 }
9184 }
9185
9186 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInStructWithReducedRights<'de> {
9187 type Natural = crate::natural::ArrayOfVectorOfEventInStructWithReducedRights;
9188 }
9189
9190 #[repr(C)]
9192 pub struct ArrayOfVectorOfEventInTableWithDefaultRights<'de> {
9193 pub(crate) table: ::fidl_next::wire::Table<'de>,
9194 }
9195
9196 impl<'de> Drop for ArrayOfVectorOfEventInTableWithDefaultRights<'de> {
9197 fn drop(&mut self) {
9198 let _ = self.table.get(1)
9199 .map(|envelope| unsafe {
9200 envelope.read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
9201 });
9202 }
9203 }
9204
9205 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInTableWithDefaultRights<'_> {
9206 type Constraint = ();
9207
9208 fn validate(
9209 _: ::fidl_next::Slot<'_, Self>,
9210 _: Self::Constraint,
9211 ) -> Result<(), ::fidl_next::ValidationError> {
9212 Ok(())
9213 }
9214 }
9215
9216 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInTableWithDefaultRights<'static> {
9217 type Narrowed<'de> = ArrayOfVectorOfEventInTableWithDefaultRights<'de>;
9218
9219 #[inline]
9220 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9221 ::fidl_next::munge!(let Self { table } = out);
9222 ::fidl_next::wire::Table::zero_padding(table);
9223 }
9224 }
9225
9226 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9227 for ArrayOfVectorOfEventInTableWithDefaultRights<'de>
9228 where
9229 ___D: ::fidl_next::Decoder<'de> + ?Sized,
9230 ___D: ::fidl_next::fuchsia::HandleDecoder,
9231 {
9232 fn decode(
9233 slot: ::fidl_next::Slot<'_, Self>,
9234 decoder: &mut ___D,
9235 _: (),
9236 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9237 ::fidl_next::munge!(let Self { table } = slot);
9238
9239 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
9240 match ordinal {
9241 0 => unsafe { ::core::hint::unreachable_unchecked() },
9242
9243 1 => {
9244 ::fidl_next::wire::Envelope::decode_as::<
9245 ___D,
9246 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9247 >(slot.as_mut(), decoder, (1, ()))?;
9248
9249 Ok(())
9250 }
9251
9252 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
9253 }
9254 })
9255 }
9256 }
9257
9258 impl<'de> ArrayOfVectorOfEventInTableWithDefaultRights<'de> {
9259 pub fn h(
9260 &self,
9261 ) -> ::core::option::Option<
9262 &[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9263 > {
9264 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
9265 }
9266
9267 pub fn take_h(
9268 &mut self,
9269 ) -> ::core::option::Option<
9270 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9271 > {
9272 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
9273 }
9274 }
9275
9276 impl<'de> ::core::fmt::Debug for ArrayOfVectorOfEventInTableWithDefaultRights<'de> {
9277 fn fmt(
9278 &self,
9279 f: &mut ::core::fmt::Formatter<'_>,
9280 ) -> ::core::result::Result<(), ::core::fmt::Error> {
9281 f.debug_struct("ArrayOfVectorOfEventInTableWithDefaultRights")
9282 .field("h", &self.h())
9283 .finish()
9284 }
9285 }
9286
9287 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInTableWithDefaultRights<'de> {
9288 type Natural = crate::natural::ArrayOfVectorOfEventInTableWithDefaultRights;
9289 }
9290
9291 #[derive(Debug)]
9293 #[repr(C)]
9294 pub struct ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'de> {
9295 pub t: crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights<'de>,
9296 }
9297
9298 static_assertions::const_assert_eq!(
9299 std::mem::size_of::<ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'_>>(),
9300 16
9301 );
9302 static_assertions::const_assert_eq!(
9303 std::mem::align_of::<ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'_>>(),
9304 8
9305 );
9306
9307 static_assertions::const_assert_eq!(
9308 std::mem::offset_of!(ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'_>, t),
9309 0
9310 );
9311
9312 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'_> {
9313 type Constraint = ();
9314
9315 fn validate(
9316 _: ::fidl_next::Slot<'_, Self>,
9317 _: Self::Constraint,
9318 ) -> Result<(), ::fidl_next::ValidationError> {
9319 Ok(())
9320 }
9321 }
9322
9323 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static> {
9324 type Narrowed<'de> = ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'de>;
9325
9326 #[inline]
9327 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9328 ::fidl_next::munge! {
9329 let Self {
9330 t,
9331
9332 } = &mut *out_;
9333 }
9334
9335 ::fidl_next::Wire::zero_padding(t);
9336 }
9337 }
9338
9339 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9340 for ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'de>
9341 where
9342 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9343 ___D: ::fidl_next::Decoder<'de>,
9344 ___D: ::fidl_next::fuchsia::HandleDecoder,
9345 {
9346 fn decode(
9347 slot_: ::fidl_next::Slot<'_, Self>,
9348 decoder_: &mut ___D,
9349 _: (),
9350 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9351 ::fidl_next::munge! {
9352 let Self {
9353 mut t,
9354
9355 } = slot_;
9356 }
9357
9358 let _field = t.as_mut();
9359
9360 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
9361
9362 Ok(())
9363 }
9364 }
9365
9366 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'de> {
9367 type Natural = crate::natural::ArrayOfVectorOfEventInTableWithDefaultRightsStruct;
9368 }
9369
9370 #[repr(C)]
9372 pub struct ArrayOfVectorOfEventInTableWithReducedRights<'de> {
9373 pub(crate) table: ::fidl_next::wire::Table<'de>,
9374 }
9375
9376 impl<'de> Drop for ArrayOfVectorOfEventInTableWithReducedRights<'de> {
9377 fn drop(&mut self) {
9378 let _ = self.table.get(1)
9379 .map(|envelope| unsafe {
9380 envelope.read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
9381 });
9382 }
9383 }
9384
9385 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInTableWithReducedRights<'_> {
9386 type Constraint = ();
9387
9388 fn validate(
9389 _: ::fidl_next::Slot<'_, Self>,
9390 _: Self::Constraint,
9391 ) -> Result<(), ::fidl_next::ValidationError> {
9392 Ok(())
9393 }
9394 }
9395
9396 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInTableWithReducedRights<'static> {
9397 type Narrowed<'de> = ArrayOfVectorOfEventInTableWithReducedRights<'de>;
9398
9399 #[inline]
9400 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9401 ::fidl_next::munge!(let Self { table } = out);
9402 ::fidl_next::wire::Table::zero_padding(table);
9403 }
9404 }
9405
9406 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9407 for ArrayOfVectorOfEventInTableWithReducedRights<'de>
9408 where
9409 ___D: ::fidl_next::Decoder<'de> + ?Sized,
9410 ___D: ::fidl_next::fuchsia::HandleDecoder,
9411 {
9412 fn decode(
9413 slot: ::fidl_next::Slot<'_, Self>,
9414 decoder: &mut ___D,
9415 _: (),
9416 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9417 ::fidl_next::munge!(let Self { table } = slot);
9418
9419 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
9420 match ordinal {
9421 0 => unsafe { ::core::hint::unreachable_unchecked() },
9422
9423 1 => {
9424 ::fidl_next::wire::Envelope::decode_as::<
9425 ___D,
9426 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9427 >(slot.as_mut(), decoder, (1, ()))?;
9428
9429 Ok(())
9430 }
9431
9432 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
9433 }
9434 })
9435 }
9436 }
9437
9438 impl<'de> ArrayOfVectorOfEventInTableWithReducedRights<'de> {
9439 pub fn h(
9440 &self,
9441 ) -> ::core::option::Option<
9442 &[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9443 > {
9444 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
9445 }
9446
9447 pub fn take_h(
9448 &mut self,
9449 ) -> ::core::option::Option<
9450 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9451 > {
9452 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
9453 }
9454 }
9455
9456 impl<'de> ::core::fmt::Debug for ArrayOfVectorOfEventInTableWithReducedRights<'de> {
9457 fn fmt(
9458 &self,
9459 f: &mut ::core::fmt::Formatter<'_>,
9460 ) -> ::core::result::Result<(), ::core::fmt::Error> {
9461 f.debug_struct("ArrayOfVectorOfEventInTableWithReducedRights")
9462 .field("h", &self.h())
9463 .finish()
9464 }
9465 }
9466
9467 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInTableWithReducedRights<'de> {
9468 type Natural = crate::natural::ArrayOfVectorOfEventInTableWithReducedRights;
9469 }
9470
9471 #[derive(Debug)]
9473 #[repr(C)]
9474 pub struct ArrayOfVectorOfEventInTableWithReducedRightsStruct<'de> {
9475 pub t: crate::wire::ArrayOfVectorOfEventInTableWithReducedRights<'de>,
9476 }
9477
9478 static_assertions::const_assert_eq!(
9479 std::mem::size_of::<ArrayOfVectorOfEventInTableWithReducedRightsStruct<'_>>(),
9480 16
9481 );
9482 static_assertions::const_assert_eq!(
9483 std::mem::align_of::<ArrayOfVectorOfEventInTableWithReducedRightsStruct<'_>>(),
9484 8
9485 );
9486
9487 static_assertions::const_assert_eq!(
9488 std::mem::offset_of!(ArrayOfVectorOfEventInTableWithReducedRightsStruct<'_>, t),
9489 0
9490 );
9491
9492 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInTableWithReducedRightsStruct<'_> {
9493 type Constraint = ();
9494
9495 fn validate(
9496 _: ::fidl_next::Slot<'_, Self>,
9497 _: Self::Constraint,
9498 ) -> Result<(), ::fidl_next::ValidationError> {
9499 Ok(())
9500 }
9501 }
9502
9503 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static> {
9504 type Narrowed<'de> = ArrayOfVectorOfEventInTableWithReducedRightsStruct<'de>;
9505
9506 #[inline]
9507 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9508 ::fidl_next::munge! {
9509 let Self {
9510 t,
9511
9512 } = &mut *out_;
9513 }
9514
9515 ::fidl_next::Wire::zero_padding(t);
9516 }
9517 }
9518
9519 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9520 for ArrayOfVectorOfEventInTableWithReducedRightsStruct<'de>
9521 where
9522 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9523 ___D: ::fidl_next::Decoder<'de>,
9524 ___D: ::fidl_next::fuchsia::HandleDecoder,
9525 {
9526 fn decode(
9527 slot_: ::fidl_next::Slot<'_, Self>,
9528 decoder_: &mut ___D,
9529 _: (),
9530 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9531 ::fidl_next::munge! {
9532 let Self {
9533 mut t,
9534
9535 } = slot_;
9536 }
9537
9538 let _field = t.as_mut();
9539
9540 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
9541
9542 Ok(())
9543 }
9544 }
9545
9546 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInTableWithReducedRightsStruct<'de> {
9547 type Natural = crate::natural::ArrayOfVectorOfEventInTableWithReducedRightsStruct;
9548 }
9549
9550 #[repr(transparent)]
9552 pub struct ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
9553 pub(crate) raw: ::fidl_next::wire::Union,
9554 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
9555 }
9556
9557 impl<'de> Drop for ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
9558 fn drop(&mut self) {
9559 match self.raw.ordinal() {
9560 1 => {
9561 let _ = unsafe {
9562 self.raw.get().read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
9563 };
9564 }
9565
9566 _ => unsafe { ::core::hint::unreachable_unchecked() },
9567 }
9568 }
9569 }
9570
9571 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInUnionWithDefaultRights<'_> {
9572 type Constraint = ();
9573
9574 fn validate(
9575 _: ::fidl_next::Slot<'_, Self>,
9576 _: Self::Constraint,
9577 ) -> Result<(), ::fidl_next::ValidationError> {
9578 Ok(())
9579 }
9580 }
9581
9582 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInUnionWithDefaultRights<'static> {
9583 type Narrowed<'de> = ArrayOfVectorOfEventInUnionWithDefaultRights<'de>;
9584
9585 #[inline]
9586 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9587 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
9588 ::fidl_next::wire::Union::zero_padding(raw);
9589 }
9590 }
9591
9592 pub mod array_of_vector_of_event_in_union_with_default_rights {
9593 pub enum Ref<'de> {
9594 H(&'de [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]),
9595 }
9596
9597 pub enum Value<'de> {
9598 H([::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]),
9599 }
9600 }
9601
9602 impl<'de> ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
9603 pub fn as_ref(
9604 &self,
9605 ) -> crate::wire::array_of_vector_of_event_in_union_with_default_rights::Ref<'_> {
9606 match self.raw.ordinal() {
9607 1 => crate::wire::array_of_vector_of_event_in_union_with_default_rights::Ref::H(
9608 unsafe {
9609 self.raw.get().deref_unchecked::<[::fidl_next::wire::Vector<'_, ::fidl_next::wire::fuchsia::Event>; 1]>()
9610 },
9611 ),
9612
9613 _ => unsafe { ::core::hint::unreachable_unchecked() },
9614 }
9615 }
9616
9617 pub fn into_inner(
9618 self,
9619 ) -> crate::wire::array_of_vector_of_event_in_union_with_default_rights::Value<'de>
9620 {
9621 let this = ::core::mem::ManuallyDrop::new(self);
9622
9623 match this.raw.ordinal() {
9624 1 => crate::wire::array_of_vector_of_event_in_union_with_default_rights::Value::H(
9625 unsafe {
9626 this.raw.get().read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
9627 },
9628 ),
9629
9630 _ => unsafe { ::core::hint::unreachable_unchecked() },
9631 }
9632 }
9633 }
9634
9635 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9636 for ArrayOfVectorOfEventInUnionWithDefaultRights<'de>
9637 where
9638 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9639 ___D: ::fidl_next::Decoder<'de>,
9640 ___D: ::fidl_next::fuchsia::HandleDecoder,
9641 {
9642 fn decode(
9643 mut slot: ::fidl_next::Slot<'_, Self>,
9644 decoder: &mut ___D,
9645 _: (),
9646 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9647 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
9648 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
9649 1 => ::fidl_next::wire::Union::decode_as::<
9650 ___D,
9651 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9652 >(raw, decoder, (1, ()))?,
9653
9654 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
9655 }
9656
9657 Ok(())
9658 }
9659 }
9660
9661 impl<'de> ::core::fmt::Debug for ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
9662 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9663 match self.raw.ordinal() {
9664 1 => unsafe {
9665 self.raw.get().deref_unchecked::<
9666 [::fidl_next::wire::Vector<'_, ::fidl_next::wire::fuchsia::Event>; 1]
9667 >().fmt(f)
9668 },
9669 _ => unsafe { ::core::hint::unreachable_unchecked() },
9670 }
9671 }
9672 }
9673
9674 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
9675 type Natural = crate::natural::ArrayOfVectorOfEventInUnionWithDefaultRights;
9676 }
9677
9678 #[derive(Debug)]
9680 #[repr(C)]
9681 pub struct ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'de> {
9682 pub u: crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>,
9683 }
9684
9685 static_assertions::const_assert_eq!(
9686 std::mem::size_of::<ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'_>>(),
9687 16
9688 );
9689 static_assertions::const_assert_eq!(
9690 std::mem::align_of::<ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'_>>(),
9691 8
9692 );
9693
9694 static_assertions::const_assert_eq!(
9695 std::mem::offset_of!(ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'_>, u),
9696 0
9697 );
9698
9699 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'_> {
9700 type Constraint = ();
9701
9702 fn validate(
9703 _: ::fidl_next::Slot<'_, Self>,
9704 _: Self::Constraint,
9705 ) -> Result<(), ::fidl_next::ValidationError> {
9706 Ok(())
9707 }
9708 }
9709
9710 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static> {
9711 type Narrowed<'de> = ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'de>;
9712
9713 #[inline]
9714 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9715 ::fidl_next::munge! {
9716 let Self {
9717 u,
9718
9719 } = &mut *out_;
9720 }
9721
9722 ::fidl_next::Wire::zero_padding(u);
9723 }
9724 }
9725
9726 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9727 for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'de>
9728 where
9729 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9730 ___D: ::fidl_next::Decoder<'de>,
9731 ___D: ::fidl_next::fuchsia::HandleDecoder,
9732 {
9733 fn decode(
9734 slot_: ::fidl_next::Slot<'_, Self>,
9735 decoder_: &mut ___D,
9736 _: (),
9737 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9738 ::fidl_next::munge! {
9739 let Self {
9740 mut u,
9741
9742 } = slot_;
9743 }
9744
9745 let _field = u.as_mut();
9746
9747 ::fidl_next::Decode::decode(u.as_mut(), decoder_, ())?;
9748
9749 Ok(())
9750 }
9751 }
9752
9753 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'de> {
9754 type Natural = crate::natural::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct;
9755 }
9756
9757 #[repr(transparent)]
9759 pub struct ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
9760 pub(crate) raw: ::fidl_next::wire::Union,
9761 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
9762 }
9763
9764 impl<'de> Drop for ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
9765 fn drop(&mut self) {
9766 match self.raw.ordinal() {
9767 1 => {
9768 let _ = unsafe {
9769 self.raw.get().read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
9770 };
9771 }
9772
9773 _ => unsafe { ::core::hint::unreachable_unchecked() },
9774 }
9775 }
9776 }
9777
9778 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInUnionWithReducedRights<'_> {
9779 type Constraint = ();
9780
9781 fn validate(
9782 _: ::fidl_next::Slot<'_, Self>,
9783 _: Self::Constraint,
9784 ) -> Result<(), ::fidl_next::ValidationError> {
9785 Ok(())
9786 }
9787 }
9788
9789 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInUnionWithReducedRights<'static> {
9790 type Narrowed<'de> = ArrayOfVectorOfEventInUnionWithReducedRights<'de>;
9791
9792 #[inline]
9793 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9794 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
9795 ::fidl_next::wire::Union::zero_padding(raw);
9796 }
9797 }
9798
9799 pub mod array_of_vector_of_event_in_union_with_reduced_rights {
9800 pub enum Ref<'de> {
9801 H(&'de [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]),
9802 }
9803
9804 pub enum Value<'de> {
9805 H([::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]),
9806 }
9807 }
9808
9809 impl<'de> ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
9810 pub fn as_ref(
9811 &self,
9812 ) -> crate::wire::array_of_vector_of_event_in_union_with_reduced_rights::Ref<'_> {
9813 match self.raw.ordinal() {
9814 1 => crate::wire::array_of_vector_of_event_in_union_with_reduced_rights::Ref::H(
9815 unsafe {
9816 self.raw.get().deref_unchecked::<[::fidl_next::wire::Vector<'_, ::fidl_next::wire::fuchsia::Event>; 1]>()
9817 },
9818 ),
9819
9820 _ => unsafe { ::core::hint::unreachable_unchecked() },
9821 }
9822 }
9823
9824 pub fn into_inner(
9825 self,
9826 ) -> crate::wire::array_of_vector_of_event_in_union_with_reduced_rights::Value<'de>
9827 {
9828 let this = ::core::mem::ManuallyDrop::new(self);
9829
9830 match this.raw.ordinal() {
9831 1 => crate::wire::array_of_vector_of_event_in_union_with_reduced_rights::Value::H(
9832 unsafe {
9833 this.raw.get().read_unchecked::<[::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1]>()
9834 },
9835 ),
9836
9837 _ => unsafe { ::core::hint::unreachable_unchecked() },
9838 }
9839 }
9840 }
9841
9842 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9843 for ArrayOfVectorOfEventInUnionWithReducedRights<'de>
9844 where
9845 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9846 ___D: ::fidl_next::Decoder<'de>,
9847 ___D: ::fidl_next::fuchsia::HandleDecoder,
9848 {
9849 fn decode(
9850 mut slot: ::fidl_next::Slot<'_, Self>,
9851 decoder: &mut ___D,
9852 _: (),
9853 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9854 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
9855 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
9856 1 => ::fidl_next::wire::Union::decode_as::<
9857 ___D,
9858 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
9859 >(raw, decoder, (1, ()))?,
9860
9861 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
9862 }
9863
9864 Ok(())
9865 }
9866 }
9867
9868 impl<'de> ::core::fmt::Debug for ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
9869 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9870 match self.raw.ordinal() {
9871 1 => unsafe {
9872 self.raw.get().deref_unchecked::<
9873 [::fidl_next::wire::Vector<'_, ::fidl_next::wire::fuchsia::Event>; 1]
9874 >().fmt(f)
9875 },
9876 _ => unsafe { ::core::hint::unreachable_unchecked() },
9877 }
9878 }
9879 }
9880
9881 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
9882 type Natural = crate::natural::ArrayOfVectorOfEventInUnionWithReducedRights;
9883 }
9884
9885 #[derive(Debug)]
9887 #[repr(C)]
9888 pub struct ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'de> {
9889 pub u: crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'de>,
9890 }
9891
9892 static_assertions::const_assert_eq!(
9893 std::mem::size_of::<ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'_>>(),
9894 16
9895 );
9896 static_assertions::const_assert_eq!(
9897 std::mem::align_of::<ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'_>>(),
9898 8
9899 );
9900
9901 static_assertions::const_assert_eq!(
9902 std::mem::offset_of!(ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'_>, u),
9903 0
9904 );
9905
9906 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'_> {
9907 type Constraint = ();
9908
9909 fn validate(
9910 _: ::fidl_next::Slot<'_, Self>,
9911 _: Self::Constraint,
9912 ) -> Result<(), ::fidl_next::ValidationError> {
9913 Ok(())
9914 }
9915 }
9916
9917 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static> {
9918 type Narrowed<'de> = ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'de>;
9919
9920 #[inline]
9921 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9922 ::fidl_next::munge! {
9923 let Self {
9924 u,
9925
9926 } = &mut *out_;
9927 }
9928
9929 ::fidl_next::Wire::zero_padding(u);
9930 }
9931 }
9932
9933 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
9934 for ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'de>
9935 where
9936 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9937 ___D: ::fidl_next::Decoder<'de>,
9938 ___D: ::fidl_next::fuchsia::HandleDecoder,
9939 {
9940 fn decode(
9941 slot_: ::fidl_next::Slot<'_, Self>,
9942 decoder_: &mut ___D,
9943 _: (),
9944 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9945 ::fidl_next::munge! {
9946 let Self {
9947 mut u,
9948
9949 } = slot_;
9950 }
9951
9952 let _field = u.as_mut();
9953
9954 ::fidl_next::Decode::decode(u.as_mut(), decoder_, ())?;
9955
9956 Ok(())
9957 }
9958 }
9959
9960 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'de> {
9961 type Natural = crate::natural::ArrayOfVectorOfEventInUnionWithReducedRightsStruct;
9962 }
9963
9964 #[derive(Debug)]
9966 #[repr(C)]
9967 pub struct Bounded32NonnullableVectorOfHandles<'de> {
9968 pub vh0: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
9969 }
9970
9971 static_assertions::const_assert_eq!(
9972 std::mem::size_of::<Bounded32NonnullableVectorOfHandles<'_>>(),
9973 16
9974 );
9975 static_assertions::const_assert_eq!(
9976 std::mem::align_of::<Bounded32NonnullableVectorOfHandles<'_>>(),
9977 8
9978 );
9979
9980 static_assertions::const_assert_eq!(
9981 std::mem::offset_of!(Bounded32NonnullableVectorOfHandles<'_>, vh0),
9982 0
9983 );
9984
9985 impl ::fidl_next::Constrained for Bounded32NonnullableVectorOfHandles<'_> {
9986 type Constraint = ();
9987
9988 fn validate(
9989 _: ::fidl_next::Slot<'_, Self>,
9990 _: Self::Constraint,
9991 ) -> Result<(), ::fidl_next::ValidationError> {
9992 Ok(())
9993 }
9994 }
9995
9996 unsafe impl ::fidl_next::Wire for Bounded32NonnullableVectorOfHandles<'static> {
9997 type Narrowed<'de> = Bounded32NonnullableVectorOfHandles<'de>;
9998
9999 #[inline]
10000 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10001 ::fidl_next::munge! {
10002 let Self {
10003 vh0,
10004
10005 } = &mut *out_;
10006 }
10007
10008 ::fidl_next::Wire::zero_padding(vh0);
10009 }
10010 }
10011
10012 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Bounded32NonnullableVectorOfHandles<'de>
10013 where
10014 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10015 ___D: ::fidl_next::Decoder<'de>,
10016 ___D: ::fidl_next::fuchsia::HandleDecoder,
10017 {
10018 fn decode(
10019 slot_: ::fidl_next::Slot<'_, Self>,
10020 decoder_: &mut ___D,
10021 _: (),
10022 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10023 ::fidl_next::munge! {
10024 let Self {
10025 mut vh0,
10026
10027 } = slot_;
10028 }
10029
10030 let _field = vh0.as_mut();
10031 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10032 ::fidl_next::Decode::decode(vh0.as_mut(), decoder_, (32, ()))?;
10033
10034 let vh0 = unsafe { vh0.deref_unchecked() };
10035
10036 if vh0.len() > 32 {
10037 return Err(::fidl_next::DecodeError::VectorTooLong {
10038 size: vh0.len() as u64,
10039 limit: 32,
10040 });
10041 }
10042
10043 Ok(())
10044 }
10045 }
10046
10047 impl<'de> ::fidl_next::IntoNatural for Bounded32NonnullableVectorOfHandles<'de> {
10048 type Natural = crate::natural::Bounded32NonnullableVectorOfHandles;
10049 }
10050
10051 #[derive(Debug)]
10053 #[repr(C)]
10054 pub struct Bounded32NullableVectorOfHandles<'de> {
10055 pub vh0: ::fidl_next::wire::OptionalVector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
10056 }
10057
10058 static_assertions::const_assert_eq!(
10059 std::mem::size_of::<Bounded32NullableVectorOfHandles<'_>>(),
10060 16
10061 );
10062 static_assertions::const_assert_eq!(
10063 std::mem::align_of::<Bounded32NullableVectorOfHandles<'_>>(),
10064 8
10065 );
10066
10067 static_assertions::const_assert_eq!(
10068 std::mem::offset_of!(Bounded32NullableVectorOfHandles<'_>, vh0),
10069 0
10070 );
10071
10072 impl ::fidl_next::Constrained for Bounded32NullableVectorOfHandles<'_> {
10073 type Constraint = ();
10074
10075 fn validate(
10076 _: ::fidl_next::Slot<'_, Self>,
10077 _: Self::Constraint,
10078 ) -> Result<(), ::fidl_next::ValidationError> {
10079 Ok(())
10080 }
10081 }
10082
10083 unsafe impl ::fidl_next::Wire for Bounded32NullableVectorOfHandles<'static> {
10084 type Narrowed<'de> = Bounded32NullableVectorOfHandles<'de>;
10085
10086 #[inline]
10087 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10088 ::fidl_next::munge! {
10089 let Self {
10090 vh0,
10091
10092 } = &mut *out_;
10093 }
10094
10095 ::fidl_next::Wire::zero_padding(vh0);
10096 }
10097 }
10098
10099 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Bounded32NullableVectorOfHandles<'de>
10100 where
10101 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10102 ___D: ::fidl_next::Decoder<'de>,
10103 ___D: ::fidl_next::fuchsia::HandleDecoder,
10104 {
10105 fn decode(
10106 slot_: ::fidl_next::Slot<'_, Self>,
10107 decoder_: &mut ___D,
10108 _: (),
10109 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10110 ::fidl_next::munge! {
10111 let Self {
10112 mut vh0,
10113
10114 } = slot_;
10115 }
10116
10117 let _field = vh0.as_mut();
10118 ::fidl_next::Constrained::validate(_field, (32, ()))?;
10119 ::fidl_next::Decode::decode(vh0.as_mut(), decoder_, (32, ()))?;
10120
10121 let vh0 = unsafe { vh0.deref_unchecked() };
10122
10123 if let Some(vh0) = vh0.as_ref() {
10124 if vh0.len() > 32 {
10125 return Err(::fidl_next::DecodeError::VectorTooLong {
10126 size: vh0.len() as u64,
10127 limit: 32,
10128 });
10129 }
10130 }
10131
10132 Ok(())
10133 }
10134 }
10135
10136 impl<'de> ::fidl_next::IntoNatural for Bounded32NullableVectorOfHandles<'de> {
10137 type Natural = crate::natural::Bounded32NullableVectorOfHandles;
10138 }
10139
10140 #[derive(Debug)]
10142 #[repr(C)]
10143 pub struct BoxOfSingleHandle<'de> {
10144 pub b: ::fidl_next::wire::Box<'de, crate::wire::SingleHandle>,
10145 }
10146
10147 static_assertions::const_assert_eq!(std::mem::size_of::<BoxOfSingleHandle<'_>>(), 8);
10148 static_assertions::const_assert_eq!(std::mem::align_of::<BoxOfSingleHandle<'_>>(), 8);
10149
10150 static_assertions::const_assert_eq!(std::mem::offset_of!(BoxOfSingleHandle<'_>, b), 0);
10151
10152 impl ::fidl_next::Constrained for BoxOfSingleHandle<'_> {
10153 type Constraint = ();
10154
10155 fn validate(
10156 _: ::fidl_next::Slot<'_, Self>,
10157 _: Self::Constraint,
10158 ) -> Result<(), ::fidl_next::ValidationError> {
10159 Ok(())
10160 }
10161 }
10162
10163 unsafe impl ::fidl_next::Wire for BoxOfSingleHandle<'static> {
10164 type Narrowed<'de> = BoxOfSingleHandle<'de>;
10165
10166 #[inline]
10167 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10168 ::fidl_next::munge! {
10169 let Self {
10170 b,
10171
10172 } = &mut *out_;
10173 }
10174
10175 ::fidl_next::Wire::zero_padding(b);
10176 }
10177 }
10178
10179 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BoxOfSingleHandle<'de>
10180 where
10181 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10182 ___D: ::fidl_next::Decoder<'de>,
10183 ___D: ::fidl_next::fuchsia::HandleDecoder,
10184 {
10185 fn decode(
10186 slot_: ::fidl_next::Slot<'_, Self>,
10187 decoder_: &mut ___D,
10188 _: (),
10189 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10190 ::fidl_next::munge! {
10191 let Self {
10192 mut b,
10193
10194 } = slot_;
10195 }
10196
10197 let _field = b.as_mut();
10198
10199 ::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
10200
10201 Ok(())
10202 }
10203 }
10204
10205 impl<'de> ::fidl_next::IntoNatural for BoxOfSingleHandle<'de> {
10206 type Natural = crate::natural::BoxOfSingleHandle;
10207 }
10208
10209 #[derive(Debug)]
10211 #[repr(C)]
10212 pub struct BoxOfSingleOptionalHandle<'de> {
10213 pub b: ::fidl_next::wire::Box<'de, crate::wire::SingleOptionalHandle>,
10214 }
10215
10216 static_assertions::const_assert_eq!(std::mem::size_of::<BoxOfSingleOptionalHandle<'_>>(), 8);
10217 static_assertions::const_assert_eq!(std::mem::align_of::<BoxOfSingleOptionalHandle<'_>>(), 8);
10218
10219 static_assertions::const_assert_eq!(std::mem::offset_of!(BoxOfSingleOptionalHandle<'_>, b), 0);
10220
10221 impl ::fidl_next::Constrained for BoxOfSingleOptionalHandle<'_> {
10222 type Constraint = ();
10223
10224 fn validate(
10225 _: ::fidl_next::Slot<'_, Self>,
10226 _: Self::Constraint,
10227 ) -> Result<(), ::fidl_next::ValidationError> {
10228 Ok(())
10229 }
10230 }
10231
10232 unsafe impl ::fidl_next::Wire for BoxOfSingleOptionalHandle<'static> {
10233 type Narrowed<'de> = BoxOfSingleOptionalHandle<'de>;
10234
10235 #[inline]
10236 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10237 ::fidl_next::munge! {
10238 let Self {
10239 b,
10240
10241 } = &mut *out_;
10242 }
10243
10244 ::fidl_next::Wire::zero_padding(b);
10245 }
10246 }
10247
10248 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BoxOfSingleOptionalHandle<'de>
10249 where
10250 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10251 ___D: ::fidl_next::Decoder<'de>,
10252 ___D: ::fidl_next::fuchsia::HandleDecoder,
10253 {
10254 fn decode(
10255 slot_: ::fidl_next::Slot<'_, Self>,
10256 decoder_: &mut ___D,
10257 _: (),
10258 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10259 ::fidl_next::munge! {
10260 let Self {
10261 mut b,
10262
10263 } = slot_;
10264 }
10265
10266 let _field = b.as_mut();
10267
10268 ::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
10269
10270 Ok(())
10271 }
10272 }
10273
10274 impl<'de> ::fidl_next::IntoNatural for BoxOfSingleOptionalHandle<'de> {
10275 type Natural = crate::natural::BoxOfSingleOptionalHandle;
10276 }
10277
10278 #[derive(Debug)]
10280 #[repr(C)]
10281 pub struct LaunchInfo<'de> {
10282 pub url: ::fidl_next::wire::String<'de>,
10283
10284 pub arguments: ::fidl_next::wire::OptionalVector<'de, ::fidl_next::wire::String<'de>>,
10285
10286 pub out: ::fidl_next::wire::Box<'de, crate::wire::TransformerEmptyStruct>,
10287
10288 pub err: ::fidl_next::wire::Box<'de, crate::wire::TransformerEmptyStruct>,
10289
10290 pub directory_request: ::fidl_next::wire::fuchsia::OptionalChannel,
10291
10292 pub flat_namespace: ::fidl_next::wire::Box<'de, crate::wire::TransformerEmptyStruct>,
10293
10294 pub additional_services: ::fidl_next::wire::Box<'de, crate::wire::TransformerEmptyStruct>,
10295 }
10296
10297 static_assertions::const_assert_eq!(std::mem::size_of::<LaunchInfo<'_>>(), 72);
10298 static_assertions::const_assert_eq!(std::mem::align_of::<LaunchInfo<'_>>(), 8);
10299
10300 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, url), 0);
10301
10302 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, arguments), 16);
10303
10304 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, out), 32);
10305
10306 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, err), 40);
10307
10308 static_assertions::const_assert_eq!(
10309 std::mem::offset_of!(LaunchInfo<'_>, directory_request),
10310 48
10311 );
10312
10313 static_assertions::const_assert_eq!(std::mem::offset_of!(LaunchInfo<'_>, flat_namespace), 56);
10314
10315 static_assertions::const_assert_eq!(
10316 std::mem::offset_of!(LaunchInfo<'_>, additional_services),
10317 64
10318 );
10319
10320 impl ::fidl_next::Constrained for LaunchInfo<'_> {
10321 type Constraint = ();
10322
10323 fn validate(
10324 _: ::fidl_next::Slot<'_, Self>,
10325 _: Self::Constraint,
10326 ) -> Result<(), ::fidl_next::ValidationError> {
10327 Ok(())
10328 }
10329 }
10330
10331 unsafe impl ::fidl_next::Wire for LaunchInfo<'static> {
10332 type Narrowed<'de> = LaunchInfo<'de>;
10333
10334 #[inline]
10335 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10336 ::fidl_next::munge! {
10337 let Self {
10338 url,
10339 arguments,
10340 out,
10341 err,
10342 directory_request,
10343 flat_namespace,
10344 additional_services,
10345
10346 } = &mut *out_;
10347 }
10348
10349 ::fidl_next::Wire::zero_padding(url);
10350
10351 ::fidl_next::Wire::zero_padding(arguments);
10352
10353 ::fidl_next::Wire::zero_padding(out);
10354
10355 ::fidl_next::Wire::zero_padding(err);
10356
10357 ::fidl_next::Wire::zero_padding(directory_request);
10358
10359 ::fidl_next::Wire::zero_padding(flat_namespace);
10360
10361 ::fidl_next::Wire::zero_padding(additional_services);
10362
10363 unsafe {
10364 out_.as_mut_ptr().cast::<u8>().add(52).write_bytes(0, 4);
10365 }
10366 }
10367 }
10368
10369 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LaunchInfo<'de>
10370 where
10371 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10372 ___D: ::fidl_next::Decoder<'de>,
10373 ___D: ::fidl_next::fuchsia::HandleDecoder,
10374 {
10375 fn decode(
10376 slot_: ::fidl_next::Slot<'_, Self>,
10377 decoder_: &mut ___D,
10378 _: (),
10379 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10380 if slot_.as_bytes()[52..56] != [0u8; 4] {
10381 return Err(::fidl_next::DecodeError::InvalidPadding);
10382 }
10383
10384 ::fidl_next::munge! {
10385 let Self {
10386 mut url,
10387 mut arguments,
10388 mut out,
10389 mut err,
10390 mut directory_request,
10391 mut flat_namespace,
10392 mut additional_services,
10393
10394 } = slot_;
10395 }
10396
10397 let _field = url.as_mut();
10398 ::fidl_next::Constrained::validate(_field, 200)?;
10399 ::fidl_next::Decode::decode(url.as_mut(), decoder_, 200)?;
10400
10401 let url = unsafe { url.deref_unchecked() };
10402
10403 if url.len() > 200 {
10404 return Err(::fidl_next::DecodeError::VectorTooLong {
10405 size: url.len() as u64,
10406 limit: 200,
10407 });
10408 }
10409
10410 let _field = arguments.as_mut();
10411 ::fidl_next::Constrained::validate(_field, (4294967295, 4294967295))?;
10412 ::fidl_next::Decode::decode(arguments.as_mut(), decoder_, (4294967295, 4294967295))?;
10413
10414 let _field = out.as_mut();
10415
10416 ::fidl_next::Decode::decode(out.as_mut(), decoder_, ())?;
10417
10418 let _field = err.as_mut();
10419
10420 ::fidl_next::Decode::decode(err.as_mut(), decoder_, ())?;
10421
10422 let _field = directory_request.as_mut();
10423
10424 ::fidl_next::Decode::decode(directory_request.as_mut(), decoder_, ())?;
10425
10426 let _field = flat_namespace.as_mut();
10427
10428 ::fidl_next::Decode::decode(flat_namespace.as_mut(), decoder_, ())?;
10429
10430 let _field = additional_services.as_mut();
10431
10432 ::fidl_next::Decode::decode(additional_services.as_mut(), decoder_, ())?;
10433
10434 Ok(())
10435 }
10436 }
10437
10438 impl<'de> ::fidl_next::IntoNatural for LaunchInfo<'de> {
10439 type Natural = crate::natural::LaunchInfo;
10440 }
10441
10442 #[derive(Debug)]
10444 #[repr(C)]
10445 pub struct CreateComponentRequest<'de> {
10446 pub launch_info: crate::wire::LaunchInfo<'de>,
10447
10448 pub controller: ::fidl_next::ServerEnd<
10449 crate::ComponentController,
10450 ::fidl_next::wire::fuchsia::OptionalChannel,
10451 >,
10452 }
10453
10454 static_assertions::const_assert_eq!(std::mem::size_of::<CreateComponentRequest<'_>>(), 80);
10455 static_assertions::const_assert_eq!(std::mem::align_of::<CreateComponentRequest<'_>>(), 8);
10456
10457 static_assertions::const_assert_eq!(
10458 std::mem::offset_of!(CreateComponentRequest<'_>, launch_info),
10459 0
10460 );
10461
10462 static_assertions::const_assert_eq!(
10463 std::mem::offset_of!(CreateComponentRequest<'_>, controller),
10464 72
10465 );
10466
10467 impl ::fidl_next::Constrained for CreateComponentRequest<'_> {
10468 type Constraint = ();
10469
10470 fn validate(
10471 _: ::fidl_next::Slot<'_, Self>,
10472 _: Self::Constraint,
10473 ) -> Result<(), ::fidl_next::ValidationError> {
10474 Ok(())
10475 }
10476 }
10477
10478 unsafe impl ::fidl_next::Wire for CreateComponentRequest<'static> {
10479 type Narrowed<'de> = CreateComponentRequest<'de>;
10480
10481 #[inline]
10482 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10483 ::fidl_next::munge! {
10484 let Self {
10485 launch_info,
10486 controller,
10487
10488 } = &mut *out_;
10489 }
10490
10491 ::fidl_next::Wire::zero_padding(launch_info);
10492
10493 ::fidl_next::Wire::zero_padding(controller);
10494
10495 unsafe {
10496 out_.as_mut_ptr().cast::<u8>().add(76).write_bytes(0, 4);
10497 }
10498 }
10499 }
10500
10501 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CreateComponentRequest<'de>
10502 where
10503 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10504 ___D: ::fidl_next::Decoder<'de>,
10505 ___D: ::fidl_next::fuchsia::HandleDecoder,
10506 {
10507 fn decode(
10508 slot_: ::fidl_next::Slot<'_, Self>,
10509 decoder_: &mut ___D,
10510 _: (),
10511 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10512 if slot_.as_bytes()[76..80] != [0u8; 4] {
10513 return Err(::fidl_next::DecodeError::InvalidPadding);
10514 }
10515
10516 ::fidl_next::munge! {
10517 let Self {
10518 mut launch_info,
10519 mut controller,
10520
10521 } = slot_;
10522 }
10523
10524 let _field = launch_info.as_mut();
10525
10526 ::fidl_next::Decode::decode(launch_info.as_mut(), decoder_, ())?;
10527
10528 let _field = controller.as_mut();
10529
10530 ::fidl_next::Decode::decode(controller.as_mut(), decoder_, ())?;
10531
10532 Ok(())
10533 }
10534 }
10535
10536 impl<'de> ::fidl_next::IntoNatural for CreateComponentRequest<'de> {
10537 type Natural = crate::natural::CreateComponentRequest;
10538 }
10539
10540 #[repr(C)]
10542 pub struct EmptyResourceTable<'de> {
10543 pub(crate) table: ::fidl_next::wire::Table<'de>,
10544 }
10545
10546 impl<'de> Drop for EmptyResourceTable<'de> {
10547 fn drop(&mut self) {}
10548 }
10549
10550 impl ::fidl_next::Constrained for EmptyResourceTable<'_> {
10551 type Constraint = ();
10552
10553 fn validate(
10554 _: ::fidl_next::Slot<'_, Self>,
10555 _: Self::Constraint,
10556 ) -> Result<(), ::fidl_next::ValidationError> {
10557 Ok(())
10558 }
10559 }
10560
10561 unsafe impl ::fidl_next::Wire for EmptyResourceTable<'static> {
10562 type Narrowed<'de> = EmptyResourceTable<'de>;
10563
10564 #[inline]
10565 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10566 ::fidl_next::munge!(let Self { table } = out);
10567 ::fidl_next::wire::Table::zero_padding(table);
10568 }
10569 }
10570
10571 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EmptyResourceTable<'de>
10572 where
10573 ___D: ::fidl_next::Decoder<'de> + ?Sized,
10574 ___D: ::fidl_next::fuchsia::HandleDecoder,
10575 {
10576 fn decode(
10577 slot: ::fidl_next::Slot<'_, Self>,
10578 decoder: &mut ___D,
10579 _: (),
10580 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10581 ::fidl_next::munge!(let Self { table } = slot);
10582
10583 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
10584 match ordinal {
10585 0 => unsafe { ::core::hint::unreachable_unchecked() },
10586
10587 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
10588 }
10589 })
10590 }
10591 }
10592
10593 impl<'de> EmptyResourceTable<'de> {}
10594
10595 impl<'de> ::core::fmt::Debug for EmptyResourceTable<'de> {
10596 fn fmt(
10597 &self,
10598 f: &mut ::core::fmt::Formatter<'_>,
10599 ) -> ::core::result::Result<(), ::core::fmt::Error> {
10600 f.debug_struct("EmptyResourceTable").finish()
10601 }
10602 }
10603
10604 impl<'de> ::fidl_next::IntoNatural for EmptyResourceTable<'de> {
10605 type Natural = crate::natural::EmptyResourceTable;
10606 }
10607
10608 #[derive(Debug)]
10610 #[repr(C)]
10611 pub struct EmptyResourceTableStruct<'de> {
10612 pub table: crate::wire::EmptyResourceTable<'de>,
10613 }
10614
10615 static_assertions::const_assert_eq!(std::mem::size_of::<EmptyResourceTableStruct<'_>>(), 16);
10616 static_assertions::const_assert_eq!(std::mem::align_of::<EmptyResourceTableStruct<'_>>(), 8);
10617
10618 static_assertions::const_assert_eq!(
10619 std::mem::offset_of!(EmptyResourceTableStruct<'_>, table),
10620 0
10621 );
10622
10623 impl ::fidl_next::Constrained for EmptyResourceTableStruct<'_> {
10624 type Constraint = ();
10625
10626 fn validate(
10627 _: ::fidl_next::Slot<'_, Self>,
10628 _: Self::Constraint,
10629 ) -> Result<(), ::fidl_next::ValidationError> {
10630 Ok(())
10631 }
10632 }
10633
10634 unsafe impl ::fidl_next::Wire for EmptyResourceTableStruct<'static> {
10635 type Narrowed<'de> = EmptyResourceTableStruct<'de>;
10636
10637 #[inline]
10638 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10639 ::fidl_next::munge! {
10640 let Self {
10641 table,
10642
10643 } = &mut *out_;
10644 }
10645
10646 ::fidl_next::Wire::zero_padding(table);
10647 }
10648 }
10649
10650 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EmptyResourceTableStruct<'de>
10651 where
10652 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10653 ___D: ::fidl_next::Decoder<'de>,
10654 ___D: ::fidl_next::fuchsia::HandleDecoder,
10655 {
10656 fn decode(
10657 slot_: ::fidl_next::Slot<'_, Self>,
10658 decoder_: &mut ___D,
10659 _: (),
10660 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10661 ::fidl_next::munge! {
10662 let Self {
10663 mut table,
10664
10665 } = slot_;
10666 }
10667
10668 let _field = table.as_mut();
10669
10670 ::fidl_next::Decode::decode(table.as_mut(), decoder_, ())?;
10671
10672 Ok(())
10673 }
10674 }
10675
10676 impl<'de> ::fidl_next::IntoNatural for EmptyResourceTableStruct<'de> {
10677 type Natural = crate::natural::EmptyResourceTableStruct;
10678 }
10679
10680 #[repr(transparent)]
10682 pub struct EnvelopeInliningTestUnion<'de> {
10683 pub(crate) raw: ::fidl_next::wire::Union,
10684 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
10685 }
10686
10687 impl<'de> Drop for EnvelopeInliningTestUnion<'de> {
10688 fn drop(&mut self) {
10689 match self.raw.ordinal() {
10690 1 => {
10691 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint32>() };
10692 }
10693
10694 2 => {
10695 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint64>() };
10696 }
10697
10698 3 => {
10699 let _ = unsafe {
10700 self.raw
10701 .get()
10702 .read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
10703 };
10704 }
10705
10706 _ => (),
10707 }
10708 }
10709 }
10710
10711 impl ::fidl_next::Constrained for EnvelopeInliningTestUnion<'_> {
10712 type Constraint = ();
10713
10714 fn validate(
10715 _: ::fidl_next::Slot<'_, Self>,
10716 _: Self::Constraint,
10717 ) -> Result<(), ::fidl_next::ValidationError> {
10718 Ok(())
10719 }
10720 }
10721
10722 unsafe impl ::fidl_next::Wire for EnvelopeInliningTestUnion<'static> {
10723 type Narrowed<'de> = EnvelopeInliningTestUnion<'de>;
10724
10725 #[inline]
10726 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10727 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
10728 ::fidl_next::wire::Union::zero_padding(raw);
10729 }
10730 }
10731
10732 pub mod envelope_inlining_test_union {
10733 pub enum Ref<'de> {
10734 Small(&'de ::fidl_next::wire::Uint32),
10735
10736 Large(&'de ::fidl_next::wire::Uint64),
10737
10738 Handle(&'de ::fidl_next::wire::fuchsia::NullableHandle),
10739
10740 UnknownOrdinal_(u64),
10741 }
10742
10743 pub enum Value {
10744 Small(::fidl_next::wire::Uint32),
10745
10746 Large(::fidl_next::wire::Uint64),
10747
10748 Handle(::fidl_next::wire::fuchsia::NullableHandle),
10749
10750 UnknownOrdinal_(u64),
10751 }
10752 }
10753
10754 impl<'de> EnvelopeInliningTestUnion<'de> {
10755 pub fn as_ref(&self) -> crate::wire::envelope_inlining_test_union::Ref<'_> {
10756 match self.raw.ordinal() {
10757 1 => crate::wire::envelope_inlining_test_union::Ref::Small(unsafe {
10758 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>()
10759 }),
10760
10761 2 => crate::wire::envelope_inlining_test_union::Ref::Large(unsafe {
10762 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>()
10763 }),
10764
10765 3 => crate::wire::envelope_inlining_test_union::Ref::Handle(unsafe {
10766 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
10767 }),
10768
10769 unknown => crate::wire::envelope_inlining_test_union::Ref::UnknownOrdinal_(unknown),
10770 }
10771 }
10772
10773 pub fn into_inner(self) -> crate::wire::envelope_inlining_test_union::Value {
10774 let this = ::core::mem::ManuallyDrop::new(self);
10775
10776 match this.raw.ordinal() {
10777 1 => crate::wire::envelope_inlining_test_union::Value::Small(unsafe {
10778 this.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
10779 }),
10780
10781 2 => crate::wire::envelope_inlining_test_union::Value::Large(unsafe {
10782 this.raw.get().read_unchecked::<::fidl_next::wire::Uint64>()
10783 }),
10784
10785 3 => crate::wire::envelope_inlining_test_union::Value::Handle(unsafe {
10786 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
10787 }),
10788
10789 unknown => {
10790 crate::wire::envelope_inlining_test_union::Value::UnknownOrdinal_(unknown)
10791 }
10792 }
10793 }
10794 }
10795
10796 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EnvelopeInliningTestUnion<'de>
10797 where
10798 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10799 ___D: ::fidl_next::Decoder<'de>,
10800 ___D: ::fidl_next::fuchsia::HandleDecoder,
10801 {
10802 fn decode(
10803 mut slot: ::fidl_next::Slot<'_, Self>,
10804 decoder: &mut ___D,
10805 _: (),
10806 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10807 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
10808 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
10809 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
10810 raw,
10811 decoder,
10812 (),
10813 )?,
10814
10815 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
10816 raw,
10817 decoder,
10818 (),
10819 )?,
10820
10821 3 => ::fidl_next::wire::Union::decode_as::<
10822 ___D,
10823 ::fidl_next::wire::fuchsia::NullableHandle,
10824 >(raw, decoder, ())?,
10825
10826 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
10827 }
10828
10829 Ok(())
10830 }
10831 }
10832
10833 impl<'de> ::core::fmt::Debug for EnvelopeInliningTestUnion<'de> {
10834 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
10835 match self.raw.ordinal() {
10836 1 => unsafe {
10837 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>().fmt(f)
10838 },
10839 2 => unsafe {
10840 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>().fmt(f)
10841 },
10842 3 => unsafe {
10843 self.raw
10844 .get()
10845 .deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
10846 .fmt(f)
10847 },
10848 _ => unsafe { ::core::hint::unreachable_unchecked() },
10849 }
10850 }
10851 }
10852
10853 impl<'de> ::fidl_next::IntoNatural for EnvelopeInliningTestUnion<'de> {
10854 type Natural = crate::natural::EnvelopeInliningTestUnion;
10855 }
10856
10857 #[derive(Debug)]
10859 #[repr(C)]
10860 pub struct EnvelopeInliningTestUnionStruct<'de> {
10861 pub u: crate::wire::EnvelopeInliningTestUnion<'de>,
10862 }
10863
10864 static_assertions::const_assert_eq!(
10865 std::mem::size_of::<EnvelopeInliningTestUnionStruct<'_>>(),
10866 16
10867 );
10868 static_assertions::const_assert_eq!(
10869 std::mem::align_of::<EnvelopeInliningTestUnionStruct<'_>>(),
10870 8
10871 );
10872
10873 static_assertions::const_assert_eq!(
10874 std::mem::offset_of!(EnvelopeInliningTestUnionStruct<'_>, u),
10875 0
10876 );
10877
10878 impl ::fidl_next::Constrained for EnvelopeInliningTestUnionStruct<'_> {
10879 type Constraint = ();
10880
10881 fn validate(
10882 _: ::fidl_next::Slot<'_, Self>,
10883 _: Self::Constraint,
10884 ) -> Result<(), ::fidl_next::ValidationError> {
10885 Ok(())
10886 }
10887 }
10888
10889 unsafe impl ::fidl_next::Wire for EnvelopeInliningTestUnionStruct<'static> {
10890 type Narrowed<'de> = EnvelopeInliningTestUnionStruct<'de>;
10891
10892 #[inline]
10893 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10894 ::fidl_next::munge! {
10895 let Self {
10896 u,
10897
10898 } = &mut *out_;
10899 }
10900
10901 ::fidl_next::Wire::zero_padding(u);
10902 }
10903 }
10904
10905 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EnvelopeInliningTestUnionStruct<'de>
10906 where
10907 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10908 ___D: ::fidl_next::Decoder<'de>,
10909 ___D: ::fidl_next::fuchsia::HandleDecoder,
10910 {
10911 fn decode(
10912 slot_: ::fidl_next::Slot<'_, Self>,
10913 decoder_: &mut ___D,
10914 _: (),
10915 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10916 ::fidl_next::munge! {
10917 let Self {
10918 mut u,
10919
10920 } = slot_;
10921 }
10922
10923 let _field = u.as_mut();
10924
10925 ::fidl_next::Decode::decode(u.as_mut(), decoder_, ())?;
10926
10927 Ok(())
10928 }
10929 }
10930
10931 impl<'de> ::fidl_next::IntoNatural for EnvelopeInliningTestUnionStruct<'de> {
10932 type Natural = crate::natural::EnvelopeInliningTestUnionStruct;
10933 }
10934
10935 #[derive(Debug)]
10937 #[repr(C)]
10938 pub struct EventWithDefaultRights {
10939 pub h: ::fidl_next::wire::fuchsia::Event,
10940 }
10941
10942 static_assertions::const_assert_eq!(std::mem::size_of::<EventWithDefaultRights>(), 4);
10943 static_assertions::const_assert_eq!(std::mem::align_of::<EventWithDefaultRights>(), 4);
10944
10945 static_assertions::const_assert_eq!(std::mem::offset_of!(EventWithDefaultRights, h), 0);
10946
10947 impl ::fidl_next::Constrained for EventWithDefaultRights {
10948 type Constraint = ();
10949
10950 fn validate(
10951 _: ::fidl_next::Slot<'_, Self>,
10952 _: Self::Constraint,
10953 ) -> Result<(), ::fidl_next::ValidationError> {
10954 Ok(())
10955 }
10956 }
10957
10958 unsafe impl ::fidl_next::Wire for EventWithDefaultRights {
10959 type Narrowed<'de> = EventWithDefaultRights;
10960
10961 #[inline]
10962 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10963 ::fidl_next::munge! {
10964 let Self {
10965 h,
10966
10967 } = &mut *out_;
10968 }
10969
10970 ::fidl_next::Wire::zero_padding(h);
10971 }
10972 }
10973
10974 unsafe impl<___D> ::fidl_next::Decode<___D> for EventWithDefaultRights
10975 where
10976 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10977 ___D: ::fidl_next::fuchsia::HandleDecoder,
10978 {
10979 fn decode(
10980 slot_: ::fidl_next::Slot<'_, Self>,
10981 decoder_: &mut ___D,
10982 _: (),
10983 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10984 ::fidl_next::munge! {
10985 let Self {
10986 mut h,
10987
10988 } = slot_;
10989 }
10990
10991 let _field = h.as_mut();
10992
10993 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
10994
10995 Ok(())
10996 }
10997 }
10998
10999 impl ::fidl_next::IntoNatural for EventWithDefaultRights {
11000 type Natural = crate::natural::EventWithDefaultRights;
11001 }
11002
11003 #[derive(Debug)]
11005 #[repr(C)]
11006 pub struct EventWithReducedRights {
11007 pub h: ::fidl_next::wire::fuchsia::Event,
11008 }
11009
11010 static_assertions::const_assert_eq!(std::mem::size_of::<EventWithReducedRights>(), 4);
11011 static_assertions::const_assert_eq!(std::mem::align_of::<EventWithReducedRights>(), 4);
11012
11013 static_assertions::const_assert_eq!(std::mem::offset_of!(EventWithReducedRights, h), 0);
11014
11015 impl ::fidl_next::Constrained for EventWithReducedRights {
11016 type Constraint = ();
11017
11018 fn validate(
11019 _: ::fidl_next::Slot<'_, Self>,
11020 _: Self::Constraint,
11021 ) -> Result<(), ::fidl_next::ValidationError> {
11022 Ok(())
11023 }
11024 }
11025
11026 unsafe impl ::fidl_next::Wire for EventWithReducedRights {
11027 type Narrowed<'de> = EventWithReducedRights;
11028
11029 #[inline]
11030 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11031 ::fidl_next::munge! {
11032 let Self {
11033 h,
11034
11035 } = &mut *out_;
11036 }
11037
11038 ::fidl_next::Wire::zero_padding(h);
11039 }
11040 }
11041
11042 unsafe impl<___D> ::fidl_next::Decode<___D> for EventWithReducedRights
11043 where
11044 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11045 ___D: ::fidl_next::fuchsia::HandleDecoder,
11046 {
11047 fn decode(
11048 slot_: ::fidl_next::Slot<'_, Self>,
11049 decoder_: &mut ___D,
11050 _: (),
11051 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11052 ::fidl_next::munge! {
11053 let Self {
11054 mut h,
11055
11056 } = slot_;
11057 }
11058
11059 let _field = h.as_mut();
11060
11061 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
11062
11063 Ok(())
11064 }
11065 }
11066
11067 impl ::fidl_next::IntoNatural for EventWithReducedRights {
11068 type Natural = crate::natural::EventWithReducedRights;
11069 }
11070
11071 #[derive(Debug)]
11073 #[repr(C)]
11074 pub struct FidlvizDemo<'de> {
11075 pub f1: u8,
11076
11077 pub f2: i8,
11078
11079 pub f3: ::fidl_next::wire::Uint16,
11080
11081 pub f4: ::fidl_next::wire::Uint32,
11082
11083 pub f5: ::fidl_next::wire::Uint64,
11084
11085 pub f6: u8,
11086
11087 pub f7: u8,
11088
11089 pub f8: ::fidl_next::wire::Uint16,
11090
11091 pub f9: ::fidl_next::wire::Float32,
11092
11093 pub f10: ::fidl_next::wire::Float64,
11094
11095 pub f11: bool,
11096
11097 pub f12: bool,
11098
11099 pub f13: ::fidl_next::wire::String<'de>,
11100
11101 pub f14: ::fidl_next::wire::OptionalString<'de>,
11102
11103 pub f15: ::fidl_next::wire::String<'de>,
11104
11105 pub f16: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
11106
11107 pub f17: ::fidl_next::wire::fuchsia::NullableHandle,
11108
11109 pub f18: [u8; 3],
11110
11111 pub f19: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Float64>,
11112
11113 pub f20: ::fidl_next::wire::OptionalVector<'de, u8>,
11114
11115 pub f21: ::fidl_next::wire::Vector<'de, u8>,
11116
11117 pub f22: crate::wire::FidlvizBits,
11118
11119 pub f23: crate::wire::FidlvizEnum,
11120
11121 pub f24: crate::wire::FidlvizStruct1,
11122
11123 pub f25: crate::wire::FidlvizStruct2,
11124
11125 pub f26: ::fidl_next::wire::Box<'de, crate::wire::FidlvizStruct1>,
11126
11127 pub f27: ::fidl_next::wire::Box<'de, crate::wire::FidlvizStruct2>,
11128
11129 pub f28: crate::wire::FidlvizTable<'de>,
11130
11131 pub f29: crate::wire::FidlvizTable<'de>,
11132
11133 pub f30: crate::wire_optional::FidlvizUnion<'de>,
11134
11135 pub f31: crate::wire::FidlvizUnion<'de>,
11136 }
11137
11138 static_assertions::const_assert_eq!(std::mem::size_of::<FidlvizDemo<'_>>(), 248);
11139 static_assertions::const_assert_eq!(std::mem::align_of::<FidlvizDemo<'_>>(), 8);
11140
11141 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f1), 0);
11142
11143 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f2), 1);
11144
11145 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f3), 2);
11146
11147 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f4), 4);
11148
11149 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f5), 8);
11150
11151 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f6), 16);
11152
11153 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f7), 17);
11154
11155 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f8), 18);
11156
11157 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f9), 20);
11158
11159 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f10), 24);
11160
11161 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f11), 32);
11162
11163 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f12), 33);
11164
11165 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f13), 40);
11166
11167 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f14), 56);
11168
11169 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f15), 72);
11170
11171 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f16), 88);
11172
11173 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f17), 92);
11174
11175 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f18), 96);
11176
11177 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f19), 104);
11178
11179 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f20), 120);
11180
11181 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f21), 136);
11182
11183 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f22), 152);
11184
11185 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f23), 153);
11186
11187 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f24), 154);
11188
11189 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f25), 160);
11190
11191 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f26), 168);
11192
11193 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f27), 176);
11194
11195 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f28), 184);
11196
11197 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f29), 200);
11198
11199 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f30), 216);
11200
11201 static_assertions::const_assert_eq!(std::mem::offset_of!(FidlvizDemo<'_>, f31), 232);
11202
11203 impl ::fidl_next::Constrained for FidlvizDemo<'_> {
11204 type Constraint = ();
11205
11206 fn validate(
11207 _: ::fidl_next::Slot<'_, Self>,
11208 _: Self::Constraint,
11209 ) -> Result<(), ::fidl_next::ValidationError> {
11210 Ok(())
11211 }
11212 }
11213
11214 unsafe impl ::fidl_next::Wire for FidlvizDemo<'static> {
11215 type Narrowed<'de> = FidlvizDemo<'de>;
11216
11217 #[inline]
11218 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11219 ::fidl_next::munge! {
11220 let Self {
11221 f1,
11222 f2,
11223 f3,
11224 f4,
11225 f5,
11226 f6,
11227 f7,
11228 f8,
11229 f9,
11230 f10,
11231 f11,
11232 f12,
11233 f13,
11234 f14,
11235 f15,
11236 f16,
11237 f17,
11238 f18,
11239 f19,
11240 f20,
11241 f21,
11242 f22,
11243 f23,
11244 f24,
11245 f25,
11246 f26,
11247 f27,
11248 f28,
11249 f29,
11250 f30,
11251 f31,
11252
11253 } = &mut *out_;
11254 }
11255
11256 ::fidl_next::Wire::zero_padding(f1);
11257
11258 ::fidl_next::Wire::zero_padding(f2);
11259
11260 ::fidl_next::Wire::zero_padding(f3);
11261
11262 ::fidl_next::Wire::zero_padding(f4);
11263
11264 ::fidl_next::Wire::zero_padding(f5);
11265
11266 ::fidl_next::Wire::zero_padding(f6);
11267
11268 ::fidl_next::Wire::zero_padding(f7);
11269
11270 ::fidl_next::Wire::zero_padding(f8);
11271
11272 ::fidl_next::Wire::zero_padding(f9);
11273
11274 ::fidl_next::Wire::zero_padding(f10);
11275
11276 ::fidl_next::Wire::zero_padding(f11);
11277
11278 ::fidl_next::Wire::zero_padding(f12);
11279
11280 ::fidl_next::Wire::zero_padding(f13);
11281
11282 ::fidl_next::Wire::zero_padding(f14);
11283
11284 ::fidl_next::Wire::zero_padding(f15);
11285
11286 ::fidl_next::Wire::zero_padding(f16);
11287
11288 ::fidl_next::Wire::zero_padding(f17);
11289
11290 ::fidl_next::Wire::zero_padding(f18);
11291
11292 ::fidl_next::Wire::zero_padding(f19);
11293
11294 ::fidl_next::Wire::zero_padding(f20);
11295
11296 ::fidl_next::Wire::zero_padding(f21);
11297
11298 ::fidl_next::Wire::zero_padding(f22);
11299
11300 ::fidl_next::Wire::zero_padding(f23);
11301
11302 ::fidl_next::Wire::zero_padding(f24);
11303
11304 ::fidl_next::Wire::zero_padding(f25);
11305
11306 ::fidl_next::Wire::zero_padding(f26);
11307
11308 ::fidl_next::Wire::zero_padding(f27);
11309
11310 ::fidl_next::Wire::zero_padding(f28);
11311
11312 ::fidl_next::Wire::zero_padding(f29);
11313
11314 ::fidl_next::Wire::zero_padding(f30);
11315
11316 ::fidl_next::Wire::zero_padding(f31);
11317
11318 unsafe {
11319 out_.as_mut_ptr().cast::<u8>().add(155).write_bytes(0, 5);
11320 }
11321
11322 unsafe {
11323 out_.as_mut_ptr().cast::<u8>().add(99).write_bytes(0, 5);
11324 }
11325
11326 unsafe {
11327 out_.as_mut_ptr().cast::<u8>().add(34).write_bytes(0, 6);
11328 }
11329 }
11330 }
11331
11332 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FidlvizDemo<'de>
11333 where
11334 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11335 ___D: ::fidl_next::Decoder<'de>,
11336 ___D: ::fidl_next::fuchsia::HandleDecoder,
11337 {
11338 fn decode(
11339 slot_: ::fidl_next::Slot<'_, Self>,
11340 decoder_: &mut ___D,
11341 _: (),
11342 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11343 if slot_.as_bytes()[155..160] != [0u8; 5] {
11344 return Err(::fidl_next::DecodeError::InvalidPadding);
11345 }
11346
11347 if slot_.as_bytes()[99..104] != [0u8; 5] {
11348 return Err(::fidl_next::DecodeError::InvalidPadding);
11349 }
11350
11351 if slot_.as_bytes()[34..40] != [0u8; 6] {
11352 return Err(::fidl_next::DecodeError::InvalidPadding);
11353 }
11354
11355 ::fidl_next::munge! {
11356 let Self {
11357 mut f1,
11358 mut f2,
11359 mut f3,
11360 mut f4,
11361 mut f5,
11362 mut f6,
11363 mut f7,
11364 mut f8,
11365 mut f9,
11366 mut f10,
11367 mut f11,
11368 mut f12,
11369 mut f13,
11370 mut f14,
11371 mut f15,
11372 mut f16,
11373 mut f17,
11374 mut f18,
11375 mut f19,
11376 mut f20,
11377 mut f21,
11378 mut f22,
11379 mut f23,
11380 mut f24,
11381 mut f25,
11382 mut f26,
11383 mut f27,
11384 mut f28,
11385 mut f29,
11386 mut f30,
11387 mut f31,
11388
11389 } = slot_;
11390 }
11391
11392 let _field = f1.as_mut();
11393
11394 ::fidl_next::Decode::decode(f1.as_mut(), decoder_, ())?;
11395
11396 let _field = f2.as_mut();
11397
11398 ::fidl_next::Decode::decode(f2.as_mut(), decoder_, ())?;
11399
11400 let _field = f3.as_mut();
11401
11402 ::fidl_next::Decode::decode(f3.as_mut(), decoder_, ())?;
11403
11404 let _field = f4.as_mut();
11405
11406 ::fidl_next::Decode::decode(f4.as_mut(), decoder_, ())?;
11407
11408 let _field = f5.as_mut();
11409
11410 ::fidl_next::Decode::decode(f5.as_mut(), decoder_, ())?;
11411
11412 let _field = f6.as_mut();
11413
11414 ::fidl_next::Decode::decode(f6.as_mut(), decoder_, ())?;
11415
11416 let _field = f7.as_mut();
11417
11418 ::fidl_next::Decode::decode(f7.as_mut(), decoder_, ())?;
11419
11420 let _field = f8.as_mut();
11421
11422 ::fidl_next::Decode::decode(f8.as_mut(), decoder_, ())?;
11423
11424 let _field = f9.as_mut();
11425
11426 ::fidl_next::Decode::decode(f9.as_mut(), decoder_, ())?;
11427
11428 let _field = f10.as_mut();
11429
11430 ::fidl_next::Decode::decode(f10.as_mut(), decoder_, ())?;
11431
11432 let _field = f11.as_mut();
11433
11434 ::fidl_next::Decode::decode(f11.as_mut(), decoder_, ())?;
11435
11436 let _field = f12.as_mut();
11437
11438 ::fidl_next::Decode::decode(f12.as_mut(), decoder_, ())?;
11439
11440 let _field = f13.as_mut();
11441 ::fidl_next::Constrained::validate(_field, 4294967295)?;
11442 ::fidl_next::Decode::decode(f13.as_mut(), decoder_, 4294967295)?;
11443
11444 let _field = f14.as_mut();
11445 ::fidl_next::Constrained::validate(_field, 4294967295)?;
11446 ::fidl_next::Decode::decode(f14.as_mut(), decoder_, 4294967295)?;
11447
11448 let _field = f15.as_mut();
11449 ::fidl_next::Constrained::validate(_field, 4294967295)?;
11450 ::fidl_next::Decode::decode(f15.as_mut(), decoder_, 4294967295)?;
11451
11452 let _field = f16.as_mut();
11453
11454 ::fidl_next::Decode::decode(f16.as_mut(), decoder_, ())?;
11455
11456 let _field = f17.as_mut();
11457
11458 ::fidl_next::Decode::decode(f17.as_mut(), decoder_, ())?;
11459
11460 let _field = f18.as_mut();
11461
11462 ::fidl_next::Decode::decode(f18.as_mut(), decoder_, ())?;
11463
11464 let _field = f19.as_mut();
11465 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
11466 ::fidl_next::Decode::decode(f19.as_mut(), decoder_, (4294967295, ()))?;
11467
11468 let _field = f20.as_mut();
11469 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
11470 ::fidl_next::Decode::decode(f20.as_mut(), decoder_, (4294967295, ()))?;
11471
11472 let _field = f21.as_mut();
11473 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
11474 ::fidl_next::Decode::decode(f21.as_mut(), decoder_, (4294967295, ()))?;
11475
11476 let _field = f22.as_mut();
11477
11478 ::fidl_next::Decode::decode(f22.as_mut(), decoder_, ())?;
11479
11480 let _field = f23.as_mut();
11481
11482 ::fidl_next::Decode::decode(f23.as_mut(), decoder_, ())?;
11483
11484 let _field = f24.as_mut();
11485
11486 ::fidl_next::Decode::decode(f24.as_mut(), decoder_, ())?;
11487
11488 let _field = f25.as_mut();
11489
11490 ::fidl_next::Decode::decode(f25.as_mut(), decoder_, ())?;
11491
11492 let _field = f26.as_mut();
11493
11494 ::fidl_next::Decode::decode(f26.as_mut(), decoder_, ())?;
11495
11496 let _field = f27.as_mut();
11497
11498 ::fidl_next::Decode::decode(f27.as_mut(), decoder_, ())?;
11499
11500 let _field = f28.as_mut();
11501
11502 ::fidl_next::Decode::decode(f28.as_mut(), decoder_, ())?;
11503
11504 let _field = f29.as_mut();
11505
11506 ::fidl_next::Decode::decode(f29.as_mut(), decoder_, ())?;
11507
11508 let _field = f30.as_mut();
11509
11510 ::fidl_next::Decode::decode(f30.as_mut(), decoder_, ())?;
11511
11512 let _field = f31.as_mut();
11513
11514 ::fidl_next::Decode::decode(f31.as_mut(), decoder_, ())?;
11515
11516 Ok(())
11517 }
11518 }
11519
11520 impl<'de> ::fidl_next::IntoNatural for FidlvizDemo<'de> {
11521 type Natural = crate::natural::FidlvizDemo;
11522 }
11523
11524 #[derive(Debug)]
11526 #[repr(C)]
11527 pub struct GoldenHandleBasicRightsStruct {
11528 pub v: ::fidl_next::wire::fuchsia::Event,
11529 }
11530
11531 static_assertions::const_assert_eq!(std::mem::size_of::<GoldenHandleBasicRightsStruct>(), 4);
11532 static_assertions::const_assert_eq!(std::mem::align_of::<GoldenHandleBasicRightsStruct>(), 4);
11533
11534 static_assertions::const_assert_eq!(std::mem::offset_of!(GoldenHandleBasicRightsStruct, v), 0);
11535
11536 impl ::fidl_next::Constrained for GoldenHandleBasicRightsStruct {
11537 type Constraint = ();
11538
11539 fn validate(
11540 _: ::fidl_next::Slot<'_, Self>,
11541 _: Self::Constraint,
11542 ) -> Result<(), ::fidl_next::ValidationError> {
11543 Ok(())
11544 }
11545 }
11546
11547 unsafe impl ::fidl_next::Wire for GoldenHandleBasicRightsStruct {
11548 type Narrowed<'de> = GoldenHandleBasicRightsStruct;
11549
11550 #[inline]
11551 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11552 ::fidl_next::munge! {
11553 let Self {
11554 v,
11555
11556 } = &mut *out_;
11557 }
11558
11559 ::fidl_next::Wire::zero_padding(v);
11560 }
11561 }
11562
11563 unsafe impl<___D> ::fidl_next::Decode<___D> for GoldenHandleBasicRightsStruct
11564 where
11565 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11566 ___D: ::fidl_next::fuchsia::HandleDecoder,
11567 {
11568 fn decode(
11569 slot_: ::fidl_next::Slot<'_, Self>,
11570 decoder_: &mut ___D,
11571 _: (),
11572 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11573 ::fidl_next::munge! {
11574 let Self {
11575 mut v,
11576
11577 } = slot_;
11578 }
11579
11580 let _field = v.as_mut();
11581
11582 ::fidl_next::Decode::decode(v.as_mut(), decoder_, ())?;
11583
11584 Ok(())
11585 }
11586 }
11587
11588 impl ::fidl_next::IntoNatural for GoldenHandleBasicRightsStruct {
11589 type Natural = crate::natural::GoldenHandleBasicRightsStruct;
11590 }
11591
11592 #[derive(Debug)]
11594 #[repr(C)]
11595 pub struct GoldenNullableHandleStruct {
11596 pub v: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
11597 }
11598
11599 static_assertions::const_assert_eq!(std::mem::size_of::<GoldenNullableHandleStruct>(), 4);
11600 static_assertions::const_assert_eq!(std::mem::align_of::<GoldenNullableHandleStruct>(), 4);
11601
11602 static_assertions::const_assert_eq!(std::mem::offset_of!(GoldenNullableHandleStruct, v), 0);
11603
11604 impl ::fidl_next::Constrained for GoldenNullableHandleStruct {
11605 type Constraint = ();
11606
11607 fn validate(
11608 _: ::fidl_next::Slot<'_, Self>,
11609 _: Self::Constraint,
11610 ) -> Result<(), ::fidl_next::ValidationError> {
11611 Ok(())
11612 }
11613 }
11614
11615 unsafe impl ::fidl_next::Wire for GoldenNullableHandleStruct {
11616 type Narrowed<'de> = GoldenNullableHandleStruct;
11617
11618 #[inline]
11619 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11620 ::fidl_next::munge! {
11621 let Self {
11622 v,
11623
11624 } = &mut *out_;
11625 }
11626
11627 ::fidl_next::Wire::zero_padding(v);
11628 }
11629 }
11630
11631 unsafe impl<___D> ::fidl_next::Decode<___D> for GoldenNullableHandleStruct
11632 where
11633 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11634 ___D: ::fidl_next::fuchsia::HandleDecoder,
11635 {
11636 fn decode(
11637 slot_: ::fidl_next::Slot<'_, Self>,
11638 decoder_: &mut ___D,
11639 _: (),
11640 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11641 ::fidl_next::munge! {
11642 let Self {
11643 mut v,
11644
11645 } = slot_;
11646 }
11647
11648 let _field = v.as_mut();
11649
11650 ::fidl_next::Decode::decode(v.as_mut(), decoder_, ())?;
11651
11652 Ok(())
11653 }
11654 }
11655
11656 impl ::fidl_next::IntoNatural for GoldenNullableHandleStruct {
11657 type Natural = crate::natural::GoldenNullableHandleStruct;
11658 }
11659
11660 #[derive(Debug)]
11662 #[repr(C)]
11663 pub struct MultipleBoundedNonnullableVectorsOfHandles<'de> {
11664 pub vh0: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
11665
11666 pub vh1: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
11667 }
11668
11669 static_assertions::const_assert_eq!(
11670 std::mem::size_of::<MultipleBoundedNonnullableVectorsOfHandles<'_>>(),
11671 32
11672 );
11673 static_assertions::const_assert_eq!(
11674 std::mem::align_of::<MultipleBoundedNonnullableVectorsOfHandles<'_>>(),
11675 8
11676 );
11677
11678 static_assertions::const_assert_eq!(
11679 std::mem::offset_of!(MultipleBoundedNonnullableVectorsOfHandles<'_>, vh0),
11680 0
11681 );
11682
11683 static_assertions::const_assert_eq!(
11684 std::mem::offset_of!(MultipleBoundedNonnullableVectorsOfHandles<'_>, vh1),
11685 16
11686 );
11687
11688 impl ::fidl_next::Constrained for MultipleBoundedNonnullableVectorsOfHandles<'_> {
11689 type Constraint = ();
11690
11691 fn validate(
11692 _: ::fidl_next::Slot<'_, Self>,
11693 _: Self::Constraint,
11694 ) -> Result<(), ::fidl_next::ValidationError> {
11695 Ok(())
11696 }
11697 }
11698
11699 unsafe impl ::fidl_next::Wire for MultipleBoundedNonnullableVectorsOfHandles<'static> {
11700 type Narrowed<'de> = MultipleBoundedNonnullableVectorsOfHandles<'de>;
11701
11702 #[inline]
11703 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11704 ::fidl_next::munge! {
11705 let Self {
11706 vh0,
11707 vh1,
11708
11709 } = &mut *out_;
11710 }
11711
11712 ::fidl_next::Wire::zero_padding(vh0);
11713
11714 ::fidl_next::Wire::zero_padding(vh1);
11715 }
11716 }
11717
11718 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for MultipleBoundedNonnullableVectorsOfHandles<'de>
11719 where
11720 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11721 ___D: ::fidl_next::Decoder<'de>,
11722 ___D: ::fidl_next::fuchsia::HandleDecoder,
11723 {
11724 fn decode(
11725 slot_: ::fidl_next::Slot<'_, Self>,
11726 decoder_: &mut ___D,
11727 _: (),
11728 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11729 ::fidl_next::munge! {
11730 let Self {
11731 mut vh0,
11732 mut vh1,
11733
11734 } = slot_;
11735 }
11736
11737 let _field = vh0.as_mut();
11738 ::fidl_next::Constrained::validate(_field, (2, ()))?;
11739 ::fidl_next::Decode::decode(vh0.as_mut(), decoder_, (2, ()))?;
11740
11741 let vh0 = unsafe { vh0.deref_unchecked() };
11742
11743 if vh0.len() > 2 {
11744 return Err(::fidl_next::DecodeError::VectorTooLong {
11745 size: vh0.len() as u64,
11746 limit: 2,
11747 });
11748 }
11749
11750 let _field = vh1.as_mut();
11751 ::fidl_next::Constrained::validate(_field, (32, ()))?;
11752 ::fidl_next::Decode::decode(vh1.as_mut(), decoder_, (32, ()))?;
11753
11754 let vh1 = unsafe { vh1.deref_unchecked() };
11755
11756 if vh1.len() > 32 {
11757 return Err(::fidl_next::DecodeError::VectorTooLong {
11758 size: vh1.len() as u64,
11759 limit: 32,
11760 });
11761 }
11762
11763 Ok(())
11764 }
11765 }
11766
11767 impl<'de> ::fidl_next::IntoNatural for MultipleBoundedNonnullableVectorsOfHandles<'de> {
11768 type Natural = crate::natural::MultipleBoundedNonnullableVectorsOfHandles;
11769 }
11770
11771 #[derive(Debug)]
11773 #[repr(C)]
11774 pub struct MultipleBoundedNullableVectorsOfHandles<'de> {
11775 pub vh0: ::fidl_next::wire::OptionalVector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
11776
11777 pub vh1: ::fidl_next::wire::OptionalVector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
11778 }
11779
11780 static_assertions::const_assert_eq!(
11781 std::mem::size_of::<MultipleBoundedNullableVectorsOfHandles<'_>>(),
11782 32
11783 );
11784 static_assertions::const_assert_eq!(
11785 std::mem::align_of::<MultipleBoundedNullableVectorsOfHandles<'_>>(),
11786 8
11787 );
11788
11789 static_assertions::const_assert_eq!(
11790 std::mem::offset_of!(MultipleBoundedNullableVectorsOfHandles<'_>, vh0),
11791 0
11792 );
11793
11794 static_assertions::const_assert_eq!(
11795 std::mem::offset_of!(MultipleBoundedNullableVectorsOfHandles<'_>, vh1),
11796 16
11797 );
11798
11799 impl ::fidl_next::Constrained for MultipleBoundedNullableVectorsOfHandles<'_> {
11800 type Constraint = ();
11801
11802 fn validate(
11803 _: ::fidl_next::Slot<'_, Self>,
11804 _: Self::Constraint,
11805 ) -> Result<(), ::fidl_next::ValidationError> {
11806 Ok(())
11807 }
11808 }
11809
11810 unsafe impl ::fidl_next::Wire for MultipleBoundedNullableVectorsOfHandles<'static> {
11811 type Narrowed<'de> = MultipleBoundedNullableVectorsOfHandles<'de>;
11812
11813 #[inline]
11814 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11815 ::fidl_next::munge! {
11816 let Self {
11817 vh0,
11818 vh1,
11819
11820 } = &mut *out_;
11821 }
11822
11823 ::fidl_next::Wire::zero_padding(vh0);
11824
11825 ::fidl_next::Wire::zero_padding(vh1);
11826 }
11827 }
11828
11829 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for MultipleBoundedNullableVectorsOfHandles<'de>
11830 where
11831 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11832 ___D: ::fidl_next::Decoder<'de>,
11833 ___D: ::fidl_next::fuchsia::HandleDecoder,
11834 {
11835 fn decode(
11836 slot_: ::fidl_next::Slot<'_, Self>,
11837 decoder_: &mut ___D,
11838 _: (),
11839 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11840 ::fidl_next::munge! {
11841 let Self {
11842 mut vh0,
11843 mut vh1,
11844
11845 } = slot_;
11846 }
11847
11848 let _field = vh0.as_mut();
11849 ::fidl_next::Constrained::validate(_field, (2, ()))?;
11850 ::fidl_next::Decode::decode(vh0.as_mut(), decoder_, (2, ()))?;
11851
11852 let vh0 = unsafe { vh0.deref_unchecked() };
11853
11854 if let Some(vh0) = vh0.as_ref() {
11855 if vh0.len() > 2 {
11856 return Err(::fidl_next::DecodeError::VectorTooLong {
11857 size: vh0.len() as u64,
11858 limit: 2,
11859 });
11860 }
11861 }
11862
11863 let _field = vh1.as_mut();
11864 ::fidl_next::Constrained::validate(_field, (32, ()))?;
11865 ::fidl_next::Decode::decode(vh1.as_mut(), decoder_, (32, ()))?;
11866
11867 let vh1 = unsafe { vh1.deref_unchecked() };
11868
11869 if let Some(vh1) = vh1.as_ref() {
11870 if vh1.len() > 32 {
11871 return Err(::fidl_next::DecodeError::VectorTooLong {
11872 size: vh1.len() as u64,
11873 limit: 32,
11874 });
11875 }
11876 }
11877
11878 Ok(())
11879 }
11880 }
11881
11882 impl<'de> ::fidl_next::IntoNatural for MultipleBoundedNullableVectorsOfHandles<'de> {
11883 type Natural = crate::natural::MultipleBoundedNullableVectorsOfHandles;
11884 }
11885
11886 #[derive(Debug)]
11888 #[repr(C)]
11889 pub struct MultipleHandleSubtypes {
11890 pub untyped: ::fidl_next::wire::fuchsia::NullableHandle,
11891
11892 pub event: ::fidl_next::wire::fuchsia::Event,
11893
11894 pub channel: ::fidl_next::wire::fuchsia::Channel,
11895 }
11896
11897 static_assertions::const_assert_eq!(std::mem::size_of::<MultipleHandleSubtypes>(), 12);
11898 static_assertions::const_assert_eq!(std::mem::align_of::<MultipleHandleSubtypes>(), 4);
11899
11900 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleHandleSubtypes, untyped), 0);
11901
11902 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleHandleSubtypes, event), 4);
11903
11904 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleHandleSubtypes, channel), 8);
11905
11906 impl ::fidl_next::Constrained for MultipleHandleSubtypes {
11907 type Constraint = ();
11908
11909 fn validate(
11910 _: ::fidl_next::Slot<'_, Self>,
11911 _: Self::Constraint,
11912 ) -> Result<(), ::fidl_next::ValidationError> {
11913 Ok(())
11914 }
11915 }
11916
11917 unsafe impl ::fidl_next::Wire for MultipleHandleSubtypes {
11918 type Narrowed<'de> = MultipleHandleSubtypes;
11919
11920 #[inline]
11921 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11922 ::fidl_next::munge! {
11923 let Self {
11924 untyped,
11925 event,
11926 channel,
11927
11928 } = &mut *out_;
11929 }
11930
11931 ::fidl_next::Wire::zero_padding(untyped);
11932
11933 ::fidl_next::Wire::zero_padding(event);
11934
11935 ::fidl_next::Wire::zero_padding(channel);
11936 }
11937 }
11938
11939 unsafe impl<___D> ::fidl_next::Decode<___D> for MultipleHandleSubtypes
11940 where
11941 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11942 ___D: ::fidl_next::fuchsia::HandleDecoder,
11943 {
11944 fn decode(
11945 slot_: ::fidl_next::Slot<'_, Self>,
11946 decoder_: &mut ___D,
11947 _: (),
11948 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11949 ::fidl_next::munge! {
11950 let Self {
11951 mut untyped,
11952 mut event,
11953 mut channel,
11954
11955 } = slot_;
11956 }
11957
11958 let _field = untyped.as_mut();
11959
11960 ::fidl_next::Decode::decode(untyped.as_mut(), decoder_, ())?;
11961
11962 let _field = event.as_mut();
11963
11964 ::fidl_next::Decode::decode(event.as_mut(), decoder_, ())?;
11965
11966 let _field = channel.as_mut();
11967
11968 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
11969
11970 Ok(())
11971 }
11972 }
11973
11974 impl ::fidl_next::IntoNatural for MultipleHandleSubtypes {
11975 type Natural = crate::natural::MultipleHandleSubtypes;
11976 }
11977
11978 #[derive(Debug)]
11980 #[repr(C)]
11981 pub struct MultipleNonnullableHandles {
11982 pub data0: ::fidl_next::wire::Uint32,
11983
11984 pub handle0: ::fidl_next::wire::fuchsia::NullableHandle,
11985
11986 pub data1: ::fidl_next::wire::Uint64,
11987
11988 pub handle1: ::fidl_next::wire::fuchsia::Channel,
11989
11990 pub handle2: ::fidl_next::wire::fuchsia::Event,
11991
11992 pub data2: ::fidl_next::wire::Uint64,
11993 }
11994
11995 static_assertions::const_assert_eq!(std::mem::size_of::<MultipleNonnullableHandles>(), 32);
11996 static_assertions::const_assert_eq!(std::mem::align_of::<MultipleNonnullableHandles>(), 8);
11997
11998 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNonnullableHandles, data0), 0);
11999
12000 static_assertions::const_assert_eq!(
12001 std::mem::offset_of!(MultipleNonnullableHandles, handle0),
12002 4
12003 );
12004
12005 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNonnullableHandles, data1), 8);
12006
12007 static_assertions::const_assert_eq!(
12008 std::mem::offset_of!(MultipleNonnullableHandles, handle1),
12009 16
12010 );
12011
12012 static_assertions::const_assert_eq!(
12013 std::mem::offset_of!(MultipleNonnullableHandles, handle2),
12014 20
12015 );
12016
12017 static_assertions::const_assert_eq!(
12018 std::mem::offset_of!(MultipleNonnullableHandles, data2),
12019 24
12020 );
12021
12022 impl ::fidl_next::Constrained for MultipleNonnullableHandles {
12023 type Constraint = ();
12024
12025 fn validate(
12026 _: ::fidl_next::Slot<'_, Self>,
12027 _: Self::Constraint,
12028 ) -> Result<(), ::fidl_next::ValidationError> {
12029 Ok(())
12030 }
12031 }
12032
12033 unsafe impl ::fidl_next::Wire for MultipleNonnullableHandles {
12034 type Narrowed<'de> = MultipleNonnullableHandles;
12035
12036 #[inline]
12037 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12038 ::fidl_next::munge! {
12039 let Self {
12040 data0,
12041 handle0,
12042 data1,
12043 handle1,
12044 handle2,
12045 data2,
12046
12047 } = &mut *out_;
12048 }
12049
12050 ::fidl_next::Wire::zero_padding(data0);
12051
12052 ::fidl_next::Wire::zero_padding(handle0);
12053
12054 ::fidl_next::Wire::zero_padding(data1);
12055
12056 ::fidl_next::Wire::zero_padding(handle1);
12057
12058 ::fidl_next::Wire::zero_padding(handle2);
12059
12060 ::fidl_next::Wire::zero_padding(data2);
12061 }
12062 }
12063
12064 unsafe impl<___D> ::fidl_next::Decode<___D> for MultipleNonnullableHandles
12065 where
12066 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12067 ___D: ::fidl_next::fuchsia::HandleDecoder,
12068 {
12069 fn decode(
12070 slot_: ::fidl_next::Slot<'_, Self>,
12071 decoder_: &mut ___D,
12072 _: (),
12073 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12074 ::fidl_next::munge! {
12075 let Self {
12076 mut data0,
12077 mut handle0,
12078 mut data1,
12079 mut handle1,
12080 mut handle2,
12081 mut data2,
12082
12083 } = slot_;
12084 }
12085
12086 let _field = data0.as_mut();
12087
12088 ::fidl_next::Decode::decode(data0.as_mut(), decoder_, ())?;
12089
12090 let _field = handle0.as_mut();
12091
12092 ::fidl_next::Decode::decode(handle0.as_mut(), decoder_, ())?;
12093
12094 let _field = data1.as_mut();
12095
12096 ::fidl_next::Decode::decode(data1.as_mut(), decoder_, ())?;
12097
12098 let _field = handle1.as_mut();
12099
12100 ::fidl_next::Decode::decode(handle1.as_mut(), decoder_, ())?;
12101
12102 let _field = handle2.as_mut();
12103
12104 ::fidl_next::Decode::decode(handle2.as_mut(), decoder_, ())?;
12105
12106 let _field = data2.as_mut();
12107
12108 ::fidl_next::Decode::decode(data2.as_mut(), decoder_, ())?;
12109
12110 Ok(())
12111 }
12112 }
12113
12114 impl ::fidl_next::IntoNatural for MultipleNonnullableHandles {
12115 type Natural = crate::natural::MultipleNonnullableHandles;
12116 }
12117
12118 #[derive(Debug)]
12120 #[repr(C)]
12121 pub struct MultipleNullableHandles {
12122 pub data0: ::fidl_next::wire::Uint32,
12123
12124 pub handle0: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
12125
12126 pub data1: ::fidl_next::wire::Uint64,
12127
12128 pub handle1: ::fidl_next::wire::fuchsia::OptionalChannel,
12129
12130 pub handle2: ::fidl_next::wire::fuchsia::OptionalEvent,
12131
12132 pub data2: ::fidl_next::wire::Uint64,
12133 }
12134
12135 static_assertions::const_assert_eq!(std::mem::size_of::<MultipleNullableHandles>(), 32);
12136 static_assertions::const_assert_eq!(std::mem::align_of::<MultipleNullableHandles>(), 8);
12137
12138 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNullableHandles, data0), 0);
12139
12140 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNullableHandles, handle0), 4);
12141
12142 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNullableHandles, data1), 8);
12143
12144 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNullableHandles, handle1), 16);
12145
12146 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNullableHandles, handle2), 20);
12147
12148 static_assertions::const_assert_eq!(std::mem::offset_of!(MultipleNullableHandles, data2), 24);
12149
12150 impl ::fidl_next::Constrained for MultipleNullableHandles {
12151 type Constraint = ();
12152
12153 fn validate(
12154 _: ::fidl_next::Slot<'_, Self>,
12155 _: Self::Constraint,
12156 ) -> Result<(), ::fidl_next::ValidationError> {
12157 Ok(())
12158 }
12159 }
12160
12161 unsafe impl ::fidl_next::Wire for MultipleNullableHandles {
12162 type Narrowed<'de> = MultipleNullableHandles;
12163
12164 #[inline]
12165 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12166 ::fidl_next::munge! {
12167 let Self {
12168 data0,
12169 handle0,
12170 data1,
12171 handle1,
12172 handle2,
12173 data2,
12174
12175 } = &mut *out_;
12176 }
12177
12178 ::fidl_next::Wire::zero_padding(data0);
12179
12180 ::fidl_next::Wire::zero_padding(handle0);
12181
12182 ::fidl_next::Wire::zero_padding(data1);
12183
12184 ::fidl_next::Wire::zero_padding(handle1);
12185
12186 ::fidl_next::Wire::zero_padding(handle2);
12187
12188 ::fidl_next::Wire::zero_padding(data2);
12189 }
12190 }
12191
12192 unsafe impl<___D> ::fidl_next::Decode<___D> for MultipleNullableHandles
12193 where
12194 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12195 ___D: ::fidl_next::fuchsia::HandleDecoder,
12196 {
12197 fn decode(
12198 slot_: ::fidl_next::Slot<'_, Self>,
12199 decoder_: &mut ___D,
12200 _: (),
12201 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12202 ::fidl_next::munge! {
12203 let Self {
12204 mut data0,
12205 mut handle0,
12206 mut data1,
12207 mut handle1,
12208 mut handle2,
12209 mut data2,
12210
12211 } = slot_;
12212 }
12213
12214 let _field = data0.as_mut();
12215
12216 ::fidl_next::Decode::decode(data0.as_mut(), decoder_, ())?;
12217
12218 let _field = handle0.as_mut();
12219
12220 ::fidl_next::Decode::decode(handle0.as_mut(), decoder_, ())?;
12221
12222 let _field = data1.as_mut();
12223
12224 ::fidl_next::Decode::decode(data1.as_mut(), decoder_, ())?;
12225
12226 let _field = handle1.as_mut();
12227
12228 ::fidl_next::Decode::decode(handle1.as_mut(), decoder_, ())?;
12229
12230 let _field = handle2.as_mut();
12231
12232 ::fidl_next::Decode::decode(handle2.as_mut(), decoder_, ())?;
12233
12234 let _field = data2.as_mut();
12235
12236 ::fidl_next::Decode::decode(data2.as_mut(), decoder_, ())?;
12237
12238 Ok(())
12239 }
12240 }
12241
12242 impl ::fidl_next::IntoNatural for MultipleNullableHandles {
12243 type Natural = crate::natural::MultipleNullableHandles;
12244 }
12245
12246 #[derive(Debug)]
12248 #[repr(C)]
12249 pub struct NonnullableHandle {
12250 pub h: ::fidl_next::wire::fuchsia::NullableHandle,
12251 }
12252
12253 static_assertions::const_assert_eq!(std::mem::size_of::<NonnullableHandle>(), 4);
12254 static_assertions::const_assert_eq!(std::mem::align_of::<NonnullableHandle>(), 4);
12255
12256 static_assertions::const_assert_eq!(std::mem::offset_of!(NonnullableHandle, h), 0);
12257
12258 impl ::fidl_next::Constrained for NonnullableHandle {
12259 type Constraint = ();
12260
12261 fn validate(
12262 _: ::fidl_next::Slot<'_, Self>,
12263 _: Self::Constraint,
12264 ) -> Result<(), ::fidl_next::ValidationError> {
12265 Ok(())
12266 }
12267 }
12268
12269 unsafe impl ::fidl_next::Wire for NonnullableHandle {
12270 type Narrowed<'de> = NonnullableHandle;
12271
12272 #[inline]
12273 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12274 ::fidl_next::munge! {
12275 let Self {
12276 h,
12277
12278 } = &mut *out_;
12279 }
12280
12281 ::fidl_next::Wire::zero_padding(h);
12282 }
12283 }
12284
12285 unsafe impl<___D> ::fidl_next::Decode<___D> for NonnullableHandle
12286 where
12287 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12288 ___D: ::fidl_next::fuchsia::HandleDecoder,
12289 {
12290 fn decode(
12291 slot_: ::fidl_next::Slot<'_, Self>,
12292 decoder_: &mut ___D,
12293 _: (),
12294 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12295 ::fidl_next::munge! {
12296 let Self {
12297 mut h,
12298
12299 } = slot_;
12300 }
12301
12302 let _field = h.as_mut();
12303
12304 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
12305
12306 Ok(())
12307 }
12308 }
12309
12310 impl ::fidl_next::IntoNatural for NonnullableHandle {
12311 type Natural = crate::natural::NonnullableHandle;
12312 }
12313
12314 #[derive(Debug)]
12316 #[repr(C)]
12317 pub struct NonnullableHandleArray {
12318 pub handles: [::fidl_next::wire::fuchsia::NullableHandle; 4],
12319 }
12320
12321 static_assertions::const_assert_eq!(std::mem::size_of::<NonnullableHandleArray>(), 16);
12322 static_assertions::const_assert_eq!(std::mem::align_of::<NonnullableHandleArray>(), 4);
12323
12324 static_assertions::const_assert_eq!(std::mem::offset_of!(NonnullableHandleArray, handles), 0);
12325
12326 impl ::fidl_next::Constrained for NonnullableHandleArray {
12327 type Constraint = ();
12328
12329 fn validate(
12330 _: ::fidl_next::Slot<'_, Self>,
12331 _: Self::Constraint,
12332 ) -> Result<(), ::fidl_next::ValidationError> {
12333 Ok(())
12334 }
12335 }
12336
12337 unsafe impl ::fidl_next::Wire for NonnullableHandleArray {
12338 type Narrowed<'de> = NonnullableHandleArray;
12339
12340 #[inline]
12341 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12342 ::fidl_next::munge! {
12343 let Self {
12344 handles,
12345
12346 } = &mut *out_;
12347 }
12348
12349 ::fidl_next::Wire::zero_padding(handles);
12350 }
12351 }
12352
12353 unsafe impl<___D> ::fidl_next::Decode<___D> for NonnullableHandleArray
12354 where
12355 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12356 ___D: ::fidl_next::fuchsia::HandleDecoder,
12357 {
12358 fn decode(
12359 slot_: ::fidl_next::Slot<'_, Self>,
12360 decoder_: &mut ___D,
12361 _: (),
12362 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12363 ::fidl_next::munge! {
12364 let Self {
12365 mut handles,
12366
12367 } = slot_;
12368 }
12369
12370 let _field = handles.as_mut();
12371
12372 ::fidl_next::Decode::decode(handles.as_mut(), decoder_, ())?;
12373
12374 Ok(())
12375 }
12376 }
12377
12378 impl ::fidl_next::IntoNatural for NonnullableHandleArray {
12379 type Natural = crate::natural::NonnullableHandleArray;
12380 }
12381
12382 #[derive(Debug)]
12384 #[repr(C)]
12385 pub struct NullableHandle {
12386 pub h: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
12387 }
12388
12389 static_assertions::const_assert_eq!(std::mem::size_of::<NullableHandle>(), 4);
12390 static_assertions::const_assert_eq!(std::mem::align_of::<NullableHandle>(), 4);
12391
12392 static_assertions::const_assert_eq!(std::mem::offset_of!(NullableHandle, h), 0);
12393
12394 impl ::fidl_next::Constrained for NullableHandle {
12395 type Constraint = ();
12396
12397 fn validate(
12398 _: ::fidl_next::Slot<'_, Self>,
12399 _: Self::Constraint,
12400 ) -> Result<(), ::fidl_next::ValidationError> {
12401 Ok(())
12402 }
12403 }
12404
12405 unsafe impl ::fidl_next::Wire for NullableHandle {
12406 type Narrowed<'de> = NullableHandle;
12407
12408 #[inline]
12409 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12410 ::fidl_next::munge! {
12411 let Self {
12412 h,
12413
12414 } = &mut *out_;
12415 }
12416
12417 ::fidl_next::Wire::zero_padding(h);
12418 }
12419 }
12420
12421 unsafe impl<___D> ::fidl_next::Decode<___D> for NullableHandle
12422 where
12423 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12424 ___D: ::fidl_next::fuchsia::HandleDecoder,
12425 {
12426 fn decode(
12427 slot_: ::fidl_next::Slot<'_, Self>,
12428 decoder_: &mut ___D,
12429 _: (),
12430 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12431 ::fidl_next::munge! {
12432 let Self {
12433 mut h,
12434
12435 } = slot_;
12436 }
12437
12438 let _field = h.as_mut();
12439
12440 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
12441
12442 Ok(())
12443 }
12444 }
12445
12446 impl ::fidl_next::IntoNatural for NullableHandle {
12447 type Natural = crate::natural::NullableHandle;
12448 }
12449
12450 #[derive(Debug)]
12452 #[repr(C)]
12453 pub struct OutOfLineArrayOfNonnullableHandles<'de> {
12454 pub handles: ::fidl_next::wire::Box<'de, crate::wire::NonnullableHandleArray>,
12455 }
12456
12457 static_assertions::const_assert_eq!(
12458 std::mem::size_of::<OutOfLineArrayOfNonnullableHandles<'_>>(),
12459 8
12460 );
12461 static_assertions::const_assert_eq!(
12462 std::mem::align_of::<OutOfLineArrayOfNonnullableHandles<'_>>(),
12463 8
12464 );
12465
12466 static_assertions::const_assert_eq!(
12467 std::mem::offset_of!(OutOfLineArrayOfNonnullableHandles<'_>, handles),
12468 0
12469 );
12470
12471 impl ::fidl_next::Constrained for OutOfLineArrayOfNonnullableHandles<'_> {
12472 type Constraint = ();
12473
12474 fn validate(
12475 _: ::fidl_next::Slot<'_, Self>,
12476 _: Self::Constraint,
12477 ) -> Result<(), ::fidl_next::ValidationError> {
12478 Ok(())
12479 }
12480 }
12481
12482 unsafe impl ::fidl_next::Wire for OutOfLineArrayOfNonnullableHandles<'static> {
12483 type Narrowed<'de> = OutOfLineArrayOfNonnullableHandles<'de>;
12484
12485 #[inline]
12486 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12487 ::fidl_next::munge! {
12488 let Self {
12489 handles,
12490
12491 } = &mut *out_;
12492 }
12493
12494 ::fidl_next::Wire::zero_padding(handles);
12495 }
12496 }
12497
12498 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OutOfLineArrayOfNonnullableHandles<'de>
12499 where
12500 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12501 ___D: ::fidl_next::Decoder<'de>,
12502 ___D: ::fidl_next::fuchsia::HandleDecoder,
12503 {
12504 fn decode(
12505 slot_: ::fidl_next::Slot<'_, Self>,
12506 decoder_: &mut ___D,
12507 _: (),
12508 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12509 ::fidl_next::munge! {
12510 let Self {
12511 mut handles,
12512
12513 } = slot_;
12514 }
12515
12516 let _field = handles.as_mut();
12517
12518 ::fidl_next::Decode::decode(handles.as_mut(), decoder_, ())?;
12519
12520 Ok(())
12521 }
12522 }
12523
12524 impl<'de> ::fidl_next::IntoNatural for OutOfLineArrayOfNonnullableHandles<'de> {
12525 type Natural = crate::natural::OutOfLineArrayOfNonnullableHandles;
12526 }
12527
12528 #[repr(transparent)]
12530 pub struct SampleResourceXUnion<'de> {
12531 pub(crate) raw: ::fidl_next::wire::Union,
12532 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12533 }
12534
12535 impl<'de> Drop for SampleResourceXUnion<'de> {
12536 fn drop(&mut self) {
12537 match self.raw.ordinal() {
12538 1 => {
12539 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint32>() };
12540 }
12541
12542 2 => {
12543 let _ =
12544 unsafe { self.raw.get().read_unchecked::<crate::wire::SimpleUnion<'de>>() };
12545 }
12546
12547 3 => {
12548 let _ =
12549 unsafe { self.raw.get().read_unchecked::<crate::wire::SimpleTable<'de>>() };
12550 }
12551
12552 _ => (),
12553 }
12554 }
12555 }
12556
12557 impl ::fidl_next::Constrained for SampleResourceXUnion<'_> {
12558 type Constraint = ();
12559
12560 fn validate(
12561 _: ::fidl_next::Slot<'_, Self>,
12562 _: Self::Constraint,
12563 ) -> Result<(), ::fidl_next::ValidationError> {
12564 Ok(())
12565 }
12566 }
12567
12568 unsafe impl ::fidl_next::Wire for SampleResourceXUnion<'static> {
12569 type Narrowed<'de> = SampleResourceXUnion<'de>;
12570
12571 #[inline]
12572 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12573 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12574 ::fidl_next::wire::Union::zero_padding(raw);
12575 }
12576 }
12577
12578 pub mod sample_resource_x_union {
12579 pub enum Ref<'de> {
12580 U(&'de ::fidl_next::wire::Uint32),
12581
12582 Su(&'de crate::wire::SimpleUnion<'de>),
12583
12584 St(&'de crate::wire::SimpleTable<'de>),
12585
12586 UnknownOrdinal_(u64),
12587 }
12588
12589 pub enum Value<'de> {
12590 U(::fidl_next::wire::Uint32),
12591
12592 Su(crate::wire::SimpleUnion<'de>),
12593
12594 St(crate::wire::SimpleTable<'de>),
12595
12596 UnknownOrdinal_(u64),
12597 }
12598 }
12599
12600 impl<'de> SampleResourceXUnion<'de> {
12601 pub fn as_ref(&self) -> crate::wire::sample_resource_x_union::Ref<'_> {
12602 match self.raw.ordinal() {
12603 1 => crate::wire::sample_resource_x_union::Ref::U(unsafe {
12604 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>()
12605 }),
12606
12607 2 => crate::wire::sample_resource_x_union::Ref::Su(unsafe {
12608 self.raw.get().deref_unchecked::<crate::wire::SimpleUnion<'_>>()
12609 }),
12610
12611 3 => crate::wire::sample_resource_x_union::Ref::St(unsafe {
12612 self.raw.get().deref_unchecked::<crate::wire::SimpleTable<'_>>()
12613 }),
12614
12615 unknown => crate::wire::sample_resource_x_union::Ref::UnknownOrdinal_(unknown),
12616 }
12617 }
12618
12619 pub fn into_inner(self) -> crate::wire::sample_resource_x_union::Value<'de> {
12620 let this = ::core::mem::ManuallyDrop::new(self);
12621
12622 match this.raw.ordinal() {
12623 1 => crate::wire::sample_resource_x_union::Value::U(unsafe {
12624 this.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
12625 }),
12626
12627 2 => crate::wire::sample_resource_x_union::Value::Su(unsafe {
12628 this.raw.get().read_unchecked::<crate::wire::SimpleUnion<'de>>()
12629 }),
12630
12631 3 => crate::wire::sample_resource_x_union::Value::St(unsafe {
12632 this.raw.get().read_unchecked::<crate::wire::SimpleTable<'de>>()
12633 }),
12634
12635 unknown => crate::wire::sample_resource_x_union::Value::UnknownOrdinal_(unknown),
12636 }
12637 }
12638 }
12639
12640 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SampleResourceXUnion<'de>
12641 where
12642 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12643 ___D: ::fidl_next::Decoder<'de>,
12644 ___D: ::fidl_next::fuchsia::HandleDecoder,
12645 {
12646 fn decode(
12647 mut slot: ::fidl_next::Slot<'_, Self>,
12648 decoder: &mut ___D,
12649 _: (),
12650 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12651 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12652 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
12653 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
12654 raw,
12655 decoder,
12656 (),
12657 )?,
12658
12659 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleUnion<'de>>(
12660 raw,
12661 decoder,
12662 (),
12663 )?,
12664
12665 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleTable<'de>>(
12666 raw,
12667 decoder,
12668 (),
12669 )?,
12670
12671 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
12672 }
12673
12674 Ok(())
12675 }
12676 }
12677
12678 impl<'de> ::core::fmt::Debug for SampleResourceXUnion<'de> {
12679 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12680 match self.raw.ordinal() {
12681 1 => unsafe {
12682 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>().fmt(f)
12683 },
12684 2 => unsafe {
12685 self.raw.get().deref_unchecked::<crate::wire::SimpleUnion<'_>>().fmt(f)
12686 },
12687 3 => unsafe {
12688 self.raw.get().deref_unchecked::<crate::wire::SimpleTable<'_>>().fmt(f)
12689 },
12690 _ => unsafe { ::core::hint::unreachable_unchecked() },
12691 }
12692 }
12693 }
12694
12695 impl<'de> ::fidl_next::IntoNatural for SampleResourceXUnion<'de> {
12696 type Natural = crate::natural::SampleResourceXUnion;
12697 }
12698
12699 #[repr(transparent)]
12701 pub struct SampleStrictResourceXUnion<'de> {
12702 pub(crate) raw: ::fidl_next::wire::Union,
12703 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12704 }
12705
12706 impl<'de> Drop for SampleStrictResourceXUnion<'de> {
12707 fn drop(&mut self) {
12708 match self.raw.ordinal() {
12709 1 => {
12710 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint32>() };
12711 }
12712
12713 2 => {
12714 let _ =
12715 unsafe { self.raw.get().read_unchecked::<crate::wire::SimpleUnion<'de>>() };
12716 }
12717
12718 3 => {
12719 let _ =
12720 unsafe { self.raw.get().read_unchecked::<crate::wire::SimpleTable<'de>>() };
12721 }
12722
12723 _ => unsafe { ::core::hint::unreachable_unchecked() },
12724 }
12725 }
12726 }
12727
12728 impl ::fidl_next::Constrained for SampleStrictResourceXUnion<'_> {
12729 type Constraint = ();
12730
12731 fn validate(
12732 _: ::fidl_next::Slot<'_, Self>,
12733 _: Self::Constraint,
12734 ) -> Result<(), ::fidl_next::ValidationError> {
12735 Ok(())
12736 }
12737 }
12738
12739 unsafe impl ::fidl_next::Wire for SampleStrictResourceXUnion<'static> {
12740 type Narrowed<'de> = SampleStrictResourceXUnion<'de>;
12741
12742 #[inline]
12743 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12744 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12745 ::fidl_next::wire::Union::zero_padding(raw);
12746 }
12747 }
12748
12749 pub mod sample_strict_resource_x_union {
12750 pub enum Ref<'de> {
12751 U(&'de ::fidl_next::wire::Uint32),
12752
12753 Su(&'de crate::wire::SimpleUnion<'de>),
12754
12755 St(&'de crate::wire::SimpleTable<'de>),
12756 }
12757
12758 pub enum Value<'de> {
12759 U(::fidl_next::wire::Uint32),
12760
12761 Su(crate::wire::SimpleUnion<'de>),
12762
12763 St(crate::wire::SimpleTable<'de>),
12764 }
12765 }
12766
12767 impl<'de> SampleStrictResourceXUnion<'de> {
12768 pub fn as_ref(&self) -> crate::wire::sample_strict_resource_x_union::Ref<'_> {
12769 match self.raw.ordinal() {
12770 1 => crate::wire::sample_strict_resource_x_union::Ref::U(unsafe {
12771 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>()
12772 }),
12773
12774 2 => crate::wire::sample_strict_resource_x_union::Ref::Su(unsafe {
12775 self.raw.get().deref_unchecked::<crate::wire::SimpleUnion<'_>>()
12776 }),
12777
12778 3 => crate::wire::sample_strict_resource_x_union::Ref::St(unsafe {
12779 self.raw.get().deref_unchecked::<crate::wire::SimpleTable<'_>>()
12780 }),
12781
12782 _ => unsafe { ::core::hint::unreachable_unchecked() },
12783 }
12784 }
12785
12786 pub fn into_inner(self) -> crate::wire::sample_strict_resource_x_union::Value<'de> {
12787 let this = ::core::mem::ManuallyDrop::new(self);
12788
12789 match this.raw.ordinal() {
12790 1 => crate::wire::sample_strict_resource_x_union::Value::U(unsafe {
12791 this.raw.get().read_unchecked::<::fidl_next::wire::Uint32>()
12792 }),
12793
12794 2 => crate::wire::sample_strict_resource_x_union::Value::Su(unsafe {
12795 this.raw.get().read_unchecked::<crate::wire::SimpleUnion<'de>>()
12796 }),
12797
12798 3 => crate::wire::sample_strict_resource_x_union::Value::St(unsafe {
12799 this.raw.get().read_unchecked::<crate::wire::SimpleTable<'de>>()
12800 }),
12801
12802 _ => unsafe { ::core::hint::unreachable_unchecked() },
12803 }
12804 }
12805 }
12806
12807 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SampleStrictResourceXUnion<'de>
12808 where
12809 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12810 ___D: ::fidl_next::Decoder<'de>,
12811 ___D: ::fidl_next::fuchsia::HandleDecoder,
12812 {
12813 fn decode(
12814 mut slot: ::fidl_next::Slot<'_, Self>,
12815 decoder: &mut ___D,
12816 _: (),
12817 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12818 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12819 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
12820 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
12821 raw,
12822 decoder,
12823 (),
12824 )?,
12825
12826 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleUnion<'de>>(
12827 raw,
12828 decoder,
12829 (),
12830 )?,
12831
12832 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleTable<'de>>(
12833 raw,
12834 decoder,
12835 (),
12836 )?,
12837
12838 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12839 }
12840
12841 Ok(())
12842 }
12843 }
12844
12845 impl<'de> ::core::fmt::Debug for SampleStrictResourceXUnion<'de> {
12846 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12847 match self.raw.ordinal() {
12848 1 => unsafe {
12849 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>().fmt(f)
12850 },
12851 2 => unsafe {
12852 self.raw.get().deref_unchecked::<crate::wire::SimpleUnion<'_>>().fmt(f)
12853 },
12854 3 => unsafe {
12855 self.raw.get().deref_unchecked::<crate::wire::SimpleTable<'_>>().fmt(f)
12856 },
12857 _ => unsafe { ::core::hint::unreachable_unchecked() },
12858 }
12859 }
12860 }
12861
12862 impl<'de> ::fidl_next::IntoNatural for SampleStrictResourceXUnion<'de> {
12863 type Natural = crate::natural::SampleStrictResourceXUnion;
12864 }
12865
12866 #[repr(transparent)]
12868 pub struct UnionWithVector<'de> {
12869 pub(crate) raw: ::fidl_next::wire::Union,
12870 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12871 }
12872
12873 impl<'de> Drop for UnionWithVector<'de> {
12874 fn drop(&mut self) {
12875 match self.raw.ordinal() {
12876 1 => {
12877 let _ = unsafe { self.raw.get().read_unchecked::<u8>() };
12878 }
12879
12880 2 => {
12881 let _ = unsafe {
12882 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
12883 };
12884 }
12885
12886 3 => {
12887 let _ = unsafe {
12888 self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
12889 };
12890 }
12891
12892 4 => {
12893 let _ = unsafe {
12894 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>>()
12895 };
12896 }
12897
12898 5 => {
12899 let _ = unsafe {
12900 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>>()
12901 };
12902 }
12903
12904 6 => {
12905 let _ = unsafe {
12906 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<
12907 'de,
12908 ::fidl_next::wire::fuchsia::NullableHandle,
12909 >>()
12910 };
12911 }
12912
12913 7 => {
12914 let _ = unsafe {
12915 self.raw.get().read_unchecked::<[crate::wire::StructSize3Align1; 2]>()
12916 };
12917 }
12918
12919 8 => {
12920 let _ = unsafe {
12921 self.raw.get().read_unchecked::<[crate::wire::StructSize3Align2; 2]>()
12922 };
12923 }
12924
12925 9 => {
12926 let _ = unsafe {
12927 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>>()
12928 };
12929 }
12930
12931 _ => unsafe { ::core::hint::unreachable_unchecked() },
12932 }
12933 }
12934 }
12935
12936 impl ::fidl_next::Constrained for UnionWithVector<'_> {
12937 type Constraint = ();
12938
12939 fn validate(
12940 _: ::fidl_next::Slot<'_, Self>,
12941 _: Self::Constraint,
12942 ) -> Result<(), ::fidl_next::ValidationError> {
12943 Ok(())
12944 }
12945 }
12946
12947 unsafe impl ::fidl_next::Wire for UnionWithVector<'static> {
12948 type Narrowed<'de> = UnionWithVector<'de>;
12949
12950 #[inline]
12951 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12952 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12953 ::fidl_next::wire::Union::zero_padding(raw);
12954 }
12955 }
12956
12957 pub mod union_with_vector {
12958 pub enum Ref<'de> {
12959 Unused(&'de u8),
12960
12961 VectorOfUint8(&'de ::fidl_next::wire::Vector<'de, u8>),
12962
12963 S(&'de ::fidl_next::wire::String<'de>),
12964
12965 VectorS3A1(&'de ::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>),
12966
12967 VectorS3A2(&'de ::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>),
12968
12969 Handles(
12970 &'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
12971 ),
12972
12973 ArrayS3A1(&'de [crate::wire::StructSize3Align1; 2]),
12974
12975 ArrayS3A2(&'de [crate::wire::StructSize3Align2; 2]),
12976
12977 VectorUnion(&'de ::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>),
12978 }
12979
12980 pub enum Value<'de> {
12981 Unused(u8),
12982
12983 VectorOfUint8(::fidl_next::wire::Vector<'de, u8>),
12984
12985 S(::fidl_next::wire::String<'de>),
12986
12987 VectorS3A1(::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>),
12988
12989 VectorS3A2(::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>),
12990
12991 Handles(::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>),
12992
12993 ArrayS3A1([crate::wire::StructSize3Align1; 2]),
12994
12995 ArrayS3A2([crate::wire::StructSize3Align2; 2]),
12996
12997 VectorUnion(::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>),
12998 }
12999 }
13000
13001 impl<'de> UnionWithVector<'de> {
13002 pub fn as_ref(&self) -> crate::wire::union_with_vector::Ref<'_> {
13003 match self.raw.ordinal() {
13004 1 => crate::wire::union_with_vector::Ref::Unused(unsafe {
13005 self.raw.get().deref_unchecked::<u8>()
13006 }),
13007
13008 2 => crate::wire::union_with_vector::Ref::VectorOfUint8(unsafe {
13009 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
13010 }),
13011
13012 3 => crate::wire::union_with_vector::Ref::S(unsafe {
13013 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
13014 }),
13015
13016 4 => crate::wire::union_with_vector::Ref::VectorS3A1(unsafe {
13017 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, crate::wire::StructSize3Align1>>()
13018 }),
13019
13020 5 => crate::wire::union_with_vector::Ref::VectorS3A2(unsafe {
13021 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, crate::wire::StructSize3Align2>>()
13022 }),
13023
13024 6 => crate::wire::union_with_vector::Ref::Handles(unsafe {
13025 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::fuchsia::NullableHandle>>()
13026 }),
13027
13028 7 => crate::wire::union_with_vector::Ref::ArrayS3A1(unsafe {
13029 self.raw.get().deref_unchecked::<[crate::wire::StructSize3Align1; 2]>()
13030 }),
13031
13032 8 => crate::wire::union_with_vector::Ref::ArrayS3A2(unsafe {
13033 self.raw.get().deref_unchecked::<[crate::wire::StructSize3Align2; 2]>()
13034 }),
13035
13036 9 => crate::wire::union_with_vector::Ref::VectorUnion(unsafe {
13037 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, crate::wire::UnionSize8Align4>>()
13038 }),
13039
13040 _ => unsafe { ::core::hint::unreachable_unchecked() },
13041 }
13042 }
13043
13044 pub fn into_inner(self) -> crate::wire::union_with_vector::Value<'de> {
13045 let this = ::core::mem::ManuallyDrop::new(self);
13046
13047 match this.raw.ordinal() {
13048 1 => crate::wire::union_with_vector::Value::Unused(unsafe {
13049 this.raw.get().read_unchecked::<u8>()
13050 }),
13051
13052 2 => crate::wire::union_with_vector::Value::VectorOfUint8(unsafe {
13053 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
13054 }),
13055
13056 3 => crate::wire::union_with_vector::Value::S(unsafe {
13057 this.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
13058 }),
13059
13060 4 => crate::wire::union_with_vector::Value::VectorS3A1(unsafe {
13061 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>>()
13062 }),
13063
13064 5 => crate::wire::union_with_vector::Value::VectorS3A2(unsafe {
13065 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>>()
13066 }),
13067
13068 6 => crate::wire::union_with_vector::Value::Handles(unsafe {
13069 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>>()
13070 }),
13071
13072 7 => crate::wire::union_with_vector::Value::ArrayS3A1(unsafe {
13073 this.raw.get().read_unchecked::<[crate::wire::StructSize3Align1; 2]>()
13074 }),
13075
13076 8 => crate::wire::union_with_vector::Value::ArrayS3A2(unsafe {
13077 this.raw.get().read_unchecked::<[crate::wire::StructSize3Align2; 2]>()
13078 }),
13079
13080 9 => crate::wire::union_with_vector::Value::VectorUnion(unsafe {
13081 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>>()
13082 }),
13083
13084 _ => unsafe { ::core::hint::unreachable_unchecked() },
13085 }
13086 }
13087 }
13088
13089 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnionWithVector<'de>
13090 where
13091 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13092 ___D: ::fidl_next::Decoder<'de>,
13093 ___D: ::fidl_next::fuchsia::HandleDecoder,
13094 {
13095 fn decode(
13096 mut slot: ::fidl_next::Slot<'_, Self>,
13097 decoder: &mut ___D,
13098 _: (),
13099 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13100 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13101 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
13102 1 => ::fidl_next::wire::Union::decode_as::<___D, u8>(raw, decoder, ())?,
13103
13104 2 => {
13105 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
13106 raw,
13107 decoder,
13108 (4294967295, ()),
13109 )?
13110 }
13111
13112 3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
13113 raw, decoder, 4294967295,
13114 )?,
13115
13116 4 => ::fidl_next::wire::Union::decode_as::<
13117 ___D,
13118 ::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>,
13119 >(raw, decoder, (4294967295, ()))?,
13120
13121 5 => ::fidl_next::wire::Union::decode_as::<
13122 ___D,
13123 ::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>,
13124 >(raw, decoder, (4294967295, ()))?,
13125
13126 6 => ::fidl_next::wire::Union::decode_as::<
13127 ___D,
13128 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
13129 >(raw, decoder, (4294967295, ()))?,
13130
13131 7 => ::fidl_next::wire::Union::decode_as::<
13132 ___D,
13133 [crate::wire::StructSize3Align1; 2],
13134 >(raw, decoder, ())?,
13135
13136 8 => ::fidl_next::wire::Union::decode_as::<
13137 ___D,
13138 [crate::wire::StructSize3Align2; 2],
13139 >(raw, decoder, ())?,
13140
13141 9 => ::fidl_next::wire::Union::decode_as::<
13142 ___D,
13143 ::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>,
13144 >(raw, decoder, (4294967295, ()))?,
13145
13146 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13147 }
13148
13149 Ok(())
13150 }
13151 }
13152
13153 impl<'de> ::core::fmt::Debug for UnionWithVector<'de> {
13154 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13155 match self.raw.ordinal() {
13156 1 => unsafe { self.raw.get().deref_unchecked::<u8>().fmt(f) },
13157 2 => unsafe {
13158 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
13159 },
13160 3 => unsafe {
13161 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
13162 },
13163 4 => unsafe {
13164 self.raw.get().deref_unchecked::<
13165 ::fidl_next::wire::Vector<'_, crate::wire::StructSize3Align1>
13166 >().fmt(f)
13167 },
13168 5 => unsafe {
13169 self.raw.get().deref_unchecked::<
13170 ::fidl_next::wire::Vector<'_, crate::wire::StructSize3Align2>
13171 >().fmt(f)
13172 },
13173 6 => unsafe {
13174 self.raw.get().deref_unchecked::<
13175 ::fidl_next::wire::Vector<'_, ::fidl_next::wire::fuchsia::NullableHandle>
13176 >().fmt(f)
13177 },
13178 7 => unsafe {
13179 self.raw.get().deref_unchecked::<[crate::wire::StructSize3Align1; 2]>().fmt(f)
13180 },
13181 8 => unsafe {
13182 self.raw.get().deref_unchecked::<[crate::wire::StructSize3Align2; 2]>().fmt(f)
13183 },
13184 9 => unsafe {
13185 self.raw.get().deref_unchecked::<
13186 ::fidl_next::wire::Vector<'_, crate::wire::UnionSize8Align4>
13187 >().fmt(f)
13188 },
13189 _ => unsafe { ::core::hint::unreachable_unchecked() },
13190 }
13191 }
13192 }
13193
13194 impl<'de> ::fidl_next::IntoNatural for UnionWithVector<'de> {
13195 type Natural = crate::natural::UnionWithVector;
13196 }
13197
13198 #[derive(Debug)]
13200 #[repr(C)]
13201 pub struct Sandwich6<'de> {
13202 pub before: ::fidl_next::wire::Uint32,
13203
13204 pub the_union: crate::wire::UnionWithVector<'de>,
13205
13206 pub after: ::fidl_next::wire::Uint32,
13207 }
13208
13209 static_assertions::const_assert_eq!(std::mem::size_of::<Sandwich6<'_>>(), 32);
13210 static_assertions::const_assert_eq!(std::mem::align_of::<Sandwich6<'_>>(), 8);
13211
13212 static_assertions::const_assert_eq!(std::mem::offset_of!(Sandwich6<'_>, before), 0);
13213
13214 static_assertions::const_assert_eq!(std::mem::offset_of!(Sandwich6<'_>, the_union), 8);
13215
13216 static_assertions::const_assert_eq!(std::mem::offset_of!(Sandwich6<'_>, after), 24);
13217
13218 impl ::fidl_next::Constrained for Sandwich6<'_> {
13219 type Constraint = ();
13220
13221 fn validate(
13222 _: ::fidl_next::Slot<'_, Self>,
13223 _: Self::Constraint,
13224 ) -> Result<(), ::fidl_next::ValidationError> {
13225 Ok(())
13226 }
13227 }
13228
13229 unsafe impl ::fidl_next::Wire for Sandwich6<'static> {
13230 type Narrowed<'de> = Sandwich6<'de>;
13231
13232 #[inline]
13233 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13234 ::fidl_next::munge! {
13235 let Self {
13236 before,
13237 the_union,
13238 after,
13239
13240 } = &mut *out_;
13241 }
13242
13243 ::fidl_next::Wire::zero_padding(before);
13244
13245 ::fidl_next::Wire::zero_padding(the_union);
13246
13247 ::fidl_next::Wire::zero_padding(after);
13248
13249 unsafe {
13250 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
13251 }
13252
13253 unsafe {
13254 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
13255 }
13256 }
13257 }
13258
13259 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Sandwich6<'de>
13260 where
13261 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13262 ___D: ::fidl_next::Decoder<'de>,
13263 ___D: ::fidl_next::fuchsia::HandleDecoder,
13264 {
13265 fn decode(
13266 slot_: ::fidl_next::Slot<'_, Self>,
13267 decoder_: &mut ___D,
13268 _: (),
13269 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13270 if slot_.as_bytes()[28..32] != [0u8; 4] {
13271 return Err(::fidl_next::DecodeError::InvalidPadding);
13272 }
13273
13274 if slot_.as_bytes()[4..8] != [0u8; 4] {
13275 return Err(::fidl_next::DecodeError::InvalidPadding);
13276 }
13277
13278 ::fidl_next::munge! {
13279 let Self {
13280 mut before,
13281 mut the_union,
13282 mut after,
13283
13284 } = slot_;
13285 }
13286
13287 let _field = before.as_mut();
13288
13289 ::fidl_next::Decode::decode(before.as_mut(), decoder_, ())?;
13290
13291 let _field = the_union.as_mut();
13292
13293 ::fidl_next::Decode::decode(the_union.as_mut(), decoder_, ())?;
13294
13295 let _field = after.as_mut();
13296
13297 ::fidl_next::Decode::decode(after.as_mut(), decoder_, ())?;
13298
13299 Ok(())
13300 }
13301 }
13302
13303 impl<'de> ::fidl_next::IntoNatural for Sandwich6<'de> {
13304 type Natural = crate::natural::Sandwich6;
13305 }
13306
13307 #[derive(Debug)]
13309 #[repr(C)]
13310 pub struct ShortStringThenHandle<'de> {
13311 pub s: ::fidl_next::wire::String<'de>,
13312
13313 pub h: ::fidl_next::wire::fuchsia::NullableHandle,
13314 }
13315
13316 static_assertions::const_assert_eq!(std::mem::size_of::<ShortStringThenHandle<'_>>(), 24);
13317 static_assertions::const_assert_eq!(std::mem::align_of::<ShortStringThenHandle<'_>>(), 8);
13318
13319 static_assertions::const_assert_eq!(std::mem::offset_of!(ShortStringThenHandle<'_>, s), 0);
13320
13321 static_assertions::const_assert_eq!(std::mem::offset_of!(ShortStringThenHandle<'_>, h), 16);
13322
13323 impl ::fidl_next::Constrained for ShortStringThenHandle<'_> {
13324 type Constraint = ();
13325
13326 fn validate(
13327 _: ::fidl_next::Slot<'_, Self>,
13328 _: Self::Constraint,
13329 ) -> Result<(), ::fidl_next::ValidationError> {
13330 Ok(())
13331 }
13332 }
13333
13334 unsafe impl ::fidl_next::Wire for ShortStringThenHandle<'static> {
13335 type Narrowed<'de> = ShortStringThenHandle<'de>;
13336
13337 #[inline]
13338 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13339 ::fidl_next::munge! {
13340 let Self {
13341 s,
13342 h,
13343
13344 } = &mut *out_;
13345 }
13346
13347 ::fidl_next::Wire::zero_padding(s);
13348
13349 ::fidl_next::Wire::zero_padding(h);
13350
13351 unsafe {
13352 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
13353 }
13354 }
13355 }
13356
13357 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ShortStringThenHandle<'de>
13358 where
13359 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13360 ___D: ::fidl_next::Decoder<'de>,
13361 ___D: ::fidl_next::fuchsia::HandleDecoder,
13362 {
13363 fn decode(
13364 slot_: ::fidl_next::Slot<'_, Self>,
13365 decoder_: &mut ___D,
13366 _: (),
13367 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13368 if slot_.as_bytes()[20..24] != [0u8; 4] {
13369 return Err(::fidl_next::DecodeError::InvalidPadding);
13370 }
13371
13372 ::fidl_next::munge! {
13373 let Self {
13374 mut s,
13375 mut h,
13376
13377 } = slot_;
13378 }
13379
13380 let _field = s.as_mut();
13381 ::fidl_next::Constrained::validate(_field, 1)?;
13382 ::fidl_next::Decode::decode(s.as_mut(), decoder_, 1)?;
13383
13384 let s = unsafe { s.deref_unchecked() };
13385
13386 if s.len() > 1 {
13387 return Err(::fidl_next::DecodeError::VectorTooLong {
13388 size: s.len() as u64,
13389 limit: 1,
13390 });
13391 }
13392
13393 let _field = h.as_mut();
13394
13395 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
13396
13397 Ok(())
13398 }
13399 }
13400
13401 impl<'de> ::fidl_next::IntoNatural for ShortStringThenHandle<'de> {
13402 type Natural = crate::natural::ShortStringThenHandle;
13403 }
13404
13405 #[repr(C)]
13407 pub struct SimpleResourceTable<'de> {
13408 pub(crate) table: ::fidl_next::wire::Table<'de>,
13409 }
13410
13411 impl<'de> Drop for SimpleResourceTable<'de> {
13412 fn drop(&mut self) {
13413 let _ = self
13414 .table
13415 .get(1)
13416 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
13417
13418 let _ = self
13419 .table
13420 .get(5)
13421 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
13422 }
13423 }
13424
13425 impl ::fidl_next::Constrained for SimpleResourceTable<'_> {
13426 type Constraint = ();
13427
13428 fn validate(
13429 _: ::fidl_next::Slot<'_, Self>,
13430 _: Self::Constraint,
13431 ) -> Result<(), ::fidl_next::ValidationError> {
13432 Ok(())
13433 }
13434 }
13435
13436 unsafe impl ::fidl_next::Wire for SimpleResourceTable<'static> {
13437 type Narrowed<'de> = SimpleResourceTable<'de>;
13438
13439 #[inline]
13440 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13441 ::fidl_next::munge!(let Self { table } = out);
13442 ::fidl_next::wire::Table::zero_padding(table);
13443 }
13444 }
13445
13446 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SimpleResourceTable<'de>
13447 where
13448 ___D: ::fidl_next::Decoder<'de> + ?Sized,
13449 ___D: ::fidl_next::fuchsia::HandleDecoder,
13450 {
13451 fn decode(
13452 slot: ::fidl_next::Slot<'_, Self>,
13453 decoder: &mut ___D,
13454 _: (),
13455 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13456 ::fidl_next::munge!(let Self { table } = slot);
13457
13458 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13459 match ordinal {
13460 0 => unsafe { ::core::hint::unreachable_unchecked() },
13461
13462 1 => {
13463 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
13464 slot.as_mut(),
13465 decoder,
13466 (),
13467 )?;
13468
13469 Ok(())
13470 }
13471
13472 5 => {
13473 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
13474 slot.as_mut(),
13475 decoder,
13476 (),
13477 )?;
13478
13479 Ok(())
13480 }
13481
13482 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13483 }
13484 })
13485 }
13486 }
13487
13488 impl<'de> SimpleResourceTable<'de> {
13489 pub fn x(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
13490 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13491 }
13492
13493 pub fn take_x(&mut self) -> ::core::option::Option<::fidl_next::wire::Int64> {
13494 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13495 }
13496
13497 pub fn y(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
13498 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
13499 }
13500
13501 pub fn take_y(&mut self) -> ::core::option::Option<::fidl_next::wire::Int64> {
13502 unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
13503 }
13504 }
13505
13506 impl<'de> ::core::fmt::Debug for SimpleResourceTable<'de> {
13507 fn fmt(
13508 &self,
13509 f: &mut ::core::fmt::Formatter<'_>,
13510 ) -> ::core::result::Result<(), ::core::fmt::Error> {
13511 f.debug_struct("SimpleResourceTable")
13512 .field("x", &self.x())
13513 .field("y", &self.y())
13514 .finish()
13515 }
13516 }
13517
13518 impl<'de> ::fidl_next::IntoNatural for SimpleResourceTable<'de> {
13519 type Natural = crate::natural::SimpleResourceTable;
13520 }
13521
13522 #[derive(Debug)]
13524 #[repr(C)]
13525 pub struct SingleHandle {
13526 pub h: ::fidl_next::wire::fuchsia::NullableHandle,
13527 }
13528
13529 static_assertions::const_assert_eq!(std::mem::size_of::<SingleHandle>(), 4);
13530 static_assertions::const_assert_eq!(std::mem::align_of::<SingleHandle>(), 4);
13531
13532 static_assertions::const_assert_eq!(std::mem::offset_of!(SingleHandle, h), 0);
13533
13534 impl ::fidl_next::Constrained for SingleHandle {
13535 type Constraint = ();
13536
13537 fn validate(
13538 _: ::fidl_next::Slot<'_, Self>,
13539 _: Self::Constraint,
13540 ) -> Result<(), ::fidl_next::ValidationError> {
13541 Ok(())
13542 }
13543 }
13544
13545 unsafe impl ::fidl_next::Wire for SingleHandle {
13546 type Narrowed<'de> = SingleHandle;
13547
13548 #[inline]
13549 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13550 ::fidl_next::munge! {
13551 let Self {
13552 h,
13553
13554 } = &mut *out_;
13555 }
13556
13557 ::fidl_next::Wire::zero_padding(h);
13558 }
13559 }
13560
13561 unsafe impl<___D> ::fidl_next::Decode<___D> for SingleHandle
13562 where
13563 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13564 ___D: ::fidl_next::fuchsia::HandleDecoder,
13565 {
13566 fn decode(
13567 slot_: ::fidl_next::Slot<'_, Self>,
13568 decoder_: &mut ___D,
13569 _: (),
13570 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13571 ::fidl_next::munge! {
13572 let Self {
13573 mut h,
13574
13575 } = slot_;
13576 }
13577
13578 let _field = h.as_mut();
13579
13580 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
13581
13582 Ok(())
13583 }
13584 }
13585
13586 impl ::fidl_next::IntoNatural for SingleHandle {
13587 type Natural = crate::natural::SingleHandle;
13588 }
13589
13590 #[derive(Debug)]
13592 #[repr(C)]
13593 pub struct SingleOptionalHandle {
13594 pub h: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
13595 }
13596
13597 static_assertions::const_assert_eq!(std::mem::size_of::<SingleOptionalHandle>(), 4);
13598 static_assertions::const_assert_eq!(std::mem::align_of::<SingleOptionalHandle>(), 4);
13599
13600 static_assertions::const_assert_eq!(std::mem::offset_of!(SingleOptionalHandle, h), 0);
13601
13602 impl ::fidl_next::Constrained for SingleOptionalHandle {
13603 type Constraint = ();
13604
13605 fn validate(
13606 _: ::fidl_next::Slot<'_, Self>,
13607 _: Self::Constraint,
13608 ) -> Result<(), ::fidl_next::ValidationError> {
13609 Ok(())
13610 }
13611 }
13612
13613 unsafe impl ::fidl_next::Wire for SingleOptionalHandle {
13614 type Narrowed<'de> = SingleOptionalHandle;
13615
13616 #[inline]
13617 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13618 ::fidl_next::munge! {
13619 let Self {
13620 h,
13621
13622 } = &mut *out_;
13623 }
13624
13625 ::fidl_next::Wire::zero_padding(h);
13626 }
13627 }
13628
13629 unsafe impl<___D> ::fidl_next::Decode<___D> for SingleOptionalHandle
13630 where
13631 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13632 ___D: ::fidl_next::fuchsia::HandleDecoder,
13633 {
13634 fn decode(
13635 slot_: ::fidl_next::Slot<'_, Self>,
13636 decoder_: &mut ___D,
13637 _: (),
13638 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13639 ::fidl_next::munge! {
13640 let Self {
13641 mut h,
13642
13643 } = slot_;
13644 }
13645
13646 let _field = h.as_mut();
13647
13648 ::fidl_next::Decode::decode(h.as_mut(), decoder_, ())?;
13649
13650 Ok(())
13651 }
13652 }
13653
13654 impl ::fidl_next::IntoNatural for SingleOptionalHandle {
13655 type Natural = crate::natural::SingleOptionalHandle;
13656 }
13657
13658 #[derive(Debug)]
13660 #[repr(C)]
13661 pub struct StructOfEndpoints {
13662 pub client_end:
13663 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
13664
13665 pub optional_client_end:
13666 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::OptionalChannel>,
13667
13668 pub server_end:
13669 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
13670
13671 pub optional_server_end:
13672 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::OptionalChannel>,
13673 }
13674
13675 static_assertions::const_assert_eq!(std::mem::size_of::<StructOfEndpoints>(), 16);
13676 static_assertions::const_assert_eq!(std::mem::align_of::<StructOfEndpoints>(), 4);
13677
13678 static_assertions::const_assert_eq!(std::mem::offset_of!(StructOfEndpoints, client_end), 0);
13679
13680 static_assertions::const_assert_eq!(
13681 std::mem::offset_of!(StructOfEndpoints, optional_client_end),
13682 4
13683 );
13684
13685 static_assertions::const_assert_eq!(std::mem::offset_of!(StructOfEndpoints, server_end), 8);
13686
13687 static_assertions::const_assert_eq!(
13688 std::mem::offset_of!(StructOfEndpoints, optional_server_end),
13689 12
13690 );
13691
13692 impl ::fidl_next::Constrained for StructOfEndpoints {
13693 type Constraint = ();
13694
13695 fn validate(
13696 _: ::fidl_next::Slot<'_, Self>,
13697 _: Self::Constraint,
13698 ) -> Result<(), ::fidl_next::ValidationError> {
13699 Ok(())
13700 }
13701 }
13702
13703 unsafe impl ::fidl_next::Wire for StructOfEndpoints {
13704 type Narrowed<'de> = StructOfEndpoints;
13705
13706 #[inline]
13707 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13708 ::fidl_next::munge! {
13709 let Self {
13710 client_end,
13711 optional_client_end,
13712 server_end,
13713 optional_server_end,
13714
13715 } = &mut *out_;
13716 }
13717
13718 ::fidl_next::Wire::zero_padding(client_end);
13719
13720 ::fidl_next::Wire::zero_padding(optional_client_end);
13721
13722 ::fidl_next::Wire::zero_padding(server_end);
13723
13724 ::fidl_next::Wire::zero_padding(optional_server_end);
13725 }
13726 }
13727
13728 unsafe impl<___D> ::fidl_next::Decode<___D> for StructOfEndpoints
13729 where
13730 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13731 ___D: ::fidl_next::fuchsia::HandleDecoder,
13732 {
13733 fn decode(
13734 slot_: ::fidl_next::Slot<'_, Self>,
13735 decoder_: &mut ___D,
13736 _: (),
13737 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13738 ::fidl_next::munge! {
13739 let Self {
13740 mut client_end,
13741 mut optional_client_end,
13742 mut server_end,
13743 mut optional_server_end,
13744
13745 } = slot_;
13746 }
13747
13748 let _field = client_end.as_mut();
13749
13750 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
13751
13752 let _field = optional_client_end.as_mut();
13753
13754 ::fidl_next::Decode::decode(optional_client_end.as_mut(), decoder_, ())?;
13755
13756 let _field = server_end.as_mut();
13757
13758 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
13759
13760 let _field = optional_server_end.as_mut();
13761
13762 ::fidl_next::Decode::decode(optional_server_end.as_mut(), decoder_, ())?;
13763
13764 Ok(())
13765 }
13766 }
13767
13768 impl ::fidl_next::IntoNatural for StructOfEndpoints {
13769 type Natural = crate::natural::StructOfEndpoints;
13770 }
13771
13772 #[derive(Debug)]
13774 #[repr(C)]
13775 pub struct StructOfOptionalUnionOfHandle {
13776 pub u: crate::wire_optional::UnionOfHandle,
13777 }
13778
13779 static_assertions::const_assert_eq!(std::mem::size_of::<StructOfOptionalUnionOfHandle>(), 16);
13780 static_assertions::const_assert_eq!(std::mem::align_of::<StructOfOptionalUnionOfHandle>(), 8);
13781
13782 static_assertions::const_assert_eq!(std::mem::offset_of!(StructOfOptionalUnionOfHandle, u), 0);
13783
13784 impl ::fidl_next::Constrained for StructOfOptionalUnionOfHandle {
13785 type Constraint = ();
13786
13787 fn validate(
13788 _: ::fidl_next::Slot<'_, Self>,
13789 _: Self::Constraint,
13790 ) -> Result<(), ::fidl_next::ValidationError> {
13791 Ok(())
13792 }
13793 }
13794
13795 unsafe impl ::fidl_next::Wire for StructOfOptionalUnionOfHandle {
13796 type Narrowed<'de> = StructOfOptionalUnionOfHandle;
13797
13798 #[inline]
13799 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13800 ::fidl_next::munge! {
13801 let Self {
13802 u,
13803
13804 } = &mut *out_;
13805 }
13806
13807 ::fidl_next::Wire::zero_padding(u);
13808 }
13809 }
13810
13811 unsafe impl<___D> ::fidl_next::Decode<___D> for StructOfOptionalUnionOfHandle
13812 where
13813 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13814 ___D: ::fidl_next::fuchsia::HandleDecoder,
13815 {
13816 fn decode(
13817 slot_: ::fidl_next::Slot<'_, Self>,
13818 decoder_: &mut ___D,
13819 _: (),
13820 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13821 ::fidl_next::munge! {
13822 let Self {
13823 mut u,
13824
13825 } = slot_;
13826 }
13827
13828 let _field = u.as_mut();
13829
13830 ::fidl_next::Decode::decode(u.as_mut(), decoder_, ())?;
13831
13832 Ok(())
13833 }
13834 }
13835
13836 impl ::fidl_next::IntoNatural for StructOfOptionalUnionOfHandle {
13837 type Natural = crate::natural::StructOfOptionalUnionOfHandle;
13838 }
13839
13840 #[derive(Debug)]
13842 #[repr(C)]
13843 pub struct StructOfSimpleResourceTable<'de> {
13844 pub table: crate::wire::SimpleResourceTable<'de>,
13845 }
13846
13847 static_assertions::const_assert_eq!(std::mem::size_of::<StructOfSimpleResourceTable<'_>>(), 16);
13848 static_assertions::const_assert_eq!(std::mem::align_of::<StructOfSimpleResourceTable<'_>>(), 8);
13849
13850 static_assertions::const_assert_eq!(
13851 std::mem::offset_of!(StructOfSimpleResourceTable<'_>, table),
13852 0
13853 );
13854
13855 impl ::fidl_next::Constrained for StructOfSimpleResourceTable<'_> {
13856 type Constraint = ();
13857
13858 fn validate(
13859 _: ::fidl_next::Slot<'_, Self>,
13860 _: Self::Constraint,
13861 ) -> Result<(), ::fidl_next::ValidationError> {
13862 Ok(())
13863 }
13864 }
13865
13866 unsafe impl ::fidl_next::Wire for StructOfSimpleResourceTable<'static> {
13867 type Narrowed<'de> = StructOfSimpleResourceTable<'de>;
13868
13869 #[inline]
13870 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13871 ::fidl_next::munge! {
13872 let Self {
13873 table,
13874
13875 } = &mut *out_;
13876 }
13877
13878 ::fidl_next::Wire::zero_padding(table);
13879 }
13880 }
13881
13882 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StructOfSimpleResourceTable<'de>
13883 where
13884 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13885 ___D: ::fidl_next::Decoder<'de>,
13886 ___D: ::fidl_next::fuchsia::HandleDecoder,
13887 {
13888 fn decode(
13889 slot_: ::fidl_next::Slot<'_, Self>,
13890 decoder_: &mut ___D,
13891 _: (),
13892 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13893 ::fidl_next::munge! {
13894 let Self {
13895 mut table,
13896
13897 } = slot_;
13898 }
13899
13900 let _field = table.as_mut();
13901
13902 ::fidl_next::Decode::decode(table.as_mut(), decoder_, ())?;
13903
13904 Ok(())
13905 }
13906 }
13907
13908 impl<'de> ::fidl_next::IntoNatural for StructOfSimpleResourceTable<'de> {
13909 type Natural = crate::natural::StructOfSimpleResourceTable;
13910 }
13911
13912 #[repr(C)]
13914 pub struct TableFieldInlinedHandle<'de> {
13915 pub(crate) table: ::fidl_next::wire::Table<'de>,
13916 }
13917
13918 impl<'de> Drop for TableFieldInlinedHandle<'de> {
13919 fn drop(&mut self) {
13920 let _ = self.table.get(1).map(|envelope| unsafe {
13921 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
13922 });
13923 }
13924 }
13925
13926 impl ::fidl_next::Constrained for TableFieldInlinedHandle<'_> {
13927 type Constraint = ();
13928
13929 fn validate(
13930 _: ::fidl_next::Slot<'_, Self>,
13931 _: Self::Constraint,
13932 ) -> Result<(), ::fidl_next::ValidationError> {
13933 Ok(())
13934 }
13935 }
13936
13937 unsafe impl ::fidl_next::Wire for TableFieldInlinedHandle<'static> {
13938 type Narrowed<'de> = TableFieldInlinedHandle<'de>;
13939
13940 #[inline]
13941 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13942 ::fidl_next::munge!(let Self { table } = out);
13943 ::fidl_next::wire::Table::zero_padding(table);
13944 }
13945 }
13946
13947 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableFieldInlinedHandle<'de>
13948 where
13949 ___D: ::fidl_next::Decoder<'de> + ?Sized,
13950 ___D: ::fidl_next::fuchsia::HandleDecoder,
13951 {
13952 fn decode(
13953 slot: ::fidl_next::Slot<'_, Self>,
13954 decoder: &mut ___D,
13955 _: (),
13956 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13957 ::fidl_next::munge!(let Self { table } = slot);
13958
13959 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13960 match ordinal {
13961 0 => unsafe { ::core::hint::unreachable_unchecked() },
13962
13963 1 => {
13964 ::fidl_next::wire::Envelope::decode_as::<
13965 ___D,
13966 ::fidl_next::wire::fuchsia::Channel,
13967 >(slot.as_mut(), decoder, ())?;
13968
13969 Ok(())
13970 }
13971
13972 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13973 }
13974 })
13975 }
13976 }
13977
13978 impl<'de> TableFieldInlinedHandle<'de> {
13979 pub fn f(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
13980 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13981 }
13982
13983 pub fn take_f(&mut self) -> ::core::option::Option<::fidl_next::wire::fuchsia::Channel> {
13984 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13985 }
13986 }
13987
13988 impl<'de> ::core::fmt::Debug for TableFieldInlinedHandle<'de> {
13989 fn fmt(
13990 &self,
13991 f: &mut ::core::fmt::Formatter<'_>,
13992 ) -> ::core::result::Result<(), ::core::fmt::Error> {
13993 f.debug_struct("TableFieldInlinedHandle").field("f", &self.f()).finish()
13994 }
13995 }
13996
13997 impl<'de> ::fidl_next::IntoNatural for TableFieldInlinedHandle<'de> {
13998 type Natural = crate::natural::TableFieldInlinedHandle;
13999 }
14000
14001 #[derive(Debug)]
14003 #[repr(C)]
14004 pub struct TableFieldInlinedHandleStruct<'de> {
14005 pub t: crate::wire::TableFieldInlinedHandle<'de>,
14006 }
14007
14008 static_assertions::const_assert_eq!(
14009 std::mem::size_of::<TableFieldInlinedHandleStruct<'_>>(),
14010 16
14011 );
14012 static_assertions::const_assert_eq!(
14013 std::mem::align_of::<TableFieldInlinedHandleStruct<'_>>(),
14014 8
14015 );
14016
14017 static_assertions::const_assert_eq!(
14018 std::mem::offset_of!(TableFieldInlinedHandleStruct<'_>, t),
14019 0
14020 );
14021
14022 impl ::fidl_next::Constrained for TableFieldInlinedHandleStruct<'_> {
14023 type Constraint = ();
14024
14025 fn validate(
14026 _: ::fidl_next::Slot<'_, Self>,
14027 _: Self::Constraint,
14028 ) -> Result<(), ::fidl_next::ValidationError> {
14029 Ok(())
14030 }
14031 }
14032
14033 unsafe impl ::fidl_next::Wire for TableFieldInlinedHandleStruct<'static> {
14034 type Narrowed<'de> = TableFieldInlinedHandleStruct<'de>;
14035
14036 #[inline]
14037 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14038 ::fidl_next::munge! {
14039 let Self {
14040 t,
14041
14042 } = &mut *out_;
14043 }
14044
14045 ::fidl_next::Wire::zero_padding(t);
14046 }
14047 }
14048
14049 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableFieldInlinedHandleStruct<'de>
14050 where
14051 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14052 ___D: ::fidl_next::Decoder<'de>,
14053 ___D: ::fidl_next::fuchsia::HandleDecoder,
14054 {
14055 fn decode(
14056 slot_: ::fidl_next::Slot<'_, Self>,
14057 decoder_: &mut ___D,
14058 _: (),
14059 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14060 ::fidl_next::munge! {
14061 let Self {
14062 mut t,
14063
14064 } = slot_;
14065 }
14066
14067 let _field = t.as_mut();
14068
14069 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
14070
14071 Ok(())
14072 }
14073 }
14074
14075 impl<'de> ::fidl_next::IntoNatural for TableFieldInlinedHandleStruct<'de> {
14076 type Natural = crate::natural::TableFieldInlinedHandleStruct;
14077 }
14078
14079 #[repr(C)]
14081 pub struct TableFieldUnknownResource<'de> {
14082 pub(crate) table: ::fidl_next::wire::Table<'de>,
14083 }
14084
14085 impl<'de> Drop for TableFieldUnknownResource<'de> {
14086 fn drop(&mut self) {}
14087 }
14088
14089 impl ::fidl_next::Constrained for TableFieldUnknownResource<'_> {
14090 type Constraint = ();
14091
14092 fn validate(
14093 _: ::fidl_next::Slot<'_, Self>,
14094 _: Self::Constraint,
14095 ) -> Result<(), ::fidl_next::ValidationError> {
14096 Ok(())
14097 }
14098 }
14099
14100 unsafe impl ::fidl_next::Wire for TableFieldUnknownResource<'static> {
14101 type Narrowed<'de> = TableFieldUnknownResource<'de>;
14102
14103 #[inline]
14104 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14105 ::fidl_next::munge!(let Self { table } = out);
14106 ::fidl_next::wire::Table::zero_padding(table);
14107 }
14108 }
14109
14110 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableFieldUnknownResource<'de>
14111 where
14112 ___D: ::fidl_next::Decoder<'de> + ?Sized,
14113 ___D: ::fidl_next::fuchsia::HandleDecoder,
14114 {
14115 fn decode(
14116 slot: ::fidl_next::Slot<'_, Self>,
14117 decoder: &mut ___D,
14118 _: (),
14119 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14120 ::fidl_next::munge!(let Self { table } = slot);
14121
14122 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14123 match ordinal {
14124 0 => unsafe { ::core::hint::unreachable_unchecked() },
14125
14126 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14127 }
14128 })
14129 }
14130 }
14131
14132 impl<'de> TableFieldUnknownResource<'de> {}
14133
14134 impl<'de> ::core::fmt::Debug for TableFieldUnknownResource<'de> {
14135 fn fmt(
14136 &self,
14137 f: &mut ::core::fmt::Formatter<'_>,
14138 ) -> ::core::result::Result<(), ::core::fmt::Error> {
14139 f.debug_struct("TableFieldUnknownResource").finish()
14140 }
14141 }
14142
14143 impl<'de> ::fidl_next::IntoNatural for TableFieldUnknownResource<'de> {
14144 type Natural = crate::natural::TableFieldUnknownResource;
14145 }
14146
14147 #[derive(Debug)]
14149 #[repr(C)]
14150 pub struct TableFieldUnknownResourceStruct<'de> {
14151 pub t: crate::wire::TableFieldUnknownResource<'de>,
14152 }
14153
14154 static_assertions::const_assert_eq!(
14155 std::mem::size_of::<TableFieldUnknownResourceStruct<'_>>(),
14156 16
14157 );
14158 static_assertions::const_assert_eq!(
14159 std::mem::align_of::<TableFieldUnknownResourceStruct<'_>>(),
14160 8
14161 );
14162
14163 static_assertions::const_assert_eq!(
14164 std::mem::offset_of!(TableFieldUnknownResourceStruct<'_>, t),
14165 0
14166 );
14167
14168 impl ::fidl_next::Constrained for TableFieldUnknownResourceStruct<'_> {
14169 type Constraint = ();
14170
14171 fn validate(
14172 _: ::fidl_next::Slot<'_, Self>,
14173 _: Self::Constraint,
14174 ) -> Result<(), ::fidl_next::ValidationError> {
14175 Ok(())
14176 }
14177 }
14178
14179 unsafe impl ::fidl_next::Wire for TableFieldUnknownResourceStruct<'static> {
14180 type Narrowed<'de> = TableFieldUnknownResourceStruct<'de>;
14181
14182 #[inline]
14183 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14184 ::fidl_next::munge! {
14185 let Self {
14186 t,
14187
14188 } = &mut *out_;
14189 }
14190
14191 ::fidl_next::Wire::zero_padding(t);
14192 }
14193 }
14194
14195 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableFieldUnknownResourceStruct<'de>
14196 where
14197 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14198 ___D: ::fidl_next::Decoder<'de>,
14199 ___D: ::fidl_next::fuchsia::HandleDecoder,
14200 {
14201 fn decode(
14202 slot_: ::fidl_next::Slot<'_, Self>,
14203 decoder_: &mut ___D,
14204 _: (),
14205 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14206 ::fidl_next::munge! {
14207 let Self {
14208 mut t,
14209
14210 } = slot_;
14211 }
14212
14213 let _field = t.as_mut();
14214
14215 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
14216
14217 Ok(())
14218 }
14219 }
14220
14221 impl<'de> ::fidl_next::IntoNatural for TableFieldUnknownResourceStruct<'de> {
14222 type Natural = crate::natural::TableFieldUnknownResourceStruct;
14223 }
14224
14225 #[repr(C)]
14227 pub struct TableOfEndpointsTable<'de> {
14228 pub(crate) table: ::fidl_next::wire::Table<'de>,
14229 }
14230
14231 impl<'de> Drop for TableOfEndpointsTable<'de> {
14232 fn drop(&mut self) {
14233 let _ = self.table.get(1)
14234 .map(|envelope| unsafe {
14235 envelope.read_unchecked::<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
14236 });
14237
14238 let _ = self.table.get(2)
14239 .map(|envelope| unsafe {
14240 envelope.read_unchecked::<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
14241 });
14242 }
14243 }
14244
14245 impl ::fidl_next::Constrained for TableOfEndpointsTable<'_> {
14246 type Constraint = ();
14247
14248 fn validate(
14249 _: ::fidl_next::Slot<'_, Self>,
14250 _: Self::Constraint,
14251 ) -> Result<(), ::fidl_next::ValidationError> {
14252 Ok(())
14253 }
14254 }
14255
14256 unsafe impl ::fidl_next::Wire for TableOfEndpointsTable<'static> {
14257 type Narrowed<'de> = TableOfEndpointsTable<'de>;
14258
14259 #[inline]
14260 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14261 ::fidl_next::munge!(let Self { table } = out);
14262 ::fidl_next::wire::Table::zero_padding(table);
14263 }
14264 }
14265
14266 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableOfEndpointsTable<'de>
14267 where
14268 ___D: ::fidl_next::Decoder<'de> + ?Sized,
14269 ___D: ::fidl_next::fuchsia::HandleDecoder,
14270 {
14271 fn decode(
14272 slot: ::fidl_next::Slot<'_, Self>,
14273 decoder: &mut ___D,
14274 _: (),
14275 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14276 ::fidl_next::munge!(let Self { table } = slot);
14277
14278 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14279 match ordinal {
14280 0 => unsafe { ::core::hint::unreachable_unchecked() },
14281
14282 1 => {
14283 ::fidl_next::wire::Envelope::decode_as::<
14284 ___D,
14285 ::fidl_next::ClientEnd<
14286 crate::Protocol,
14287 ::fidl_next::wire::fuchsia::Channel,
14288 >,
14289 >(slot.as_mut(), decoder, ())?;
14290
14291 Ok(())
14292 }
14293
14294 2 => {
14295 ::fidl_next::wire::Envelope::decode_as::<
14296 ___D,
14297 ::fidl_next::ServerEnd<
14298 crate::Protocol,
14299 ::fidl_next::wire::fuchsia::Channel,
14300 >,
14301 >(slot.as_mut(), decoder, ())?;
14302
14303 Ok(())
14304 }
14305
14306 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14307 }
14308 })
14309 }
14310 }
14311
14312 impl<'de> TableOfEndpointsTable<'de> {
14313 pub fn client_end(
14314 &self,
14315 ) -> ::core::option::Option<
14316 &::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
14317 > {
14318 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14319 }
14320
14321 pub fn take_client_end(
14322 &mut self,
14323 ) -> ::core::option::Option<
14324 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
14325 > {
14326 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14327 }
14328
14329 pub fn server_end(
14330 &self,
14331 ) -> ::core::option::Option<
14332 &::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
14333 > {
14334 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14335 }
14336
14337 pub fn take_server_end(
14338 &mut self,
14339 ) -> ::core::option::Option<
14340 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
14341 > {
14342 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14343 }
14344 }
14345
14346 impl<'de> ::core::fmt::Debug for TableOfEndpointsTable<'de> {
14347 fn fmt(
14348 &self,
14349 f: &mut ::core::fmt::Formatter<'_>,
14350 ) -> ::core::result::Result<(), ::core::fmt::Error> {
14351 f.debug_struct("TableOfEndpointsTable")
14352 .field("client_end", &self.client_end())
14353 .field("server_end", &self.server_end())
14354 .finish()
14355 }
14356 }
14357
14358 impl<'de> ::fidl_next::IntoNatural for TableOfEndpointsTable<'de> {
14359 type Natural = crate::natural::TableOfEndpointsTable;
14360 }
14361
14362 #[derive(Debug)]
14364 #[repr(C)]
14365 pub struct TableOfEndpoints<'de> {
14366 pub t: crate::wire::TableOfEndpointsTable<'de>,
14367 }
14368
14369 static_assertions::const_assert_eq!(std::mem::size_of::<TableOfEndpoints<'_>>(), 16);
14370 static_assertions::const_assert_eq!(std::mem::align_of::<TableOfEndpoints<'_>>(), 8);
14371
14372 static_assertions::const_assert_eq!(std::mem::offset_of!(TableOfEndpoints<'_>, t), 0);
14373
14374 impl ::fidl_next::Constrained for TableOfEndpoints<'_> {
14375 type Constraint = ();
14376
14377 fn validate(
14378 _: ::fidl_next::Slot<'_, Self>,
14379 _: Self::Constraint,
14380 ) -> Result<(), ::fidl_next::ValidationError> {
14381 Ok(())
14382 }
14383 }
14384
14385 unsafe impl ::fidl_next::Wire for TableOfEndpoints<'static> {
14386 type Narrowed<'de> = TableOfEndpoints<'de>;
14387
14388 #[inline]
14389 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14390 ::fidl_next::munge! {
14391 let Self {
14392 t,
14393
14394 } = &mut *out_;
14395 }
14396
14397 ::fidl_next::Wire::zero_padding(t);
14398 }
14399 }
14400
14401 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableOfEndpoints<'de>
14402 where
14403 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14404 ___D: ::fidl_next::Decoder<'de>,
14405 ___D: ::fidl_next::fuchsia::HandleDecoder,
14406 {
14407 fn decode(
14408 slot_: ::fidl_next::Slot<'_, Self>,
14409 decoder_: &mut ___D,
14410 _: (),
14411 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14412 ::fidl_next::munge! {
14413 let Self {
14414 mut t,
14415
14416 } = slot_;
14417 }
14418
14419 let _field = t.as_mut();
14420
14421 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
14422
14423 Ok(())
14424 }
14425 }
14426
14427 impl<'de> ::fidl_next::IntoNatural for TableOfEndpoints<'de> {
14428 type Natural = crate::natural::TableOfEndpoints;
14429 }
14430
14431 #[repr(C)]
14433 pub struct TableUnionWithVectorReservedSandwich<'de> {
14434 pub(crate) table: ::fidl_next::wire::Table<'de>,
14435 }
14436
14437 impl<'de> Drop for TableUnionWithVectorReservedSandwich<'de> {
14438 fn drop(&mut self) {
14439 let _ = self.table.get(2).map(|envelope| unsafe {
14440 envelope.read_unchecked::<crate::wire::UnionWithVector<'de>>()
14441 });
14442 }
14443 }
14444
14445 impl ::fidl_next::Constrained for TableUnionWithVectorReservedSandwich<'_> {
14446 type Constraint = ();
14447
14448 fn validate(
14449 _: ::fidl_next::Slot<'_, Self>,
14450 _: Self::Constraint,
14451 ) -> Result<(), ::fidl_next::ValidationError> {
14452 Ok(())
14453 }
14454 }
14455
14456 unsafe impl ::fidl_next::Wire for TableUnionWithVectorReservedSandwich<'static> {
14457 type Narrowed<'de> = TableUnionWithVectorReservedSandwich<'de>;
14458
14459 #[inline]
14460 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14461 ::fidl_next::munge!(let Self { table } = out);
14462 ::fidl_next::wire::Table::zero_padding(table);
14463 }
14464 }
14465
14466 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableUnionWithVectorReservedSandwich<'de>
14467 where
14468 ___D: ::fidl_next::Decoder<'de> + ?Sized,
14469 ___D: ::fidl_next::fuchsia::HandleDecoder,
14470 {
14471 fn decode(
14472 slot: ::fidl_next::Slot<'_, Self>,
14473 decoder: &mut ___D,
14474 _: (),
14475 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14476 ::fidl_next::munge!(let Self { table } = slot);
14477
14478 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14479 match ordinal {
14480 0 => unsafe { ::core::hint::unreachable_unchecked() },
14481
14482 2 => {
14483 ::fidl_next::wire::Envelope::decode_as::<
14484 ___D,
14485 crate::wire::UnionWithVector<'de>,
14486 >(slot.as_mut(), decoder, ())?;
14487
14488 Ok(())
14489 }
14490
14491 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14492 }
14493 })
14494 }
14495 }
14496
14497 impl<'de> TableUnionWithVectorReservedSandwich<'de> {
14498 pub fn uv(&self) -> ::core::option::Option<&crate::wire::UnionWithVector<'de>> {
14499 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14500 }
14501
14502 pub fn take_uv(&mut self) -> ::core::option::Option<crate::wire::UnionWithVector<'de>> {
14503 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14504 }
14505 }
14506
14507 impl<'de> ::core::fmt::Debug for TableUnionWithVectorReservedSandwich<'de> {
14508 fn fmt(
14509 &self,
14510 f: &mut ::core::fmt::Formatter<'_>,
14511 ) -> ::core::result::Result<(), ::core::fmt::Error> {
14512 f.debug_struct("TableUnionWithVectorReservedSandwich").field("uv", &self.uv()).finish()
14513 }
14514 }
14515
14516 impl<'de> ::fidl_next::IntoNatural for TableUnionWithVectorReservedSandwich<'de> {
14517 type Natural = crate::natural::TableUnionWithVectorReservedSandwich;
14518 }
14519
14520 #[derive(Debug)]
14522 #[repr(C)]
14523 pub struct TableUnionWithVectorReservedSandwichStruct<'de> {
14524 pub table: crate::wire::TableUnionWithVectorReservedSandwich<'de>,
14525 }
14526
14527 static_assertions::const_assert_eq!(
14528 std::mem::size_of::<TableUnionWithVectorReservedSandwichStruct<'_>>(),
14529 16
14530 );
14531 static_assertions::const_assert_eq!(
14532 std::mem::align_of::<TableUnionWithVectorReservedSandwichStruct<'_>>(),
14533 8
14534 );
14535
14536 static_assertions::const_assert_eq!(
14537 std::mem::offset_of!(TableUnionWithVectorReservedSandwichStruct<'_>, table),
14538 0
14539 );
14540
14541 impl ::fidl_next::Constrained for TableUnionWithVectorReservedSandwichStruct<'_> {
14542 type Constraint = ();
14543
14544 fn validate(
14545 _: ::fidl_next::Slot<'_, Self>,
14546 _: Self::Constraint,
14547 ) -> Result<(), ::fidl_next::ValidationError> {
14548 Ok(())
14549 }
14550 }
14551
14552 unsafe impl ::fidl_next::Wire for TableUnionWithVectorReservedSandwichStruct<'static> {
14553 type Narrowed<'de> = TableUnionWithVectorReservedSandwichStruct<'de>;
14554
14555 #[inline]
14556 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14557 ::fidl_next::munge! {
14558 let Self {
14559 table,
14560
14561 } = &mut *out_;
14562 }
14563
14564 ::fidl_next::Wire::zero_padding(table);
14565 }
14566 }
14567
14568 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableUnionWithVectorReservedSandwichStruct<'de>
14569 where
14570 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14571 ___D: ::fidl_next::Decoder<'de>,
14572 ___D: ::fidl_next::fuchsia::HandleDecoder,
14573 {
14574 fn decode(
14575 slot_: ::fidl_next::Slot<'_, Self>,
14576 decoder_: &mut ___D,
14577 _: (),
14578 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14579 ::fidl_next::munge! {
14580 let Self {
14581 mut table,
14582
14583 } = slot_;
14584 }
14585
14586 let _field = table.as_mut();
14587
14588 ::fidl_next::Decode::decode(table.as_mut(), decoder_, ())?;
14589
14590 Ok(())
14591 }
14592 }
14593
14594 impl<'de> ::fidl_next::IntoNatural for TableUnionWithVectorReservedSandwichStruct<'de> {
14595 type Natural = crate::natural::TableUnionWithVectorReservedSandwichStruct;
14596 }
14597
14598 #[repr(C)]
14600 pub struct TableUnionWithVectorStructSandwich<'de> {
14601 pub(crate) table: ::fidl_next::wire::Table<'de>,
14602 }
14603
14604 impl<'de> Drop for TableUnionWithVectorStructSandwich<'de> {
14605 fn drop(&mut self) {
14606 let _ = self.table.get(1).map(|envelope| unsafe {
14607 envelope.read_unchecked::<crate::wire::StructSize3Align1>()
14608 });
14609
14610 let _ = self.table.get(2).map(|envelope| unsafe {
14611 envelope.read_unchecked::<crate::wire::UnionWithVector<'de>>()
14612 });
14613
14614 let _ = self.table.get(3).map(|envelope| unsafe {
14615 envelope.read_unchecked::<crate::wire::StructSize3Align1>()
14616 });
14617 }
14618 }
14619
14620 impl ::fidl_next::Constrained for TableUnionWithVectorStructSandwich<'_> {
14621 type Constraint = ();
14622
14623 fn validate(
14624 _: ::fidl_next::Slot<'_, Self>,
14625 _: Self::Constraint,
14626 ) -> Result<(), ::fidl_next::ValidationError> {
14627 Ok(())
14628 }
14629 }
14630
14631 unsafe impl ::fidl_next::Wire for TableUnionWithVectorStructSandwich<'static> {
14632 type Narrowed<'de> = TableUnionWithVectorStructSandwich<'de>;
14633
14634 #[inline]
14635 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14636 ::fidl_next::munge!(let Self { table } = out);
14637 ::fidl_next::wire::Table::zero_padding(table);
14638 }
14639 }
14640
14641 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableUnionWithVectorStructSandwich<'de>
14642 where
14643 ___D: ::fidl_next::Decoder<'de> + ?Sized,
14644 ___D: ::fidl_next::fuchsia::HandleDecoder,
14645 {
14646 fn decode(
14647 slot: ::fidl_next::Slot<'_, Self>,
14648 decoder: &mut ___D,
14649 _: (),
14650 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14651 ::fidl_next::munge!(let Self { table } = slot);
14652
14653 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14654 match ordinal {
14655 0 => unsafe { ::core::hint::unreachable_unchecked() },
14656
14657 1 => {
14658 ::fidl_next::wire::Envelope::decode_as::<
14659 ___D,
14660 crate::wire::StructSize3Align1,
14661 >(slot.as_mut(), decoder, ())?;
14662
14663 Ok(())
14664 }
14665
14666 2 => {
14667 ::fidl_next::wire::Envelope::decode_as::<
14668 ___D,
14669 crate::wire::UnionWithVector<'de>,
14670 >(slot.as_mut(), decoder, ())?;
14671
14672 Ok(())
14673 }
14674
14675 3 => {
14676 ::fidl_next::wire::Envelope::decode_as::<
14677 ___D,
14678 crate::wire::StructSize3Align1,
14679 >(slot.as_mut(), decoder, ())?;
14680
14681 Ok(())
14682 }
14683
14684 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14685 }
14686 })
14687 }
14688 }
14689
14690 impl<'de> TableUnionWithVectorStructSandwich<'de> {
14691 pub fn s1(&self) -> ::core::option::Option<&crate::wire::StructSize3Align1> {
14692 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14693 }
14694
14695 pub fn take_s1(&mut self) -> ::core::option::Option<crate::wire::StructSize3Align1> {
14696 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14697 }
14698
14699 pub fn uv(&self) -> ::core::option::Option<&crate::wire::UnionWithVector<'de>> {
14700 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14701 }
14702
14703 pub fn take_uv(&mut self) -> ::core::option::Option<crate::wire::UnionWithVector<'de>> {
14704 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14705 }
14706
14707 pub fn s2(&self) -> ::core::option::Option<&crate::wire::StructSize3Align1> {
14708 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
14709 }
14710
14711 pub fn take_s2(&mut self) -> ::core::option::Option<crate::wire::StructSize3Align1> {
14712 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
14713 }
14714 }
14715
14716 impl<'de> ::core::fmt::Debug for TableUnionWithVectorStructSandwich<'de> {
14717 fn fmt(
14718 &self,
14719 f: &mut ::core::fmt::Formatter<'_>,
14720 ) -> ::core::result::Result<(), ::core::fmt::Error> {
14721 f.debug_struct("TableUnionWithVectorStructSandwich")
14722 .field("s1", &self.s1())
14723 .field("uv", &self.uv())
14724 .field("s2", &self.s2())
14725 .finish()
14726 }
14727 }
14728
14729 impl<'de> ::fidl_next::IntoNatural for TableUnionWithVectorStructSandwich<'de> {
14730 type Natural = crate::natural::TableUnionWithVectorStructSandwich;
14731 }
14732
14733 #[derive(Debug)]
14735 #[repr(C)]
14736 pub struct TableUnionWithVectorStructSandwichStruct<'de> {
14737 pub table: crate::wire::TableUnionWithVectorStructSandwich<'de>,
14738 }
14739
14740 static_assertions::const_assert_eq!(
14741 std::mem::size_of::<TableUnionWithVectorStructSandwichStruct<'_>>(),
14742 16
14743 );
14744 static_assertions::const_assert_eq!(
14745 std::mem::align_of::<TableUnionWithVectorStructSandwichStruct<'_>>(),
14746 8
14747 );
14748
14749 static_assertions::const_assert_eq!(
14750 std::mem::offset_of!(TableUnionWithVectorStructSandwichStruct<'_>, table),
14751 0
14752 );
14753
14754 impl ::fidl_next::Constrained for TableUnionWithVectorStructSandwichStruct<'_> {
14755 type Constraint = ();
14756
14757 fn validate(
14758 _: ::fidl_next::Slot<'_, Self>,
14759 _: Self::Constraint,
14760 ) -> Result<(), ::fidl_next::ValidationError> {
14761 Ok(())
14762 }
14763 }
14764
14765 unsafe impl ::fidl_next::Wire for TableUnionWithVectorStructSandwichStruct<'static> {
14766 type Narrowed<'de> = TableUnionWithVectorStructSandwichStruct<'de>;
14767
14768 #[inline]
14769 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14770 ::fidl_next::munge! {
14771 let Self {
14772 table,
14773
14774 } = &mut *out_;
14775 }
14776
14777 ::fidl_next::Wire::zero_padding(table);
14778 }
14779 }
14780
14781 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TableUnionWithVectorStructSandwichStruct<'de>
14782 where
14783 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14784 ___D: ::fidl_next::Decoder<'de>,
14785 ___D: ::fidl_next::fuchsia::HandleDecoder,
14786 {
14787 fn decode(
14788 slot_: ::fidl_next::Slot<'_, Self>,
14789 decoder_: &mut ___D,
14790 _: (),
14791 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14792 ::fidl_next::munge! {
14793 let Self {
14794 mut table,
14795
14796 } = slot_;
14797 }
14798
14799 let _field = table.as_mut();
14800
14801 ::fidl_next::Decode::decode(table.as_mut(), decoder_, ())?;
14802
14803 Ok(())
14804 }
14805 }
14806
14807 impl<'de> ::fidl_next::IntoNatural for TableUnionWithVectorStructSandwichStruct<'de> {
14808 type Natural = crate::natural::TableUnionWithVectorStructSandwichStruct;
14809 }
14810
14811 #[repr(C)]
14813 pub struct TableWithUnknownEnvelopesAfterKnownEnvelopes<'de> {
14814 pub(crate) table: ::fidl_next::wire::Table<'de>,
14815 }
14816
14817 impl<'de> Drop for TableWithUnknownEnvelopesAfterKnownEnvelopes<'de> {
14818 fn drop(&mut self) {
14819 let _ = self.table.get(1).map(|envelope| unsafe {
14820 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
14821 });
14822 }
14823 }
14824
14825 impl ::fidl_next::Constrained for TableWithUnknownEnvelopesAfterKnownEnvelopes<'_> {
14826 type Constraint = ();
14827
14828 fn validate(
14829 _: ::fidl_next::Slot<'_, Self>,
14830 _: Self::Constraint,
14831 ) -> Result<(), ::fidl_next::ValidationError> {
14832 Ok(())
14833 }
14834 }
14835
14836 unsafe impl ::fidl_next::Wire for TableWithUnknownEnvelopesAfterKnownEnvelopes<'static> {
14837 type Narrowed<'de> = TableWithUnknownEnvelopesAfterKnownEnvelopes<'de>;
14838
14839 #[inline]
14840 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14841 ::fidl_next::munge!(let Self { table } = out);
14842 ::fidl_next::wire::Table::zero_padding(table);
14843 }
14844 }
14845
14846 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
14847 for TableWithUnknownEnvelopesAfterKnownEnvelopes<'de>
14848 where
14849 ___D: ::fidl_next::Decoder<'de> + ?Sized,
14850 ___D: ::fidl_next::fuchsia::HandleDecoder,
14851 {
14852 fn decode(
14853 slot: ::fidl_next::Slot<'_, Self>,
14854 decoder: &mut ___D,
14855 _: (),
14856 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14857 ::fidl_next::munge!(let Self { table } = slot);
14858
14859 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14860 match ordinal {
14861 0 => unsafe { ::core::hint::unreachable_unchecked() },
14862
14863 1 => {
14864 ::fidl_next::wire::Envelope::decode_as::<
14865 ___D,
14866 ::fidl_next::wire::fuchsia::Event,
14867 >(slot.as_mut(), decoder, ())?;
14868
14869 Ok(())
14870 }
14871
14872 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14873 }
14874 })
14875 }
14876 }
14877
14878 impl<'de> TableWithUnknownEnvelopesAfterKnownEnvelopes<'de> {
14879 pub fn a(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Event> {
14880 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14881 }
14882
14883 pub fn take_a(&mut self) -> ::core::option::Option<::fidl_next::wire::fuchsia::Event> {
14884 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14885 }
14886 }
14887
14888 impl<'de> ::core::fmt::Debug for TableWithUnknownEnvelopesAfterKnownEnvelopes<'de> {
14889 fn fmt(
14890 &self,
14891 f: &mut ::core::fmt::Formatter<'_>,
14892 ) -> ::core::result::Result<(), ::core::fmt::Error> {
14893 f.debug_struct("TableWithUnknownEnvelopesAfterKnownEnvelopes")
14894 .field("a", &self.a())
14895 .finish()
14896 }
14897 }
14898
14899 impl<'de> ::fidl_next::IntoNatural for TableWithUnknownEnvelopesAfterKnownEnvelopes<'de> {
14900 type Natural = crate::natural::TableWithUnknownEnvelopesAfterKnownEnvelopes;
14901 }
14902
14903 #[derive(Debug)]
14905 #[repr(C)]
14906 pub struct TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'de> {
14907 pub t: crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes<'de>,
14908 }
14909
14910 static_assertions::const_assert_eq!(
14911 std::mem::size_of::<TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'_>>(),
14912 16
14913 );
14914 static_assertions::const_assert_eq!(
14915 std::mem::align_of::<TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'_>>(),
14916 8
14917 );
14918
14919 static_assertions::const_assert_eq!(
14920 std::mem::offset_of!(TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'_>, t),
14921 0
14922 );
14923
14924 impl ::fidl_next::Constrained for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'_> {
14925 type Constraint = ();
14926
14927 fn validate(
14928 _: ::fidl_next::Slot<'_, Self>,
14929 _: Self::Constraint,
14930 ) -> Result<(), ::fidl_next::ValidationError> {
14931 Ok(())
14932 }
14933 }
14934
14935 unsafe impl ::fidl_next::Wire for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static> {
14936 type Narrowed<'de> = TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'de>;
14937
14938 #[inline]
14939 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14940 ::fidl_next::munge! {
14941 let Self {
14942 t,
14943
14944 } = &mut *out_;
14945 }
14946
14947 ::fidl_next::Wire::zero_padding(t);
14948 }
14949 }
14950
14951 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
14952 for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'de>
14953 where
14954 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14955 ___D: ::fidl_next::Decoder<'de>,
14956 ___D: ::fidl_next::fuchsia::HandleDecoder,
14957 {
14958 fn decode(
14959 slot_: ::fidl_next::Slot<'_, Self>,
14960 decoder_: &mut ___D,
14961 _: (),
14962 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14963 ::fidl_next::munge! {
14964 let Self {
14965 mut t,
14966
14967 } = slot_;
14968 }
14969
14970 let _field = t.as_mut();
14971
14972 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
14973
14974 Ok(())
14975 }
14976 }
14977
14978 impl<'de> ::fidl_next::IntoNatural for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'de> {
14979 type Natural = crate::natural::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct;
14980 }
14981
14982 #[repr(C)]
14984 pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de> {
14985 pub(crate) table: ::fidl_next::wire::Table<'de>,
14986 }
14987
14988 impl<'de> Drop for TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de> {
14989 fn drop(&mut self) {
14990 let _ = self.table.get(2).map(|envelope| unsafe {
14991 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
14992 });
14993 }
14994 }
14995
14996 impl ::fidl_next::Constrained for TableWithUnknownEnvelopesBeforeKnownEnvelopes<'_> {
14997 type Constraint = ();
14998
14999 fn validate(
15000 _: ::fidl_next::Slot<'_, Self>,
15001 _: Self::Constraint,
15002 ) -> Result<(), ::fidl_next::ValidationError> {
15003 Ok(())
15004 }
15005 }
15006
15007 unsafe impl ::fidl_next::Wire for TableWithUnknownEnvelopesBeforeKnownEnvelopes<'static> {
15008 type Narrowed<'de> = TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de>;
15009
15010 #[inline]
15011 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
15012 ::fidl_next::munge!(let Self { table } = out);
15013 ::fidl_next::wire::Table::zero_padding(table);
15014 }
15015 }
15016
15017 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
15018 for TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de>
15019 where
15020 ___D: ::fidl_next::Decoder<'de> + ?Sized,
15021 ___D: ::fidl_next::fuchsia::HandleDecoder,
15022 {
15023 fn decode(
15024 slot: ::fidl_next::Slot<'_, Self>,
15025 decoder: &mut ___D,
15026 _: (),
15027 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15028 ::fidl_next::munge!(let Self { table } = slot);
15029
15030 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
15031 match ordinal {
15032 0 => unsafe { ::core::hint::unreachable_unchecked() },
15033
15034 2 => {
15035 ::fidl_next::wire::Envelope::decode_as::<
15036 ___D,
15037 ::fidl_next::wire::fuchsia::Event,
15038 >(slot.as_mut(), decoder, ())?;
15039
15040 Ok(())
15041 }
15042
15043 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
15044 }
15045 })
15046 }
15047 }
15048
15049 impl<'de> TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de> {
15050 pub fn b(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Event> {
15051 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
15052 }
15053
15054 pub fn take_b(&mut self) -> ::core::option::Option<::fidl_next::wire::fuchsia::Event> {
15055 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
15056 }
15057 }
15058
15059 impl<'de> ::core::fmt::Debug for TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de> {
15060 fn fmt(
15061 &self,
15062 f: &mut ::core::fmt::Formatter<'_>,
15063 ) -> ::core::result::Result<(), ::core::fmt::Error> {
15064 f.debug_struct("TableWithUnknownEnvelopesBeforeKnownEnvelopes")
15065 .field("b", &self.b())
15066 .finish()
15067 }
15068 }
15069
15070 impl<'de> ::fidl_next::IntoNatural for TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de> {
15071 type Natural = crate::natural::TableWithUnknownEnvelopesBeforeKnownEnvelopes;
15072 }
15073
15074 #[derive(Debug)]
15076 #[repr(C)]
15077 pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'de> {
15078 pub t: crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes<'de>,
15079 }
15080
15081 static_assertions::const_assert_eq!(
15082 std::mem::size_of::<TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'_>>(),
15083 16
15084 );
15085 static_assertions::const_assert_eq!(
15086 std::mem::align_of::<TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'_>>(),
15087 8
15088 );
15089
15090 static_assertions::const_assert_eq!(
15091 std::mem::offset_of!(TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'_>, t),
15092 0
15093 );
15094
15095 impl ::fidl_next::Constrained for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'_> {
15096 type Constraint = ();
15097
15098 fn validate(
15099 _: ::fidl_next::Slot<'_, Self>,
15100 _: Self::Constraint,
15101 ) -> Result<(), ::fidl_next::ValidationError> {
15102 Ok(())
15103 }
15104 }
15105
15106 unsafe impl ::fidl_next::Wire for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static> {
15107 type Narrowed<'de> = TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'de>;
15108
15109 #[inline]
15110 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15111 ::fidl_next::munge! {
15112 let Self {
15113 t,
15114
15115 } = &mut *out_;
15116 }
15117
15118 ::fidl_next::Wire::zero_padding(t);
15119 }
15120 }
15121
15122 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
15123 for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'de>
15124 where
15125 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15126 ___D: ::fidl_next::Decoder<'de>,
15127 ___D: ::fidl_next::fuchsia::HandleDecoder,
15128 {
15129 fn decode(
15130 slot_: ::fidl_next::Slot<'_, Self>,
15131 decoder_: &mut ___D,
15132 _: (),
15133 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15134 ::fidl_next::munge! {
15135 let Self {
15136 mut t,
15137
15138 } = slot_;
15139 }
15140
15141 let _field = t.as_mut();
15142
15143 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
15144
15145 Ok(())
15146 }
15147 }
15148
15149 impl<'de> ::fidl_next::IntoNatural for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'de> {
15150 type Natural = crate::natural::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct;
15151 }
15152
15153 #[derive(Debug)]
15155 #[repr(C)]
15156 pub struct TestFlexibleResourceXUnionInStruct<'de> {
15157 pub xu: crate::wire::SampleResourceXUnion<'de>,
15158 }
15159
15160 static_assertions::const_assert_eq!(
15161 std::mem::size_of::<TestFlexibleResourceXUnionInStruct<'_>>(),
15162 16
15163 );
15164 static_assertions::const_assert_eq!(
15165 std::mem::align_of::<TestFlexibleResourceXUnionInStruct<'_>>(),
15166 8
15167 );
15168
15169 static_assertions::const_assert_eq!(
15170 std::mem::offset_of!(TestFlexibleResourceXUnionInStruct<'_>, xu),
15171 0
15172 );
15173
15174 impl ::fidl_next::Constrained for TestFlexibleResourceXUnionInStruct<'_> {
15175 type Constraint = ();
15176
15177 fn validate(
15178 _: ::fidl_next::Slot<'_, Self>,
15179 _: Self::Constraint,
15180 ) -> Result<(), ::fidl_next::ValidationError> {
15181 Ok(())
15182 }
15183 }
15184
15185 unsafe impl ::fidl_next::Wire for TestFlexibleResourceXUnionInStruct<'static> {
15186 type Narrowed<'de> = TestFlexibleResourceXUnionInStruct<'de>;
15187
15188 #[inline]
15189 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15190 ::fidl_next::munge! {
15191 let Self {
15192 xu,
15193
15194 } = &mut *out_;
15195 }
15196
15197 ::fidl_next::Wire::zero_padding(xu);
15198 }
15199 }
15200
15201 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TestFlexibleResourceXUnionInStruct<'de>
15202 where
15203 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15204 ___D: ::fidl_next::Decoder<'de>,
15205 ___D: ::fidl_next::fuchsia::HandleDecoder,
15206 {
15207 fn decode(
15208 slot_: ::fidl_next::Slot<'_, Self>,
15209 decoder_: &mut ___D,
15210 _: (),
15211 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15212 ::fidl_next::munge! {
15213 let Self {
15214 mut xu,
15215
15216 } = slot_;
15217 }
15218
15219 let _field = xu.as_mut();
15220
15221 ::fidl_next::Decode::decode(xu.as_mut(), decoder_, ())?;
15222
15223 Ok(())
15224 }
15225 }
15226
15227 impl<'de> ::fidl_next::IntoNatural for TestFlexibleResourceXUnionInStruct<'de> {
15228 type Natural = crate::natural::TestFlexibleResourceXUnionInStruct;
15229 }
15230
15231 #[derive(Debug)]
15233 #[repr(C)]
15234 pub struct TestOptionalFlexibleResourceXUnionInStruct<'de> {
15235 pub xu: crate::wire_optional::SampleResourceXUnion<'de>,
15236 }
15237
15238 static_assertions::const_assert_eq!(
15239 std::mem::size_of::<TestOptionalFlexibleResourceXUnionInStruct<'_>>(),
15240 16
15241 );
15242 static_assertions::const_assert_eq!(
15243 std::mem::align_of::<TestOptionalFlexibleResourceXUnionInStruct<'_>>(),
15244 8
15245 );
15246
15247 static_assertions::const_assert_eq!(
15248 std::mem::offset_of!(TestOptionalFlexibleResourceXUnionInStruct<'_>, xu),
15249 0
15250 );
15251
15252 impl ::fidl_next::Constrained for TestOptionalFlexibleResourceXUnionInStruct<'_> {
15253 type Constraint = ();
15254
15255 fn validate(
15256 _: ::fidl_next::Slot<'_, Self>,
15257 _: Self::Constraint,
15258 ) -> Result<(), ::fidl_next::ValidationError> {
15259 Ok(())
15260 }
15261 }
15262
15263 unsafe impl ::fidl_next::Wire for TestOptionalFlexibleResourceXUnionInStruct<'static> {
15264 type Narrowed<'de> = TestOptionalFlexibleResourceXUnionInStruct<'de>;
15265
15266 #[inline]
15267 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15268 ::fidl_next::munge! {
15269 let Self {
15270 xu,
15271
15272 } = &mut *out_;
15273 }
15274
15275 ::fidl_next::Wire::zero_padding(xu);
15276 }
15277 }
15278
15279 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TestOptionalFlexibleResourceXUnionInStruct<'de>
15280 where
15281 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15282 ___D: ::fidl_next::Decoder<'de>,
15283 ___D: ::fidl_next::fuchsia::HandleDecoder,
15284 {
15285 fn decode(
15286 slot_: ::fidl_next::Slot<'_, Self>,
15287 decoder_: &mut ___D,
15288 _: (),
15289 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15290 ::fidl_next::munge! {
15291 let Self {
15292 mut xu,
15293
15294 } = slot_;
15295 }
15296
15297 let _field = xu.as_mut();
15298
15299 ::fidl_next::Decode::decode(xu.as_mut(), decoder_, ())?;
15300
15301 Ok(())
15302 }
15303 }
15304
15305 impl<'de> ::fidl_next::IntoNatural for TestOptionalFlexibleResourceXUnionInStruct<'de> {
15306 type Natural = crate::natural::TestOptionalFlexibleResourceXUnionInStruct;
15307 }
15308
15309 #[derive(Debug)]
15311 #[repr(C)]
15312 pub struct TestOptionalStrictResourceXUnionInStruct<'de> {
15313 pub xu: crate::wire_optional::SampleStrictResourceXUnion<'de>,
15314 }
15315
15316 static_assertions::const_assert_eq!(
15317 std::mem::size_of::<TestOptionalStrictResourceXUnionInStruct<'_>>(),
15318 16
15319 );
15320 static_assertions::const_assert_eq!(
15321 std::mem::align_of::<TestOptionalStrictResourceXUnionInStruct<'_>>(),
15322 8
15323 );
15324
15325 static_assertions::const_assert_eq!(
15326 std::mem::offset_of!(TestOptionalStrictResourceXUnionInStruct<'_>, xu),
15327 0
15328 );
15329
15330 impl ::fidl_next::Constrained for TestOptionalStrictResourceXUnionInStruct<'_> {
15331 type Constraint = ();
15332
15333 fn validate(
15334 _: ::fidl_next::Slot<'_, Self>,
15335 _: Self::Constraint,
15336 ) -> Result<(), ::fidl_next::ValidationError> {
15337 Ok(())
15338 }
15339 }
15340
15341 unsafe impl ::fidl_next::Wire for TestOptionalStrictResourceXUnionInStruct<'static> {
15342 type Narrowed<'de> = TestOptionalStrictResourceXUnionInStruct<'de>;
15343
15344 #[inline]
15345 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15346 ::fidl_next::munge! {
15347 let Self {
15348 xu,
15349
15350 } = &mut *out_;
15351 }
15352
15353 ::fidl_next::Wire::zero_padding(xu);
15354 }
15355 }
15356
15357 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TestOptionalStrictResourceXUnionInStruct<'de>
15358 where
15359 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15360 ___D: ::fidl_next::Decoder<'de>,
15361 ___D: ::fidl_next::fuchsia::HandleDecoder,
15362 {
15363 fn decode(
15364 slot_: ::fidl_next::Slot<'_, Self>,
15365 decoder_: &mut ___D,
15366 _: (),
15367 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15368 ::fidl_next::munge! {
15369 let Self {
15370 mut xu,
15371
15372 } = slot_;
15373 }
15374
15375 let _field = xu.as_mut();
15376
15377 ::fidl_next::Decode::decode(xu.as_mut(), decoder_, ())?;
15378
15379 Ok(())
15380 }
15381 }
15382
15383 impl<'de> ::fidl_next::IntoNatural for TestOptionalStrictResourceXUnionInStruct<'de> {
15384 type Natural = crate::natural::TestOptionalStrictResourceXUnionInStruct;
15385 }
15386
15387 #[derive(Debug)]
15389 #[repr(C)]
15390 pub struct TestPackageResolverResolveRequest<'de> {
15391 pub package_url: ::fidl_next::wire::String<'de>,
15392
15393 pub selectors: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
15394
15395 pub update_policy: crate::wire::UpdatePolicy,
15396
15397 pub this_should_be_a_handle: ::fidl_next::wire::Uint32,
15398 }
15399
15400 static_assertions::const_assert_eq!(
15401 std::mem::size_of::<TestPackageResolverResolveRequest<'_>>(),
15402 40
15403 );
15404 static_assertions::const_assert_eq!(
15405 std::mem::align_of::<TestPackageResolverResolveRequest<'_>>(),
15406 8
15407 );
15408
15409 static_assertions::const_assert_eq!(
15410 std::mem::offset_of!(TestPackageResolverResolveRequest<'_>, package_url),
15411 0
15412 );
15413
15414 static_assertions::const_assert_eq!(
15415 std::mem::offset_of!(TestPackageResolverResolveRequest<'_>, selectors),
15416 16
15417 );
15418
15419 static_assertions::const_assert_eq!(
15420 std::mem::offset_of!(TestPackageResolverResolveRequest<'_>, update_policy),
15421 32
15422 );
15423
15424 static_assertions::const_assert_eq!(
15425 std::mem::offset_of!(TestPackageResolverResolveRequest<'_>, this_should_be_a_handle),
15426 36
15427 );
15428
15429 impl ::fidl_next::Constrained for TestPackageResolverResolveRequest<'_> {
15430 type Constraint = ();
15431
15432 fn validate(
15433 _: ::fidl_next::Slot<'_, Self>,
15434 _: Self::Constraint,
15435 ) -> Result<(), ::fidl_next::ValidationError> {
15436 Ok(())
15437 }
15438 }
15439
15440 unsafe impl ::fidl_next::Wire for TestPackageResolverResolveRequest<'static> {
15441 type Narrowed<'de> = TestPackageResolverResolveRequest<'de>;
15442
15443 #[inline]
15444 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15445 ::fidl_next::munge! {
15446 let Self {
15447 package_url,
15448 selectors,
15449 update_policy,
15450 this_should_be_a_handle,
15451
15452 } = &mut *out_;
15453 }
15454
15455 ::fidl_next::Wire::zero_padding(package_url);
15456
15457 ::fidl_next::Wire::zero_padding(selectors);
15458
15459 ::fidl_next::Wire::zero_padding(update_policy);
15460
15461 ::fidl_next::Wire::zero_padding(this_should_be_a_handle);
15462
15463 unsafe {
15464 out_.as_mut_ptr().cast::<u8>().add(34).write_bytes(0, 2);
15465 }
15466 }
15467 }
15468
15469 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TestPackageResolverResolveRequest<'de>
15470 where
15471 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15472 ___D: ::fidl_next::Decoder<'de>,
15473 ___D: ::fidl_next::fuchsia::HandleDecoder,
15474 {
15475 fn decode(
15476 slot_: ::fidl_next::Slot<'_, Self>,
15477 decoder_: &mut ___D,
15478 _: (),
15479 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15480 if slot_.as_bytes()[34..36] != [0u8; 2] {
15481 return Err(::fidl_next::DecodeError::InvalidPadding);
15482 }
15483
15484 ::fidl_next::munge! {
15485 let Self {
15486 mut package_url,
15487 mut selectors,
15488 mut update_policy,
15489 mut this_should_be_a_handle,
15490
15491 } = slot_;
15492 }
15493
15494 let _field = package_url.as_mut();
15495 ::fidl_next::Constrained::validate(_field, 4294967295)?;
15496 ::fidl_next::Decode::decode(package_url.as_mut(), decoder_, 4294967295)?;
15497
15498 let _field = selectors.as_mut();
15499 ::fidl_next::Constrained::validate(_field, (4294967295, 4294967295))?;
15500 ::fidl_next::Decode::decode(selectors.as_mut(), decoder_, (4294967295, 4294967295))?;
15501
15502 let _field = update_policy.as_mut();
15503
15504 ::fidl_next::Decode::decode(update_policy.as_mut(), decoder_, ())?;
15505
15506 let _field = this_should_be_a_handle.as_mut();
15507
15508 ::fidl_next::Decode::decode(this_should_be_a_handle.as_mut(), decoder_, ())?;
15509
15510 Ok(())
15511 }
15512 }
15513
15514 impl<'de> ::fidl_next::IntoNatural for TestPackageResolverResolveRequest<'de> {
15515 type Natural = crate::natural::TestPackageResolverResolveRequest;
15516 }
15517
15518 #[derive(Debug)]
15520 #[repr(C)]
15521 pub struct TestStrictResourceXUnionInStruct<'de> {
15522 pub xu: crate::wire::SampleStrictResourceXUnion<'de>,
15523 }
15524
15525 static_assertions::const_assert_eq!(
15526 std::mem::size_of::<TestStrictResourceXUnionInStruct<'_>>(),
15527 16
15528 );
15529 static_assertions::const_assert_eq!(
15530 std::mem::align_of::<TestStrictResourceXUnionInStruct<'_>>(),
15531 8
15532 );
15533
15534 static_assertions::const_assert_eq!(
15535 std::mem::offset_of!(TestStrictResourceXUnionInStruct<'_>, xu),
15536 0
15537 );
15538
15539 impl ::fidl_next::Constrained for TestStrictResourceXUnionInStruct<'_> {
15540 type Constraint = ();
15541
15542 fn validate(
15543 _: ::fidl_next::Slot<'_, Self>,
15544 _: Self::Constraint,
15545 ) -> Result<(), ::fidl_next::ValidationError> {
15546 Ok(())
15547 }
15548 }
15549
15550 unsafe impl ::fidl_next::Wire for TestStrictResourceXUnionInStruct<'static> {
15551 type Narrowed<'de> = TestStrictResourceXUnionInStruct<'de>;
15552
15553 #[inline]
15554 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15555 ::fidl_next::munge! {
15556 let Self {
15557 xu,
15558
15559 } = &mut *out_;
15560 }
15561
15562 ::fidl_next::Wire::zero_padding(xu);
15563 }
15564 }
15565
15566 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for TestStrictResourceXUnionInStruct<'de>
15567 where
15568 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15569 ___D: ::fidl_next::Decoder<'de>,
15570 ___D: ::fidl_next::fuchsia::HandleDecoder,
15571 {
15572 fn decode(
15573 slot_: ::fidl_next::Slot<'_, Self>,
15574 decoder_: &mut ___D,
15575 _: (),
15576 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15577 ::fidl_next::munge! {
15578 let Self {
15579 mut xu,
15580
15581 } = slot_;
15582 }
15583
15584 let _field = xu.as_mut();
15585
15586 ::fidl_next::Decode::decode(xu.as_mut(), decoder_, ())?;
15587
15588 Ok(())
15589 }
15590 }
15591
15592 impl<'de> ::fidl_next::IntoNatural for TestStrictResourceXUnionInStruct<'de> {
15593 type Natural = crate::natural::TestStrictResourceXUnionInStruct;
15594 }
15595
15596 #[derive(Debug)]
15598 #[repr(C)]
15599 pub struct UnboundedNonnullableVectorOfHandles<'de> {
15600 pub vh0: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
15601 }
15602
15603 static_assertions::const_assert_eq!(
15604 std::mem::size_of::<UnboundedNonnullableVectorOfHandles<'_>>(),
15605 16
15606 );
15607 static_assertions::const_assert_eq!(
15608 std::mem::align_of::<UnboundedNonnullableVectorOfHandles<'_>>(),
15609 8
15610 );
15611
15612 static_assertions::const_assert_eq!(
15613 std::mem::offset_of!(UnboundedNonnullableVectorOfHandles<'_>, vh0),
15614 0
15615 );
15616
15617 impl ::fidl_next::Constrained for UnboundedNonnullableVectorOfHandles<'_> {
15618 type Constraint = ();
15619
15620 fn validate(
15621 _: ::fidl_next::Slot<'_, Self>,
15622 _: Self::Constraint,
15623 ) -> Result<(), ::fidl_next::ValidationError> {
15624 Ok(())
15625 }
15626 }
15627
15628 unsafe impl ::fidl_next::Wire for UnboundedNonnullableVectorOfHandles<'static> {
15629 type Narrowed<'de> = UnboundedNonnullableVectorOfHandles<'de>;
15630
15631 #[inline]
15632 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15633 ::fidl_next::munge! {
15634 let Self {
15635 vh0,
15636
15637 } = &mut *out_;
15638 }
15639
15640 ::fidl_next::Wire::zero_padding(vh0);
15641 }
15642 }
15643
15644 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnboundedNonnullableVectorOfHandles<'de>
15645 where
15646 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15647 ___D: ::fidl_next::Decoder<'de>,
15648 ___D: ::fidl_next::fuchsia::HandleDecoder,
15649 {
15650 fn decode(
15651 slot_: ::fidl_next::Slot<'_, Self>,
15652 decoder_: &mut ___D,
15653 _: (),
15654 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15655 ::fidl_next::munge! {
15656 let Self {
15657 mut vh0,
15658
15659 } = slot_;
15660 }
15661
15662 let _field = vh0.as_mut();
15663 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
15664 ::fidl_next::Decode::decode(vh0.as_mut(), decoder_, (4294967295, ()))?;
15665
15666 Ok(())
15667 }
15668 }
15669
15670 impl<'de> ::fidl_next::IntoNatural for UnboundedNonnullableVectorOfHandles<'de> {
15671 type Natural = crate::natural::UnboundedNonnullableVectorOfHandles;
15672 }
15673
15674 #[derive(Debug)]
15676 #[repr(C)]
15677 pub struct UnboundedNullableVectorOfHandles<'de> {
15678 pub vh0: ::fidl_next::wire::OptionalVector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
15679 }
15680
15681 static_assertions::const_assert_eq!(
15682 std::mem::size_of::<UnboundedNullableVectorOfHandles<'_>>(),
15683 16
15684 );
15685 static_assertions::const_assert_eq!(
15686 std::mem::align_of::<UnboundedNullableVectorOfHandles<'_>>(),
15687 8
15688 );
15689
15690 static_assertions::const_assert_eq!(
15691 std::mem::offset_of!(UnboundedNullableVectorOfHandles<'_>, vh0),
15692 0
15693 );
15694
15695 impl ::fidl_next::Constrained for UnboundedNullableVectorOfHandles<'_> {
15696 type Constraint = ();
15697
15698 fn validate(
15699 _: ::fidl_next::Slot<'_, Self>,
15700 _: Self::Constraint,
15701 ) -> Result<(), ::fidl_next::ValidationError> {
15702 Ok(())
15703 }
15704 }
15705
15706 unsafe impl ::fidl_next::Wire for UnboundedNullableVectorOfHandles<'static> {
15707 type Narrowed<'de> = UnboundedNullableVectorOfHandles<'de>;
15708
15709 #[inline]
15710 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15711 ::fidl_next::munge! {
15712 let Self {
15713 vh0,
15714
15715 } = &mut *out_;
15716 }
15717
15718 ::fidl_next::Wire::zero_padding(vh0);
15719 }
15720 }
15721
15722 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnboundedNullableVectorOfHandles<'de>
15723 where
15724 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15725 ___D: ::fidl_next::Decoder<'de>,
15726 ___D: ::fidl_next::fuchsia::HandleDecoder,
15727 {
15728 fn decode(
15729 slot_: ::fidl_next::Slot<'_, Self>,
15730 decoder_: &mut ___D,
15731 _: (),
15732 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15733 ::fidl_next::munge! {
15734 let Self {
15735 mut vh0,
15736
15737 } = slot_;
15738 }
15739
15740 let _field = vh0.as_mut();
15741 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
15742 ::fidl_next::Decode::decode(vh0.as_mut(), decoder_, (4294967295, ()))?;
15743
15744 Ok(())
15745 }
15746 }
15747
15748 impl<'de> ::fidl_next::IntoNatural for UnboundedNullableVectorOfHandles<'de> {
15749 type Natural = crate::natural::UnboundedNullableVectorOfHandles;
15750 }
15751
15752 #[repr(transparent)]
15754 pub struct UnionOfEndpointsUnion<'de> {
15755 pub(crate) raw: ::fidl_next::wire::Union,
15756 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
15757 }
15758
15759 impl<'de> Drop for UnionOfEndpointsUnion<'de> {
15760 fn drop(&mut self) {
15761 match self.raw.ordinal() {
15762 1 => {
15763 let _ = unsafe {
15764 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
15765 crate::Protocol,
15766 ::fidl_next::wire::fuchsia::Channel,
15767 >>()
15768 };
15769 }
15770
15771 2 => {
15772 let _ = unsafe {
15773 self.raw.get().read_unchecked::<::fidl_next::ServerEnd<
15774 crate::Protocol,
15775 ::fidl_next::wire::fuchsia::Channel,
15776 >>()
15777 };
15778 }
15779
15780 _ => (),
15781 }
15782 }
15783 }
15784
15785 impl ::fidl_next::Constrained for UnionOfEndpointsUnion<'_> {
15786 type Constraint = ();
15787
15788 fn validate(
15789 _: ::fidl_next::Slot<'_, Self>,
15790 _: Self::Constraint,
15791 ) -> Result<(), ::fidl_next::ValidationError> {
15792 Ok(())
15793 }
15794 }
15795
15796 unsafe impl ::fidl_next::Wire for UnionOfEndpointsUnion<'static> {
15797 type Narrowed<'de> = UnionOfEndpointsUnion<'de>;
15798
15799 #[inline]
15800 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
15801 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
15802 ::fidl_next::wire::Union::zero_padding(raw);
15803 }
15804 }
15805
15806 pub mod union_of_endpoints_union {
15807 pub enum Ref<'de> {
15808 ClientEnd(
15809 &'de ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
15810 ),
15811
15812 ServerEnd(
15813 &'de ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
15814 ),
15815
15816 UnknownOrdinal_(u64),
15817 }
15818
15819 pub enum Value {
15820 ClientEnd(::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>),
15821
15822 ServerEnd(::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>),
15823
15824 UnknownOrdinal_(u64),
15825 }
15826 }
15827
15828 impl<'de> UnionOfEndpointsUnion<'de> {
15829 pub fn as_ref(&self) -> crate::wire::union_of_endpoints_union::Ref<'_> {
15830 match self.raw.ordinal() {
15831 1 => crate::wire::union_of_endpoints_union::Ref::ClientEnd(unsafe {
15832 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
15833 }),
15834
15835 2 => crate::wire::union_of_endpoints_union::Ref::ServerEnd(unsafe {
15836 self.raw.get().deref_unchecked::<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
15837 }),
15838
15839 unknown => crate::wire::union_of_endpoints_union::Ref::UnknownOrdinal_(unknown),
15840 }
15841 }
15842
15843 pub fn into_inner(self) -> crate::wire::union_of_endpoints_union::Value {
15844 let this = ::core::mem::ManuallyDrop::new(self);
15845
15846 match this.raw.ordinal() {
15847 1 => crate::wire::union_of_endpoints_union::Value::ClientEnd(unsafe {
15848 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
15849 }),
15850
15851 2 => crate::wire::union_of_endpoints_union::Value::ServerEnd(unsafe {
15852 this.raw.get().read_unchecked::<::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>>()
15853 }),
15854
15855 unknown => crate::wire::union_of_endpoints_union::Value::UnknownOrdinal_(unknown),
15856 }
15857 }
15858 }
15859
15860 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnionOfEndpointsUnion<'de>
15861 where
15862 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15863 ___D: ::fidl_next::Decoder<'de>,
15864 ___D: ::fidl_next::fuchsia::HandleDecoder,
15865 {
15866 fn decode(
15867 mut slot: ::fidl_next::Slot<'_, Self>,
15868 decoder: &mut ___D,
15869 _: (),
15870 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15871 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
15872 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
15873 1 => ::fidl_next::wire::Union::decode_as::<
15874 ___D,
15875 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
15876 >(raw, decoder, ())?,
15877
15878 2 => ::fidl_next::wire::Union::decode_as::<
15879 ___D,
15880 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
15881 >(raw, decoder, ())?,
15882
15883 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
15884 }
15885
15886 Ok(())
15887 }
15888 }
15889
15890 impl<'de> ::core::fmt::Debug for UnionOfEndpointsUnion<'de> {
15891 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
15892 match self.raw.ordinal() {
15893 1 => unsafe {
15894 self.raw.get().deref_unchecked::<
15895 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>
15896 >().fmt(f)
15897 },
15898 2 => unsafe {
15899 self.raw.get().deref_unchecked::<
15900 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>
15901 >().fmt(f)
15902 },
15903 _ => unsafe { ::core::hint::unreachable_unchecked() },
15904 }
15905 }
15906 }
15907
15908 impl<'de> ::fidl_next::IntoNatural for UnionOfEndpointsUnion<'de> {
15909 type Natural = crate::natural::UnionOfEndpointsUnion;
15910 }
15911
15912 #[derive(Debug)]
15914 #[repr(C)]
15915 pub struct UnionOfEndpoints<'de> {
15916 pub u: crate::wire::UnionOfEndpointsUnion<'de>,
15917 }
15918
15919 static_assertions::const_assert_eq!(std::mem::size_of::<UnionOfEndpoints<'_>>(), 16);
15920 static_assertions::const_assert_eq!(std::mem::align_of::<UnionOfEndpoints<'_>>(), 8);
15921
15922 static_assertions::const_assert_eq!(std::mem::offset_of!(UnionOfEndpoints<'_>, u), 0);
15923
15924 impl ::fidl_next::Constrained for UnionOfEndpoints<'_> {
15925 type Constraint = ();
15926
15927 fn validate(
15928 _: ::fidl_next::Slot<'_, Self>,
15929 _: Self::Constraint,
15930 ) -> Result<(), ::fidl_next::ValidationError> {
15931 Ok(())
15932 }
15933 }
15934
15935 unsafe impl ::fidl_next::Wire for UnionOfEndpoints<'static> {
15936 type Narrowed<'de> = UnionOfEndpoints<'de>;
15937
15938 #[inline]
15939 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15940 ::fidl_next::munge! {
15941 let Self {
15942 u,
15943
15944 } = &mut *out_;
15945 }
15946
15947 ::fidl_next::Wire::zero_padding(u);
15948 }
15949 }
15950
15951 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnionOfEndpoints<'de>
15952 where
15953 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15954 ___D: ::fidl_next::Decoder<'de>,
15955 ___D: ::fidl_next::fuchsia::HandleDecoder,
15956 {
15957 fn decode(
15958 slot_: ::fidl_next::Slot<'_, Self>,
15959 decoder_: &mut ___D,
15960 _: (),
15961 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15962 ::fidl_next::munge! {
15963 let Self {
15964 mut u,
15965
15966 } = slot_;
15967 }
15968
15969 let _field = u.as_mut();
15970
15971 ::fidl_next::Decode::decode(u.as_mut(), decoder_, ())?;
15972
15973 Ok(())
15974 }
15975 }
15976
15977 impl<'de> ::fidl_next::IntoNatural for UnionOfEndpoints<'de> {
15978 type Natural = crate::natural::UnionOfEndpoints;
15979 }
15980
15981 #[repr(transparent)]
15983 pub struct UnionOfHandle {
15984 pub(crate) raw: ::fidl_next::wire::Union,
15985 pub(crate) _phantom: ::core::marker::PhantomData<()>,
15986 }
15987
15988 impl Drop for UnionOfHandle {
15989 fn drop(&mut self) {
15990 match self.raw.ordinal() {
15991 1 => {
15992 let _ = unsafe {
15993 self.raw
15994 .get()
15995 .read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
15996 };
15997 }
15998
15999 _ => unsafe { ::core::hint::unreachable_unchecked() },
16000 }
16001 }
16002 }
16003
16004 impl ::fidl_next::Constrained for UnionOfHandle {
16005 type Constraint = ();
16006
16007 fn validate(
16008 _: ::fidl_next::Slot<'_, Self>,
16009 _: Self::Constraint,
16010 ) -> Result<(), ::fidl_next::ValidationError> {
16011 Ok(())
16012 }
16013 }
16014
16015 unsafe impl ::fidl_next::Wire for UnionOfHandle {
16016 type Narrowed<'de> = UnionOfHandle;
16017
16018 #[inline]
16019 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16020 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
16021 ::fidl_next::wire::Union::zero_padding(raw);
16022 }
16023 }
16024
16025 pub mod union_of_handle {
16026 pub enum Ref<'de> {
16027 H(&'de ::fidl_next::wire::fuchsia::NullableHandle),
16028 }
16029
16030 pub enum Value {
16031 H(::fidl_next::wire::fuchsia::NullableHandle),
16032 }
16033 }
16034
16035 impl UnionOfHandle {
16036 pub fn as_ref(&self) -> crate::wire::union_of_handle::Ref<'_> {
16037 match self.raw.ordinal() {
16038 1 => crate::wire::union_of_handle::Ref::H(unsafe {
16039 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
16040 }),
16041
16042 _ => unsafe { ::core::hint::unreachable_unchecked() },
16043 }
16044 }
16045
16046 pub fn into_inner(self) -> crate::wire::union_of_handle::Value {
16047 let this = ::core::mem::ManuallyDrop::new(self);
16048
16049 match this.raw.ordinal() {
16050 1 => crate::wire::union_of_handle::Value::H(unsafe {
16051 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
16052 }),
16053
16054 _ => unsafe { ::core::hint::unreachable_unchecked() },
16055 }
16056 }
16057 }
16058
16059 unsafe impl<___D> ::fidl_next::Decode<___D> for UnionOfHandle
16060 where
16061 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16062 ___D: ::fidl_next::fuchsia::HandleDecoder,
16063 {
16064 fn decode(
16065 mut slot: ::fidl_next::Slot<'_, Self>,
16066 decoder: &mut ___D,
16067 _: (),
16068 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16069 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
16070 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
16071 1 => ::fidl_next::wire::Union::decode_as_static::<
16072 ___D,
16073 ::fidl_next::wire::fuchsia::NullableHandle,
16074 >(raw, decoder, ())?,
16075
16076 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
16077 }
16078
16079 Ok(())
16080 }
16081 }
16082
16083 impl ::core::fmt::Debug for UnionOfHandle {
16084 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
16085 match self.raw.ordinal() {
16086 1 => unsafe {
16087 self.raw
16088 .get()
16089 .deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
16090 .fmt(f)
16091 },
16092 _ => unsafe { ::core::hint::unreachable_unchecked() },
16093 }
16094 }
16095 }
16096
16097 impl ::fidl_next::IntoNatural for UnionOfHandle {
16098 type Natural = crate::natural::UnionOfHandle;
16099 }
16100
16101 #[derive(Debug)]
16103 #[repr(C)]
16104 pub struct VectorOfArrayOfEventInStructWithDefaultRights<'de> {
16105 pub h: ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
16106 }
16107
16108 static_assertions::const_assert_eq!(
16109 std::mem::size_of::<VectorOfArrayOfEventInStructWithDefaultRights<'_>>(),
16110 16
16111 );
16112 static_assertions::const_assert_eq!(
16113 std::mem::align_of::<VectorOfArrayOfEventInStructWithDefaultRights<'_>>(),
16114 8
16115 );
16116
16117 static_assertions::const_assert_eq!(
16118 std::mem::offset_of!(VectorOfArrayOfEventInStructWithDefaultRights<'_>, h),
16119 0
16120 );
16121
16122 impl ::fidl_next::Constrained for VectorOfArrayOfEventInStructWithDefaultRights<'_> {
16123 type Constraint = ();
16124
16125 fn validate(
16126 _: ::fidl_next::Slot<'_, Self>,
16127 _: Self::Constraint,
16128 ) -> Result<(), ::fidl_next::ValidationError> {
16129 Ok(())
16130 }
16131 }
16132
16133 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInStructWithDefaultRights<'static> {
16134 type Narrowed<'de> = VectorOfArrayOfEventInStructWithDefaultRights<'de>;
16135
16136 #[inline]
16137 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16138 ::fidl_next::munge! {
16139 let Self {
16140 h,
16141
16142 } = &mut *out_;
16143 }
16144
16145 ::fidl_next::Wire::zero_padding(h);
16146 }
16147 }
16148
16149 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16150 for VectorOfArrayOfEventInStructWithDefaultRights<'de>
16151 where
16152 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16153 ___D: ::fidl_next::Decoder<'de>,
16154 ___D: ::fidl_next::fuchsia::HandleDecoder,
16155 {
16156 fn decode(
16157 slot_: ::fidl_next::Slot<'_, Self>,
16158 decoder_: &mut ___D,
16159 _: (),
16160 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16161 ::fidl_next::munge! {
16162 let Self {
16163 mut h,
16164
16165 } = slot_;
16166 }
16167
16168 let _field = h.as_mut();
16169 ::fidl_next::Constrained::validate(_field, (1, ()))?;
16170 ::fidl_next::Decode::decode(h.as_mut(), decoder_, (1, ()))?;
16171
16172 let h = unsafe { h.deref_unchecked() };
16173
16174 if h.len() > 1 {
16175 return Err(::fidl_next::DecodeError::VectorTooLong {
16176 size: h.len() as u64,
16177 limit: 1,
16178 });
16179 }
16180
16181 Ok(())
16182 }
16183 }
16184
16185 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInStructWithDefaultRights<'de> {
16186 type Natural = crate::natural::VectorOfArrayOfEventInStructWithDefaultRights;
16187 }
16188
16189 #[derive(Debug)]
16191 #[repr(C)]
16192 pub struct VectorOfArrayOfEventInStructWithReducedRights<'de> {
16193 pub h: ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
16194 }
16195
16196 static_assertions::const_assert_eq!(
16197 std::mem::size_of::<VectorOfArrayOfEventInStructWithReducedRights<'_>>(),
16198 16
16199 );
16200 static_assertions::const_assert_eq!(
16201 std::mem::align_of::<VectorOfArrayOfEventInStructWithReducedRights<'_>>(),
16202 8
16203 );
16204
16205 static_assertions::const_assert_eq!(
16206 std::mem::offset_of!(VectorOfArrayOfEventInStructWithReducedRights<'_>, h),
16207 0
16208 );
16209
16210 impl ::fidl_next::Constrained for VectorOfArrayOfEventInStructWithReducedRights<'_> {
16211 type Constraint = ();
16212
16213 fn validate(
16214 _: ::fidl_next::Slot<'_, Self>,
16215 _: Self::Constraint,
16216 ) -> Result<(), ::fidl_next::ValidationError> {
16217 Ok(())
16218 }
16219 }
16220
16221 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInStructWithReducedRights<'static> {
16222 type Narrowed<'de> = VectorOfArrayOfEventInStructWithReducedRights<'de>;
16223
16224 #[inline]
16225 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16226 ::fidl_next::munge! {
16227 let Self {
16228 h,
16229
16230 } = &mut *out_;
16231 }
16232
16233 ::fidl_next::Wire::zero_padding(h);
16234 }
16235 }
16236
16237 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16238 for VectorOfArrayOfEventInStructWithReducedRights<'de>
16239 where
16240 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16241 ___D: ::fidl_next::Decoder<'de>,
16242 ___D: ::fidl_next::fuchsia::HandleDecoder,
16243 {
16244 fn decode(
16245 slot_: ::fidl_next::Slot<'_, Self>,
16246 decoder_: &mut ___D,
16247 _: (),
16248 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16249 ::fidl_next::munge! {
16250 let Self {
16251 mut h,
16252
16253 } = slot_;
16254 }
16255
16256 let _field = h.as_mut();
16257 ::fidl_next::Constrained::validate(_field, (1, ()))?;
16258 ::fidl_next::Decode::decode(h.as_mut(), decoder_, (1, ()))?;
16259
16260 let h = unsafe { h.deref_unchecked() };
16261
16262 if h.len() > 1 {
16263 return Err(::fidl_next::DecodeError::VectorTooLong {
16264 size: h.len() as u64,
16265 limit: 1,
16266 });
16267 }
16268
16269 Ok(())
16270 }
16271 }
16272
16273 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInStructWithReducedRights<'de> {
16274 type Natural = crate::natural::VectorOfArrayOfEventInStructWithReducedRights;
16275 }
16276
16277 #[repr(C)]
16279 pub struct VectorOfArrayOfEventInTableWithReducedRights<'de> {
16280 pub(crate) table: ::fidl_next::wire::Table<'de>,
16281 }
16282
16283 impl<'de> Drop for VectorOfArrayOfEventInTableWithReducedRights<'de> {
16284 fn drop(&mut self) {
16285 let _ = self.table.get(1)
16286 .map(|envelope| unsafe {
16287 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>>()
16288 });
16289 }
16290 }
16291
16292 impl ::fidl_next::Constrained for VectorOfArrayOfEventInTableWithReducedRights<'_> {
16293 type Constraint = ();
16294
16295 fn validate(
16296 _: ::fidl_next::Slot<'_, Self>,
16297 _: Self::Constraint,
16298 ) -> Result<(), ::fidl_next::ValidationError> {
16299 Ok(())
16300 }
16301 }
16302
16303 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInTableWithReducedRights<'static> {
16304 type Narrowed<'de> = VectorOfArrayOfEventInTableWithReducedRights<'de>;
16305
16306 #[inline]
16307 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16308 ::fidl_next::munge!(let Self { table } = out);
16309 ::fidl_next::wire::Table::zero_padding(table);
16310 }
16311 }
16312
16313 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16314 for VectorOfArrayOfEventInTableWithReducedRights<'de>
16315 where
16316 ___D: ::fidl_next::Decoder<'de> + ?Sized,
16317 ___D: ::fidl_next::fuchsia::HandleDecoder,
16318 {
16319 fn decode(
16320 slot: ::fidl_next::Slot<'_, Self>,
16321 decoder: &mut ___D,
16322 _: (),
16323 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16324 ::fidl_next::munge!(let Self { table } = slot);
16325
16326 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
16327 match ordinal {
16328 0 => unsafe { ::core::hint::unreachable_unchecked() },
16329
16330 1 => {
16331 ::fidl_next::wire::Envelope::decode_as::<
16332 ___D,
16333 ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
16334 >(slot.as_mut(), decoder, (1, ()))?;
16335
16336 let value = unsafe {
16337 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
16338 '_,
16339 [::fidl_next::wire::fuchsia::Event; 1],
16340 >>()
16341 };
16342
16343 if value.len() > 1 {
16344 return Err(::fidl_next::DecodeError::VectorTooLong {
16345 size: value.len() as u64,
16346 limit: 1,
16347 });
16348 }
16349
16350 Ok(())
16351 }
16352
16353 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
16354 }
16355 })
16356 }
16357 }
16358
16359 impl<'de> VectorOfArrayOfEventInTableWithReducedRights<'de> {
16360 pub fn h(
16361 &self,
16362 ) -> ::core::option::Option<
16363 &::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
16364 > {
16365 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
16366 }
16367
16368 pub fn take_h(
16369 &mut self,
16370 ) -> ::core::option::Option<
16371 ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
16372 > {
16373 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
16374 }
16375 }
16376
16377 impl<'de> ::core::fmt::Debug for VectorOfArrayOfEventInTableWithReducedRights<'de> {
16378 fn fmt(
16379 &self,
16380 f: &mut ::core::fmt::Formatter<'_>,
16381 ) -> ::core::result::Result<(), ::core::fmt::Error> {
16382 f.debug_struct("VectorOfArrayOfEventInTableWithReducedRights")
16383 .field("h", &self.h())
16384 .finish()
16385 }
16386 }
16387
16388 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInTableWithReducedRights<'de> {
16389 type Natural = crate::natural::VectorOfArrayOfEventInTableWithReducedRights;
16390 }
16391
16392 #[derive(Debug)]
16394 #[repr(C)]
16395 pub struct VectorOfArrayOfEventInTableWithReducedRightsStruct<'de> {
16396 pub t: crate::wire::VectorOfArrayOfEventInTableWithReducedRights<'de>,
16397 }
16398
16399 static_assertions::const_assert_eq!(
16400 std::mem::size_of::<VectorOfArrayOfEventInTableWithReducedRightsStruct<'_>>(),
16401 16
16402 );
16403 static_assertions::const_assert_eq!(
16404 std::mem::align_of::<VectorOfArrayOfEventInTableWithReducedRightsStruct<'_>>(),
16405 8
16406 );
16407
16408 static_assertions::const_assert_eq!(
16409 std::mem::offset_of!(VectorOfArrayOfEventInTableWithReducedRightsStruct<'_>, t),
16410 0
16411 );
16412
16413 impl ::fidl_next::Constrained for VectorOfArrayOfEventInTableWithReducedRightsStruct<'_> {
16414 type Constraint = ();
16415
16416 fn validate(
16417 _: ::fidl_next::Slot<'_, Self>,
16418 _: Self::Constraint,
16419 ) -> Result<(), ::fidl_next::ValidationError> {
16420 Ok(())
16421 }
16422 }
16423
16424 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInTableWithReducedRightsStruct<'static> {
16425 type Narrowed<'de> = VectorOfArrayOfEventInTableWithReducedRightsStruct<'de>;
16426
16427 #[inline]
16428 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16429 ::fidl_next::munge! {
16430 let Self {
16431 t,
16432
16433 } = &mut *out_;
16434 }
16435
16436 ::fidl_next::Wire::zero_padding(t);
16437 }
16438 }
16439
16440 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16441 for VectorOfArrayOfEventInTableWithReducedRightsStruct<'de>
16442 where
16443 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16444 ___D: ::fidl_next::Decoder<'de>,
16445 ___D: ::fidl_next::fuchsia::HandleDecoder,
16446 {
16447 fn decode(
16448 slot_: ::fidl_next::Slot<'_, Self>,
16449 decoder_: &mut ___D,
16450 _: (),
16451 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16452 ::fidl_next::munge! {
16453 let Self {
16454 mut t,
16455
16456 } = slot_;
16457 }
16458
16459 let _field = t.as_mut();
16460
16461 ::fidl_next::Decode::decode(t.as_mut(), decoder_, ())?;
16462
16463 Ok(())
16464 }
16465 }
16466
16467 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInTableWithReducedRightsStruct<'de> {
16468 type Natural = crate::natural::VectorOfArrayOfEventInTableWithReducedRightsStruct;
16469 }
16470
16471 #[repr(transparent)]
16473 pub struct VectorOfArrayOfEventInUnionWithReducedRights<'de> {
16474 pub(crate) raw: ::fidl_next::wire::Union,
16475 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
16476 }
16477
16478 impl<'de> Drop for VectorOfArrayOfEventInUnionWithReducedRights<'de> {
16479 fn drop(&mut self) {
16480 match self.raw.ordinal() {
16481 1 => {
16482 let _ = unsafe {
16483 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>>()
16484 };
16485 }
16486
16487 _ => unsafe { ::core::hint::unreachable_unchecked() },
16488 }
16489 }
16490 }
16491
16492 impl ::fidl_next::Constrained for VectorOfArrayOfEventInUnionWithReducedRights<'_> {
16493 type Constraint = ();
16494
16495 fn validate(
16496 _: ::fidl_next::Slot<'_, Self>,
16497 _: Self::Constraint,
16498 ) -> Result<(), ::fidl_next::ValidationError> {
16499 Ok(())
16500 }
16501 }
16502
16503 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInUnionWithReducedRights<'static> {
16504 type Narrowed<'de> = VectorOfArrayOfEventInUnionWithReducedRights<'de>;
16505
16506 #[inline]
16507 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16508 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
16509 ::fidl_next::wire::Union::zero_padding(raw);
16510 }
16511 }
16512
16513 pub mod vector_of_array_of_event_in_union_with_reduced_rights {
16514 pub enum Ref<'de> {
16515 H(&'de ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>),
16516 }
16517
16518 pub enum Value<'de> {
16519 H(::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>),
16520 }
16521 }
16522
16523 impl<'de> VectorOfArrayOfEventInUnionWithReducedRights<'de> {
16524 pub fn as_ref(
16525 &self,
16526 ) -> crate::wire::vector_of_array_of_event_in_union_with_reduced_rights::Ref<'_> {
16527 match self.raw.ordinal() {
16528 1 => crate::wire::vector_of_array_of_event_in_union_with_reduced_rights::Ref::H(
16529 unsafe {
16530 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, [::fidl_next::wire::fuchsia::Event; 1]>>()
16531 },
16532 ),
16533
16534 _ => unsafe { ::core::hint::unreachable_unchecked() },
16535 }
16536 }
16537
16538 pub fn into_inner(
16539 self,
16540 ) -> crate::wire::vector_of_array_of_event_in_union_with_reduced_rights::Value<'de>
16541 {
16542 let this = ::core::mem::ManuallyDrop::new(self);
16543
16544 match this.raw.ordinal() {
16545 1 => crate::wire::vector_of_array_of_event_in_union_with_reduced_rights::Value::H(
16546 unsafe {
16547 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>>()
16548 },
16549 ),
16550
16551 _ => unsafe { ::core::hint::unreachable_unchecked() },
16552 }
16553 }
16554 }
16555
16556 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16557 for VectorOfArrayOfEventInUnionWithReducedRights<'de>
16558 where
16559 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16560 ___D: ::fidl_next::Decoder<'de>,
16561 ___D: ::fidl_next::fuchsia::HandleDecoder,
16562 {
16563 fn decode(
16564 mut slot: ::fidl_next::Slot<'_, Self>,
16565 decoder: &mut ___D,
16566 _: (),
16567 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16568 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
16569 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
16570 1 => ::fidl_next::wire::Union::decode_as::<
16571 ___D,
16572 ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
16573 >(raw, decoder, (1, ()))?,
16574
16575 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
16576 }
16577
16578 Ok(())
16579 }
16580 }
16581
16582 impl<'de> ::core::fmt::Debug for VectorOfArrayOfEventInUnionWithReducedRights<'de> {
16583 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
16584 match self.raw.ordinal() {
16585 1 => unsafe {
16586 self.raw.get().deref_unchecked::<
16587 ::fidl_next::wire::Vector<'_, [::fidl_next::wire::fuchsia::Event; 1]>
16588 >().fmt(f)
16589 },
16590 _ => unsafe { ::core::hint::unreachable_unchecked() },
16591 }
16592 }
16593 }
16594
16595 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInUnionWithReducedRights<'de> {
16596 type Natural = crate::natural::VectorOfArrayOfEventInUnionWithReducedRights;
16597 }
16598
16599 #[derive(Debug)]
16601 #[repr(C)]
16602 pub struct VectorOfArrayOfEventInUnionWithReducedRightsStruct<'de> {
16603 pub u: crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'de>,
16604 }
16605
16606 static_assertions::const_assert_eq!(
16607 std::mem::size_of::<VectorOfArrayOfEventInUnionWithReducedRightsStruct<'_>>(),
16608 16
16609 );
16610 static_assertions::const_assert_eq!(
16611 std::mem::align_of::<VectorOfArrayOfEventInUnionWithReducedRightsStruct<'_>>(),
16612 8
16613 );
16614
16615 static_assertions::const_assert_eq!(
16616 std::mem::offset_of!(VectorOfArrayOfEventInUnionWithReducedRightsStruct<'_>, u),
16617 0
16618 );
16619
16620 impl ::fidl_next::Constrained for VectorOfArrayOfEventInUnionWithReducedRightsStruct<'_> {
16621 type Constraint = ();
16622
16623 fn validate(
16624 _: ::fidl_next::Slot<'_, Self>,
16625 _: Self::Constraint,
16626 ) -> Result<(), ::fidl_next::ValidationError> {
16627 Ok(())
16628 }
16629 }
16630
16631 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static> {
16632 type Narrowed<'de> = VectorOfArrayOfEventInUnionWithReducedRightsStruct<'de>;
16633
16634 #[inline]
16635 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16636 ::fidl_next::munge! {
16637 let Self {
16638 u,
16639
16640 } = &mut *out_;
16641 }
16642
16643 ::fidl_next::Wire::zero_padding(u);
16644 }
16645 }
16646
16647 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16648 for VectorOfArrayOfEventInUnionWithReducedRightsStruct<'de>
16649 where
16650 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16651 ___D: ::fidl_next::Decoder<'de>,
16652 ___D: ::fidl_next::fuchsia::HandleDecoder,
16653 {
16654 fn decode(
16655 slot_: ::fidl_next::Slot<'_, Self>,
16656 decoder_: &mut ___D,
16657 _: (),
16658 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16659 ::fidl_next::munge! {
16660 let Self {
16661 mut u,
16662
16663 } = slot_;
16664 }
16665
16666 let _field = u.as_mut();
16667
16668 ::fidl_next::Decode::decode(u.as_mut(), decoder_, ())?;
16669
16670 Ok(())
16671 }
16672 }
16673
16674 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInUnionWithReducedRightsStruct<'de> {
16675 type Natural = crate::natural::VectorOfArrayOfEventInUnionWithReducedRightsStruct;
16676 }
16677
16678 #[derive(Debug)]
16680 #[repr(C)]
16681 pub struct VectorOfHandles<'de> {
16682 pub v: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
16683 }
16684
16685 static_assertions::const_assert_eq!(std::mem::size_of::<VectorOfHandles<'_>>(), 16);
16686 static_assertions::const_assert_eq!(std::mem::align_of::<VectorOfHandles<'_>>(), 8);
16687
16688 static_assertions::const_assert_eq!(std::mem::offset_of!(VectorOfHandles<'_>, v), 0);
16689
16690 impl ::fidl_next::Constrained for VectorOfHandles<'_> {
16691 type Constraint = ();
16692
16693 fn validate(
16694 _: ::fidl_next::Slot<'_, Self>,
16695 _: Self::Constraint,
16696 ) -> Result<(), ::fidl_next::ValidationError> {
16697 Ok(())
16698 }
16699 }
16700
16701 unsafe impl ::fidl_next::Wire for VectorOfHandles<'static> {
16702 type Narrowed<'de> = VectorOfHandles<'de>;
16703
16704 #[inline]
16705 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16706 ::fidl_next::munge! {
16707 let Self {
16708 v,
16709
16710 } = &mut *out_;
16711 }
16712
16713 ::fidl_next::Wire::zero_padding(v);
16714 }
16715 }
16716
16717 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for VectorOfHandles<'de>
16718 where
16719 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16720 ___D: ::fidl_next::Decoder<'de>,
16721 ___D: ::fidl_next::fuchsia::HandleDecoder,
16722 {
16723 fn decode(
16724 slot_: ::fidl_next::Slot<'_, Self>,
16725 decoder_: &mut ___D,
16726 _: (),
16727 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16728 ::fidl_next::munge! {
16729 let Self {
16730 mut v,
16731
16732 } = slot_;
16733 }
16734
16735 let _field = v.as_mut();
16736 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
16737 ::fidl_next::Decode::decode(v.as_mut(), decoder_, (4294967295, ()))?;
16738
16739 Ok(())
16740 }
16741 }
16742
16743 impl<'de> ::fidl_next::IntoNatural for VectorOfHandles<'de> {
16744 type Natural = crate::natural::VectorOfHandles;
16745 }
16746
16747 #[derive(Debug)]
16749 #[repr(C)]
16750 pub struct VectorOfOptionalHandles<'de> {
16751 pub v: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::OptionalNullableHandle>,
16752 }
16753
16754 static_assertions::const_assert_eq!(std::mem::size_of::<VectorOfOptionalHandles<'_>>(), 16);
16755 static_assertions::const_assert_eq!(std::mem::align_of::<VectorOfOptionalHandles<'_>>(), 8);
16756
16757 static_assertions::const_assert_eq!(std::mem::offset_of!(VectorOfOptionalHandles<'_>, v), 0);
16758
16759 impl ::fidl_next::Constrained for VectorOfOptionalHandles<'_> {
16760 type Constraint = ();
16761
16762 fn validate(
16763 _: ::fidl_next::Slot<'_, Self>,
16764 _: Self::Constraint,
16765 ) -> Result<(), ::fidl_next::ValidationError> {
16766 Ok(())
16767 }
16768 }
16769
16770 unsafe impl ::fidl_next::Wire for VectorOfOptionalHandles<'static> {
16771 type Narrowed<'de> = VectorOfOptionalHandles<'de>;
16772
16773 #[inline]
16774 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16775 ::fidl_next::munge! {
16776 let Self {
16777 v,
16778
16779 } = &mut *out_;
16780 }
16781
16782 ::fidl_next::Wire::zero_padding(v);
16783 }
16784 }
16785
16786 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for VectorOfOptionalHandles<'de>
16787 where
16788 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16789 ___D: ::fidl_next::Decoder<'de>,
16790 ___D: ::fidl_next::fuchsia::HandleDecoder,
16791 {
16792 fn decode(
16793 slot_: ::fidl_next::Slot<'_, Self>,
16794 decoder_: &mut ___D,
16795 _: (),
16796 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16797 ::fidl_next::munge! {
16798 let Self {
16799 mut v,
16800
16801 } = slot_;
16802 }
16803
16804 let _field = v.as_mut();
16805 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
16806 ::fidl_next::Decode::decode(v.as_mut(), decoder_, (4294967295, ()))?;
16807
16808 Ok(())
16809 }
16810 }
16811
16812 impl<'de> ::fidl_next::IntoNatural for VectorOfOptionalHandles<'de> {
16813 type Natural = crate::natural::VectorOfOptionalHandles;
16814 }
16815
16816 #[derive(Debug)]
16818 #[repr(C)]
16819 pub struct VectorOfUpTo2Handles<'de> {
16820 pub v: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
16821 }
16822
16823 static_assertions::const_assert_eq!(std::mem::size_of::<VectorOfUpTo2Handles<'_>>(), 16);
16824 static_assertions::const_assert_eq!(std::mem::align_of::<VectorOfUpTo2Handles<'_>>(), 8);
16825
16826 static_assertions::const_assert_eq!(std::mem::offset_of!(VectorOfUpTo2Handles<'_>, v), 0);
16827
16828 impl ::fidl_next::Constrained for VectorOfUpTo2Handles<'_> {
16829 type Constraint = ();
16830
16831 fn validate(
16832 _: ::fidl_next::Slot<'_, Self>,
16833 _: Self::Constraint,
16834 ) -> Result<(), ::fidl_next::ValidationError> {
16835 Ok(())
16836 }
16837 }
16838
16839 unsafe impl ::fidl_next::Wire for VectorOfUpTo2Handles<'static> {
16840 type Narrowed<'de> = VectorOfUpTo2Handles<'de>;
16841
16842 #[inline]
16843 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
16844 ::fidl_next::munge! {
16845 let Self {
16846 v,
16847
16848 } = &mut *out_;
16849 }
16850
16851 ::fidl_next::Wire::zero_padding(v);
16852 }
16853 }
16854
16855 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for VectorOfUpTo2Handles<'de>
16856 where
16857 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16858 ___D: ::fidl_next::Decoder<'de>,
16859 ___D: ::fidl_next::fuchsia::HandleDecoder,
16860 {
16861 fn decode(
16862 slot_: ::fidl_next::Slot<'_, Self>,
16863 decoder_: &mut ___D,
16864 _: (),
16865 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16866 ::fidl_next::munge! {
16867 let Self {
16868 mut v,
16869
16870 } = slot_;
16871 }
16872
16873 let _field = v.as_mut();
16874 ::fidl_next::Constrained::validate(_field, (2, ()))?;
16875 ::fidl_next::Decode::decode(v.as_mut(), decoder_, (2, ()))?;
16876
16877 let v = unsafe { v.deref_unchecked() };
16878
16879 if v.len() > 2 {
16880 return Err(::fidl_next::DecodeError::VectorTooLong {
16881 size: v.len() as u64,
16882 limit: 2,
16883 });
16884 }
16885
16886 Ok(())
16887 }
16888 }
16889
16890 impl<'de> ::fidl_next::IntoNatural for VectorOfUpTo2Handles<'de> {
16891 type Natural = crate::natural::VectorOfUpTo2Handles;
16892 }
16893}
16894
16895pub mod wire_optional {
16896
16897 pub use fidl_next_common_test_conformance::wire_optional::*;
16898
16899 #[repr(transparent)]
16900 pub struct ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
16901 pub(crate) raw: ::fidl_next::wire::Union,
16902 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
16903 }
16904
16905 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInUnionWithDefaultRights<'_> {
16906 type Constraint = ();
16907
16908 fn validate(
16909 _: ::fidl_next::Slot<'_, Self>,
16910 _: Self::Constraint,
16911 ) -> Result<(), ::fidl_next::ValidationError> {
16912 Ok(())
16913 }
16914 }
16915
16916 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInUnionWithDefaultRights<'static> {
16917 type Narrowed<'de> = ArrayOfVectorOfEventInUnionWithDefaultRights<'de>;
16918
16919 #[inline]
16920 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16921 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
16922 ::fidl_next::wire::Union::zero_padding(raw);
16923 }
16924 }
16925
16926 impl<'de> ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
16927 pub fn is_some(&self) -> bool {
16928 self.raw.is_some()
16929 }
16930
16931 pub fn is_none(&self) -> bool {
16932 self.raw.is_none()
16933 }
16934
16935 pub fn as_ref(
16936 &self,
16937 ) -> ::core::option::Option<&crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>>
16938 {
16939 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
16940 }
16941
16942 pub fn into_option(
16943 self,
16944 ) -> ::core::option::Option<crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'de>>
16945 {
16946 if self.is_some() {
16947 Some(crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights {
16948 raw: self.raw,
16949 _phantom: ::core::marker::PhantomData,
16950 })
16951 } else {
16952 None
16953 }
16954 }
16955 }
16956
16957 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
16958 for ArrayOfVectorOfEventInUnionWithDefaultRights<'de>
16959 where
16960 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16961 ___D: ::fidl_next::Decoder<'de>,
16962 ___D: ::fidl_next::fuchsia::HandleDecoder,
16963 {
16964 fn decode(
16965 mut slot: ::fidl_next::Slot<'_, Self>,
16966 decoder: &mut ___D,
16967 _: (),
16968 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16969 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
16970 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
16971 1 => ::fidl_next::wire::Union::decode_as::<
16972 ___D,
16973 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
16974 >(raw, decoder, (1, ()))?,
16975
16976 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
16977 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
16978 }
16979
16980 Ok(())
16981 }
16982 }
16983
16984 impl<'de> ::core::fmt::Debug for ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
16985 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
16986 self.as_ref().fmt(f)
16987 }
16988 }
16989
16990 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInUnionWithDefaultRights<'de> {
16991 type Natural =
16992 ::core::option::Option<crate::natural::ArrayOfVectorOfEventInUnionWithDefaultRights>;
16993 }
16994
16995 #[repr(transparent)]
16996 pub struct ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
16997 pub(crate) raw: ::fidl_next::wire::Union,
16998 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
16999 }
17000
17001 impl ::fidl_next::Constrained for ArrayOfVectorOfEventInUnionWithReducedRights<'_> {
17002 type Constraint = ();
17003
17004 fn validate(
17005 _: ::fidl_next::Slot<'_, Self>,
17006 _: Self::Constraint,
17007 ) -> Result<(), ::fidl_next::ValidationError> {
17008 Ok(())
17009 }
17010 }
17011
17012 unsafe impl ::fidl_next::Wire for ArrayOfVectorOfEventInUnionWithReducedRights<'static> {
17013 type Narrowed<'de> = ArrayOfVectorOfEventInUnionWithReducedRights<'de>;
17014
17015 #[inline]
17016 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17017 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17018 ::fidl_next::wire::Union::zero_padding(raw);
17019 }
17020 }
17021
17022 impl<'de> ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
17023 pub fn is_some(&self) -> bool {
17024 self.raw.is_some()
17025 }
17026
17027 pub fn is_none(&self) -> bool {
17028 self.raw.is_none()
17029 }
17030
17031 pub fn as_ref(
17032 &self,
17033 ) -> ::core::option::Option<&crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'de>>
17034 {
17035 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17036 }
17037
17038 pub fn into_option(
17039 self,
17040 ) -> ::core::option::Option<crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'de>>
17041 {
17042 if self.is_some() {
17043 Some(crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights {
17044 raw: self.raw,
17045 _phantom: ::core::marker::PhantomData,
17046 })
17047 } else {
17048 None
17049 }
17050 }
17051 }
17052
17053 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
17054 for ArrayOfVectorOfEventInUnionWithReducedRights<'de>
17055 where
17056 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17057 ___D: ::fidl_next::Decoder<'de>,
17058 ___D: ::fidl_next::fuchsia::HandleDecoder,
17059 {
17060 fn decode(
17061 mut slot: ::fidl_next::Slot<'_, Self>,
17062 decoder: &mut ___D,
17063 _: (),
17064 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17065 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17066 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17067 1 => ::fidl_next::wire::Union::decode_as::<
17068 ___D,
17069 [::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::Event>; 1],
17070 >(raw, decoder, (1, ()))?,
17071
17072 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17073 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17074 }
17075
17076 Ok(())
17077 }
17078 }
17079
17080 impl<'de> ::core::fmt::Debug for ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
17081 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17082 self.as_ref().fmt(f)
17083 }
17084 }
17085
17086 impl<'de> ::fidl_next::IntoNatural for ArrayOfVectorOfEventInUnionWithReducedRights<'de> {
17087 type Natural =
17088 ::core::option::Option<crate::natural::ArrayOfVectorOfEventInUnionWithReducedRights>;
17089 }
17090
17091 #[repr(transparent)]
17092 pub struct EnvelopeInliningTestUnion<'de> {
17093 pub(crate) raw: ::fidl_next::wire::Union,
17094 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
17095 }
17096
17097 impl ::fidl_next::Constrained for EnvelopeInliningTestUnion<'_> {
17098 type Constraint = ();
17099
17100 fn validate(
17101 _: ::fidl_next::Slot<'_, Self>,
17102 _: Self::Constraint,
17103 ) -> Result<(), ::fidl_next::ValidationError> {
17104 Ok(())
17105 }
17106 }
17107
17108 unsafe impl ::fidl_next::Wire for EnvelopeInliningTestUnion<'static> {
17109 type Narrowed<'de> = EnvelopeInliningTestUnion<'de>;
17110
17111 #[inline]
17112 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17113 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17114 ::fidl_next::wire::Union::zero_padding(raw);
17115 }
17116 }
17117
17118 impl<'de> EnvelopeInliningTestUnion<'de> {
17119 pub fn is_some(&self) -> bool {
17120 self.raw.is_some()
17121 }
17122
17123 pub fn is_none(&self) -> bool {
17124 self.raw.is_none()
17125 }
17126
17127 pub fn as_ref(
17128 &self,
17129 ) -> ::core::option::Option<&crate::wire::EnvelopeInliningTestUnion<'de>> {
17130 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17131 }
17132
17133 pub fn into_option(
17134 self,
17135 ) -> ::core::option::Option<crate::wire::EnvelopeInliningTestUnion<'de>> {
17136 if self.is_some() {
17137 Some(crate::wire::EnvelopeInliningTestUnion {
17138 raw: self.raw,
17139 _phantom: ::core::marker::PhantomData,
17140 })
17141 } else {
17142 None
17143 }
17144 }
17145 }
17146
17147 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EnvelopeInliningTestUnion<'de>
17148 where
17149 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17150 ___D: ::fidl_next::Decoder<'de>,
17151 ___D: ::fidl_next::fuchsia::HandleDecoder,
17152 {
17153 fn decode(
17154 mut slot: ::fidl_next::Slot<'_, Self>,
17155 decoder: &mut ___D,
17156 _: (),
17157 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17158 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17159 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17160 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
17161 raw,
17162 decoder,
17163 (),
17164 )?,
17165
17166 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
17167 raw,
17168 decoder,
17169 (),
17170 )?,
17171
17172 3 => ::fidl_next::wire::Union::decode_as::<
17173 ___D,
17174 ::fidl_next::wire::fuchsia::NullableHandle,
17175 >(raw, decoder, ())?,
17176
17177 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17178 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17179 }
17180
17181 Ok(())
17182 }
17183 }
17184
17185 impl<'de> ::core::fmt::Debug for EnvelopeInliningTestUnion<'de> {
17186 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17187 self.as_ref().fmt(f)
17188 }
17189 }
17190
17191 impl<'de> ::fidl_next::IntoNatural for EnvelopeInliningTestUnion<'de> {
17192 type Natural = ::core::option::Option<crate::natural::EnvelopeInliningTestUnion>;
17193 }
17194
17195 #[repr(transparent)]
17196 pub struct SampleResourceXUnion<'de> {
17197 pub(crate) raw: ::fidl_next::wire::Union,
17198 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
17199 }
17200
17201 impl ::fidl_next::Constrained for SampleResourceXUnion<'_> {
17202 type Constraint = ();
17203
17204 fn validate(
17205 _: ::fidl_next::Slot<'_, Self>,
17206 _: Self::Constraint,
17207 ) -> Result<(), ::fidl_next::ValidationError> {
17208 Ok(())
17209 }
17210 }
17211
17212 unsafe impl ::fidl_next::Wire for SampleResourceXUnion<'static> {
17213 type Narrowed<'de> = SampleResourceXUnion<'de>;
17214
17215 #[inline]
17216 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17217 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17218 ::fidl_next::wire::Union::zero_padding(raw);
17219 }
17220 }
17221
17222 impl<'de> SampleResourceXUnion<'de> {
17223 pub fn is_some(&self) -> bool {
17224 self.raw.is_some()
17225 }
17226
17227 pub fn is_none(&self) -> bool {
17228 self.raw.is_none()
17229 }
17230
17231 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::SampleResourceXUnion<'de>> {
17232 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17233 }
17234
17235 pub fn into_option(self) -> ::core::option::Option<crate::wire::SampleResourceXUnion<'de>> {
17236 if self.is_some() {
17237 Some(crate::wire::SampleResourceXUnion {
17238 raw: self.raw,
17239 _phantom: ::core::marker::PhantomData,
17240 })
17241 } else {
17242 None
17243 }
17244 }
17245 }
17246
17247 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SampleResourceXUnion<'de>
17248 where
17249 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17250 ___D: ::fidl_next::Decoder<'de>,
17251 ___D: ::fidl_next::fuchsia::HandleDecoder,
17252 {
17253 fn decode(
17254 mut slot: ::fidl_next::Slot<'_, Self>,
17255 decoder: &mut ___D,
17256 _: (),
17257 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17258 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17259 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17260 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
17261 raw,
17262 decoder,
17263 (),
17264 )?,
17265
17266 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleUnion<'de>>(
17267 raw,
17268 decoder,
17269 (),
17270 )?,
17271
17272 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleTable<'de>>(
17273 raw,
17274 decoder,
17275 (),
17276 )?,
17277
17278 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17279 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17280 }
17281
17282 Ok(())
17283 }
17284 }
17285
17286 impl<'de> ::core::fmt::Debug for SampleResourceXUnion<'de> {
17287 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17288 self.as_ref().fmt(f)
17289 }
17290 }
17291
17292 impl<'de> ::fidl_next::IntoNatural for SampleResourceXUnion<'de> {
17293 type Natural = ::core::option::Option<crate::natural::SampleResourceXUnion>;
17294 }
17295
17296 #[repr(transparent)]
17297 pub struct SampleStrictResourceXUnion<'de> {
17298 pub(crate) raw: ::fidl_next::wire::Union,
17299 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
17300 }
17301
17302 impl ::fidl_next::Constrained for SampleStrictResourceXUnion<'_> {
17303 type Constraint = ();
17304
17305 fn validate(
17306 _: ::fidl_next::Slot<'_, Self>,
17307 _: Self::Constraint,
17308 ) -> Result<(), ::fidl_next::ValidationError> {
17309 Ok(())
17310 }
17311 }
17312
17313 unsafe impl ::fidl_next::Wire for SampleStrictResourceXUnion<'static> {
17314 type Narrowed<'de> = SampleStrictResourceXUnion<'de>;
17315
17316 #[inline]
17317 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17318 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17319 ::fidl_next::wire::Union::zero_padding(raw);
17320 }
17321 }
17322
17323 impl<'de> SampleStrictResourceXUnion<'de> {
17324 pub fn is_some(&self) -> bool {
17325 self.raw.is_some()
17326 }
17327
17328 pub fn is_none(&self) -> bool {
17329 self.raw.is_none()
17330 }
17331
17332 pub fn as_ref(
17333 &self,
17334 ) -> ::core::option::Option<&crate::wire::SampleStrictResourceXUnion<'de>> {
17335 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17336 }
17337
17338 pub fn into_option(
17339 self,
17340 ) -> ::core::option::Option<crate::wire::SampleStrictResourceXUnion<'de>> {
17341 if self.is_some() {
17342 Some(crate::wire::SampleStrictResourceXUnion {
17343 raw: self.raw,
17344 _phantom: ::core::marker::PhantomData,
17345 })
17346 } else {
17347 None
17348 }
17349 }
17350 }
17351
17352 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SampleStrictResourceXUnion<'de>
17353 where
17354 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17355 ___D: ::fidl_next::Decoder<'de>,
17356 ___D: ::fidl_next::fuchsia::HandleDecoder,
17357 {
17358 fn decode(
17359 mut slot: ::fidl_next::Slot<'_, Self>,
17360 decoder: &mut ___D,
17361 _: (),
17362 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17363 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17364 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17365 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
17366 raw,
17367 decoder,
17368 (),
17369 )?,
17370
17371 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleUnion<'de>>(
17372 raw,
17373 decoder,
17374 (),
17375 )?,
17376
17377 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SimpleTable<'de>>(
17378 raw,
17379 decoder,
17380 (),
17381 )?,
17382
17383 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17384 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17385 }
17386
17387 Ok(())
17388 }
17389 }
17390
17391 impl<'de> ::core::fmt::Debug for SampleStrictResourceXUnion<'de> {
17392 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17393 self.as_ref().fmt(f)
17394 }
17395 }
17396
17397 impl<'de> ::fidl_next::IntoNatural for SampleStrictResourceXUnion<'de> {
17398 type Natural = ::core::option::Option<crate::natural::SampleStrictResourceXUnion>;
17399 }
17400
17401 #[repr(transparent)]
17402 pub struct UnionWithVector<'de> {
17403 pub(crate) raw: ::fidl_next::wire::Union,
17404 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
17405 }
17406
17407 impl ::fidl_next::Constrained for UnionWithVector<'_> {
17408 type Constraint = ();
17409
17410 fn validate(
17411 _: ::fidl_next::Slot<'_, Self>,
17412 _: Self::Constraint,
17413 ) -> Result<(), ::fidl_next::ValidationError> {
17414 Ok(())
17415 }
17416 }
17417
17418 unsafe impl ::fidl_next::Wire for UnionWithVector<'static> {
17419 type Narrowed<'de> = UnionWithVector<'de>;
17420
17421 #[inline]
17422 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17423 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17424 ::fidl_next::wire::Union::zero_padding(raw);
17425 }
17426 }
17427
17428 impl<'de> UnionWithVector<'de> {
17429 pub fn is_some(&self) -> bool {
17430 self.raw.is_some()
17431 }
17432
17433 pub fn is_none(&self) -> bool {
17434 self.raw.is_none()
17435 }
17436
17437 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::UnionWithVector<'de>> {
17438 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17439 }
17440
17441 pub fn into_option(self) -> ::core::option::Option<crate::wire::UnionWithVector<'de>> {
17442 if self.is_some() {
17443 Some(crate::wire::UnionWithVector {
17444 raw: self.raw,
17445 _phantom: ::core::marker::PhantomData,
17446 })
17447 } else {
17448 None
17449 }
17450 }
17451 }
17452
17453 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnionWithVector<'de>
17454 where
17455 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17456 ___D: ::fidl_next::Decoder<'de>,
17457 ___D: ::fidl_next::fuchsia::HandleDecoder,
17458 {
17459 fn decode(
17460 mut slot: ::fidl_next::Slot<'_, Self>,
17461 decoder: &mut ___D,
17462 _: (),
17463 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17464 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17465 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17466 1 => ::fidl_next::wire::Union::decode_as::<___D, u8>(raw, decoder, ())?,
17467
17468 2 => {
17469 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
17470 raw,
17471 decoder,
17472 (4294967295, ()),
17473 )?
17474 }
17475
17476 3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
17477 raw, decoder, 4294967295,
17478 )?,
17479
17480 4 => ::fidl_next::wire::Union::decode_as::<
17481 ___D,
17482 ::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align1>,
17483 >(raw, decoder, (4294967295, ()))?,
17484
17485 5 => ::fidl_next::wire::Union::decode_as::<
17486 ___D,
17487 ::fidl_next::wire::Vector<'de, crate::wire::StructSize3Align2>,
17488 >(raw, decoder, (4294967295, ()))?,
17489
17490 6 => ::fidl_next::wire::Union::decode_as::<
17491 ___D,
17492 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::fuchsia::NullableHandle>,
17493 >(raw, decoder, (4294967295, ()))?,
17494
17495 7 => ::fidl_next::wire::Union::decode_as::<
17496 ___D,
17497 [crate::wire::StructSize3Align1; 2],
17498 >(raw, decoder, ())?,
17499
17500 8 => ::fidl_next::wire::Union::decode_as::<
17501 ___D,
17502 [crate::wire::StructSize3Align2; 2],
17503 >(raw, decoder, ())?,
17504
17505 9 => ::fidl_next::wire::Union::decode_as::<
17506 ___D,
17507 ::fidl_next::wire::Vector<'de, crate::wire::UnionSize8Align4>,
17508 >(raw, decoder, (4294967295, ()))?,
17509
17510 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17511 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17512 }
17513
17514 Ok(())
17515 }
17516 }
17517
17518 impl<'de> ::core::fmt::Debug for UnionWithVector<'de> {
17519 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17520 self.as_ref().fmt(f)
17521 }
17522 }
17523
17524 impl<'de> ::fidl_next::IntoNatural for UnionWithVector<'de> {
17525 type Natural = ::core::option::Option<crate::natural::UnionWithVector>;
17526 }
17527
17528 #[repr(transparent)]
17529 pub struct UnionOfEndpointsUnion<'de> {
17530 pub(crate) raw: ::fidl_next::wire::Union,
17531 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
17532 }
17533
17534 impl ::fidl_next::Constrained for UnionOfEndpointsUnion<'_> {
17535 type Constraint = ();
17536
17537 fn validate(
17538 _: ::fidl_next::Slot<'_, Self>,
17539 _: Self::Constraint,
17540 ) -> Result<(), ::fidl_next::ValidationError> {
17541 Ok(())
17542 }
17543 }
17544
17545 unsafe impl ::fidl_next::Wire for UnionOfEndpointsUnion<'static> {
17546 type Narrowed<'de> = UnionOfEndpointsUnion<'de>;
17547
17548 #[inline]
17549 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17550 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17551 ::fidl_next::wire::Union::zero_padding(raw);
17552 }
17553 }
17554
17555 impl<'de> UnionOfEndpointsUnion<'de> {
17556 pub fn is_some(&self) -> bool {
17557 self.raw.is_some()
17558 }
17559
17560 pub fn is_none(&self) -> bool {
17561 self.raw.is_none()
17562 }
17563
17564 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::UnionOfEndpointsUnion<'de>> {
17565 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17566 }
17567
17568 pub fn into_option(
17569 self,
17570 ) -> ::core::option::Option<crate::wire::UnionOfEndpointsUnion<'de>> {
17571 if self.is_some() {
17572 Some(crate::wire::UnionOfEndpointsUnion {
17573 raw: self.raw,
17574 _phantom: ::core::marker::PhantomData,
17575 })
17576 } else {
17577 None
17578 }
17579 }
17580 }
17581
17582 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnionOfEndpointsUnion<'de>
17583 where
17584 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17585 ___D: ::fidl_next::Decoder<'de>,
17586 ___D: ::fidl_next::fuchsia::HandleDecoder,
17587 {
17588 fn decode(
17589 mut slot: ::fidl_next::Slot<'_, Self>,
17590 decoder: &mut ___D,
17591 _: (),
17592 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17593 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17594 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17595 1 => ::fidl_next::wire::Union::decode_as::<
17596 ___D,
17597 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
17598 >(raw, decoder, ())?,
17599
17600 2 => ::fidl_next::wire::Union::decode_as::<
17601 ___D,
17602 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
17603 >(raw, decoder, ())?,
17604
17605 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17606 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17607 }
17608
17609 Ok(())
17610 }
17611 }
17612
17613 impl<'de> ::core::fmt::Debug for UnionOfEndpointsUnion<'de> {
17614 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17615 self.as_ref().fmt(f)
17616 }
17617 }
17618
17619 impl<'de> ::fidl_next::IntoNatural for UnionOfEndpointsUnion<'de> {
17620 type Natural = ::core::option::Option<crate::natural::UnionOfEndpointsUnion>;
17621 }
17622
17623 #[repr(transparent)]
17624 pub struct UnionOfHandle {
17625 pub(crate) raw: ::fidl_next::wire::Union,
17626 pub(crate) _phantom: ::core::marker::PhantomData<()>,
17627 }
17628
17629 impl ::fidl_next::Constrained for UnionOfHandle {
17630 type Constraint = ();
17631
17632 fn validate(
17633 _: ::fidl_next::Slot<'_, Self>,
17634 _: Self::Constraint,
17635 ) -> Result<(), ::fidl_next::ValidationError> {
17636 Ok(())
17637 }
17638 }
17639
17640 unsafe impl ::fidl_next::Wire for UnionOfHandle {
17641 type Narrowed<'de> = UnionOfHandle;
17642
17643 #[inline]
17644 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17645 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17646 ::fidl_next::wire::Union::zero_padding(raw);
17647 }
17648 }
17649
17650 impl UnionOfHandle {
17651 pub fn is_some(&self) -> bool {
17652 self.raw.is_some()
17653 }
17654
17655 pub fn is_none(&self) -> bool {
17656 self.raw.is_none()
17657 }
17658
17659 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::UnionOfHandle> {
17660 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17661 }
17662
17663 pub fn into_option(self) -> ::core::option::Option<crate::wire::UnionOfHandle> {
17664 if self.is_some() {
17665 Some(crate::wire::UnionOfHandle {
17666 raw: self.raw,
17667 _phantom: ::core::marker::PhantomData,
17668 })
17669 } else {
17670 None
17671 }
17672 }
17673 }
17674
17675 unsafe impl<___D> ::fidl_next::Decode<___D> for UnionOfHandle
17676 where
17677 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17678 ___D: ::fidl_next::fuchsia::HandleDecoder,
17679 {
17680 fn decode(
17681 mut slot: ::fidl_next::Slot<'_, Self>,
17682 decoder: &mut ___D,
17683 _: (),
17684 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17685 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17686 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17687 1 => ::fidl_next::wire::Union::decode_as_static::<
17688 ___D,
17689 ::fidl_next::wire::fuchsia::NullableHandle,
17690 >(raw, decoder, ())?,
17691
17692 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17693 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
17694 }
17695
17696 Ok(())
17697 }
17698 }
17699
17700 impl ::core::fmt::Debug for UnionOfHandle {
17701 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17702 self.as_ref().fmt(f)
17703 }
17704 }
17705
17706 impl ::fidl_next::IntoNatural for UnionOfHandle {
17707 type Natural = ::core::option::Option<crate::natural::UnionOfHandle>;
17708 }
17709
17710 #[repr(transparent)]
17711 pub struct VectorOfArrayOfEventInUnionWithReducedRights<'de> {
17712 pub(crate) raw: ::fidl_next::wire::Union,
17713 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
17714 }
17715
17716 impl ::fidl_next::Constrained for VectorOfArrayOfEventInUnionWithReducedRights<'_> {
17717 type Constraint = ();
17718
17719 fn validate(
17720 _: ::fidl_next::Slot<'_, Self>,
17721 _: Self::Constraint,
17722 ) -> Result<(), ::fidl_next::ValidationError> {
17723 Ok(())
17724 }
17725 }
17726
17727 unsafe impl ::fidl_next::Wire for VectorOfArrayOfEventInUnionWithReducedRights<'static> {
17728 type Narrowed<'de> = VectorOfArrayOfEventInUnionWithReducedRights<'de>;
17729
17730 #[inline]
17731 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
17732 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
17733 ::fidl_next::wire::Union::zero_padding(raw);
17734 }
17735 }
17736
17737 impl<'de> VectorOfArrayOfEventInUnionWithReducedRights<'de> {
17738 pub fn is_some(&self) -> bool {
17739 self.raw.is_some()
17740 }
17741
17742 pub fn is_none(&self) -> bool {
17743 self.raw.is_none()
17744 }
17745
17746 pub fn as_ref(
17747 &self,
17748 ) -> ::core::option::Option<&crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'de>>
17749 {
17750 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
17751 }
17752
17753 pub fn into_option(
17754 self,
17755 ) -> ::core::option::Option<crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'de>>
17756 {
17757 if self.is_some() {
17758 Some(crate::wire::VectorOfArrayOfEventInUnionWithReducedRights {
17759 raw: self.raw,
17760 _phantom: ::core::marker::PhantomData,
17761 })
17762 } else {
17763 None
17764 }
17765 }
17766 }
17767
17768 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
17769 for VectorOfArrayOfEventInUnionWithReducedRights<'de>
17770 where
17771 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
17772 ___D: ::fidl_next::Decoder<'de>,
17773 ___D: ::fidl_next::fuchsia::HandleDecoder,
17774 {
17775 fn decode(
17776 mut slot: ::fidl_next::Slot<'_, Self>,
17777 decoder: &mut ___D,
17778 _: (),
17779 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
17780 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
17781 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
17782 1 => ::fidl_next::wire::Union::decode_as::<
17783 ___D,
17784 ::fidl_next::wire::Vector<'de, [::fidl_next::wire::fuchsia::Event; 1]>,
17785 >(raw, decoder, (1, ()))?,
17786
17787 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
17788 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
17789 }
17790
17791 Ok(())
17792 }
17793 }
17794
17795 impl<'de> ::core::fmt::Debug for VectorOfArrayOfEventInUnionWithReducedRights<'de> {
17796 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
17797 self.as_ref().fmt(f)
17798 }
17799 }
17800
17801 impl<'de> ::fidl_next::IntoNatural for VectorOfArrayOfEventInUnionWithReducedRights<'de> {
17802 type Natural =
17803 ::core::option::Option<crate::natural::VectorOfArrayOfEventInUnionWithReducedRights>;
17804 }
17805}
17806
17807pub mod generic {
17808
17809 pub use fidl_next_common_test_conformance::generic::*;
17810
17811 pub struct AlternatingHandlesAndFailures<T0, T1, T2, T3, T4> {
17813 pub h1: T0,
17814
17815 pub failure_trigger1: T1,
17816
17817 pub h2: T2,
17818
17819 pub failure_trigger2: T3,
17820
17821 pub h3: T4,
17822 }
17823
17824 unsafe impl<___E, T0, T1, T2, T3, T4>
17825 ::fidl_next::Encode<crate::wire::AlternatingHandlesAndFailures<'static>, ___E>
17826 for AlternatingHandlesAndFailures<T0, T1, T2, T3, T4>
17827 where
17828 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17829 ___E: ::fidl_next::Encoder,
17830 ___E: ::fidl_next::fuchsia::HandleEncoder,
17831 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
17832 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
17833 T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
17834 T3: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
17835 T4: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
17836 {
17837 #[inline]
17838 fn encode(
17839 self,
17840 encoder_: &mut ___E,
17841 out_: &mut ::core::mem::MaybeUninit<
17842 crate::wire::AlternatingHandlesAndFailures<'static>,
17843 >,
17844 _: (),
17845 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17846 ::fidl_next::munge! {
17847 let crate::wire::AlternatingHandlesAndFailures {
17848 h1,
17849 failure_trigger1,
17850 h2,
17851 failure_trigger2,
17852 h3,
17853
17854 } = out_;
17855 }
17856
17857 ::fidl_next::Encode::encode(self.h1, encoder_, h1, ())?;
17858
17859 ::fidl_next::Encode::encode(self.failure_trigger1, encoder_, failure_trigger1, 1)?;
17860
17861 ::fidl_next::Encode::encode(self.h2, encoder_, h2, ())?;
17862
17863 ::fidl_next::Encode::encode(self.failure_trigger2, encoder_, failure_trigger2, 1)?;
17864
17865 ::fidl_next::Encode::encode(self.h3, encoder_, h3, ())?;
17866
17867 Ok(())
17868 }
17869 }
17870
17871 pub struct ArrayOfArrayOfNonnullableHandles<T0> {
17873 pub handles: T0,
17874 }
17875
17876 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArrayOfArrayOfNonnullableHandles, ___E>
17877 for ArrayOfArrayOfNonnullableHandles<T0>
17878 where
17879 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17880 ___E: ::fidl_next::fuchsia::HandleEncoder,
17881 T0: ::fidl_next::Encode<[[::fidl_next::wire::fuchsia::NullableHandle; 3]; 4], ___E>,
17882 {
17883 #[inline]
17884 fn encode(
17885 self,
17886 encoder_: &mut ___E,
17887 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfArrayOfNonnullableHandles>,
17888 _: (),
17889 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17890 ::fidl_next::munge! {
17891 let crate::wire::ArrayOfArrayOfNonnullableHandles {
17892 handles,
17893
17894 } = out_;
17895 }
17896
17897 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
17898
17899 Ok(())
17900 }
17901 }
17902
17903 pub struct ArrayOfHandles<T0> {
17905 pub a: T0,
17906 }
17907
17908 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArrayOfHandles, ___E> for ArrayOfHandles<T0>
17909 where
17910 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17911 ___E: ::fidl_next::fuchsia::HandleEncoder,
17912 T0: ::fidl_next::Encode<[::fidl_next::wire::fuchsia::NullableHandle; 3], ___E>,
17913 {
17914 #[inline]
17915 fn encode(
17916 self,
17917 encoder_: &mut ___E,
17918 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfHandles>,
17919 _: (),
17920 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17921 ::fidl_next::munge! {
17922 let crate::wire::ArrayOfHandles {
17923 a,
17924
17925 } = out_;
17926 }
17927
17928 ::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
17929
17930 Ok(())
17931 }
17932 }
17933
17934 pub struct ArrayOfNonnullableHandles<T0> {
17936 pub handles: T0,
17937 }
17938
17939 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArrayOfNonnullableHandles, ___E>
17940 for ArrayOfNonnullableHandles<T0>
17941 where
17942 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17943 ___E: ::fidl_next::fuchsia::HandleEncoder,
17944 T0: ::fidl_next::Encode<[::fidl_next::wire::fuchsia::NullableHandle; 4], ___E>,
17945 {
17946 #[inline]
17947 fn encode(
17948 self,
17949 encoder_: &mut ___E,
17950 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfNonnullableHandles>,
17951 _: (),
17952 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17953 ::fidl_next::munge! {
17954 let crate::wire::ArrayOfNonnullableHandles {
17955 handles,
17956
17957 } = out_;
17958 }
17959
17960 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
17961
17962 Ok(())
17963 }
17964 }
17965
17966 pub struct ArrayOfNullableHandles<T0> {
17968 pub handles: T0,
17969 }
17970
17971 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArrayOfNullableHandles, ___E>
17972 for ArrayOfNullableHandles<T0>
17973 where
17974 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17975 ___E: ::fidl_next::fuchsia::HandleEncoder,
17976 T0: ::fidl_next::Encode<[::fidl_next::wire::fuchsia::OptionalNullableHandle; 5], ___E>,
17977 {
17978 #[inline]
17979 fn encode(
17980 self,
17981 encoder_: &mut ___E,
17982 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfNullableHandles>,
17983 _: (),
17984 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17985 ::fidl_next::munge! {
17986 let crate::wire::ArrayOfNullableHandles {
17987 handles,
17988
17989 } = out_;
17990 }
17991
17992 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
17993
17994 Ok(())
17995 }
17996 }
17997
17998 pub struct ArrayOfOptionalHandles<T0> {
18000 pub a: T0,
18001 }
18002
18003 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArrayOfOptionalHandles, ___E>
18004 for ArrayOfOptionalHandles<T0>
18005 where
18006 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18007 ___E: ::fidl_next::fuchsia::HandleEncoder,
18008 T0: ::fidl_next::Encode<[::fidl_next::wire::fuchsia::OptionalNullableHandle; 3], ___E>,
18009 {
18010 #[inline]
18011 fn encode(
18012 self,
18013 encoder_: &mut ___E,
18014 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArrayOfOptionalHandles>,
18015 _: (),
18016 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18017 ::fidl_next::munge! {
18018 let crate::wire::ArrayOfOptionalHandles {
18019 a,
18020
18021 } = out_;
18022 }
18023
18024 ::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
18025
18026 Ok(())
18027 }
18028 }
18029
18030 pub struct ArrayOfVectorOfEventInStructWithDefaultRights<T0> {
18032 pub h: T0,
18033 }
18034
18035 unsafe impl<___E, T0>
18036 ::fidl_next::Encode<
18037 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
18038 ___E,
18039 > for ArrayOfVectorOfEventInStructWithDefaultRights<T0>
18040 where
18041 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18042 ___E: ::fidl_next::Encoder,
18043 ___E: ::fidl_next::fuchsia::HandleEncoder,
18044 T0: ::fidl_next::Encode<
18045 [::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::Event>; 1],
18046 ___E,
18047 >,
18048 {
18049 #[inline]
18050 fn encode(
18051 self,
18052 encoder_: &mut ___E,
18053 out_: &mut ::core::mem::MaybeUninit<
18054 crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights<'static>,
18055 >,
18056 _: (),
18057 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18058 ::fidl_next::munge! {
18059 let crate::wire::ArrayOfVectorOfEventInStructWithDefaultRights {
18060 h,
18061
18062 } = out_;
18063 }
18064
18065 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
18066
18067 Ok(())
18068 }
18069 }
18070
18071 pub struct ArrayOfVectorOfEventInStructWithReducedRights<T0> {
18073 pub h: T0,
18074 }
18075
18076 unsafe impl<___E, T0>
18077 ::fidl_next::Encode<
18078 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
18079 ___E,
18080 > for ArrayOfVectorOfEventInStructWithReducedRights<T0>
18081 where
18082 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18083 ___E: ::fidl_next::Encoder,
18084 ___E: ::fidl_next::fuchsia::HandleEncoder,
18085 T0: ::fidl_next::Encode<
18086 [::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::Event>; 1],
18087 ___E,
18088 >,
18089 {
18090 #[inline]
18091 fn encode(
18092 self,
18093 encoder_: &mut ___E,
18094 out_: &mut ::core::mem::MaybeUninit<
18095 crate::wire::ArrayOfVectorOfEventInStructWithReducedRights<'static>,
18096 >,
18097 _: (),
18098 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18099 ::fidl_next::munge! {
18100 let crate::wire::ArrayOfVectorOfEventInStructWithReducedRights {
18101 h,
18102
18103 } = out_;
18104 }
18105
18106 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
18107
18108 Ok(())
18109 }
18110 }
18111
18112 pub struct ArrayOfVectorOfEventInTableWithDefaultRightsStruct<T0> {
18114 pub t: T0,
18115 }
18116
18117 unsafe impl<___E, T0>
18118 ::fidl_next::Encode<
18119 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
18120 ___E,
18121 > for ArrayOfVectorOfEventInTableWithDefaultRightsStruct<T0>
18122 where
18123 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18124 ___E: ::fidl_next::Encoder,
18125 ___E: ::fidl_next::fuchsia::HandleEncoder,
18126 T0: ::fidl_next::Encode<
18127 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRights<'static>,
18128 ___E,
18129 >,
18130 {
18131 #[inline]
18132 fn encode(
18133 self,
18134 encoder_: &mut ___E,
18135 out_: &mut ::core::mem::MaybeUninit<
18136 crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct<'static>,
18137 >,
18138 _: (),
18139 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18140 ::fidl_next::munge! {
18141 let crate::wire::ArrayOfVectorOfEventInTableWithDefaultRightsStruct {
18142 t,
18143
18144 } = out_;
18145 }
18146
18147 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
18148
18149 Ok(())
18150 }
18151 }
18152
18153 pub struct ArrayOfVectorOfEventInTableWithReducedRightsStruct<T0> {
18155 pub t: T0,
18156 }
18157
18158 unsafe impl<___E, T0>
18159 ::fidl_next::Encode<
18160 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
18161 ___E,
18162 > for ArrayOfVectorOfEventInTableWithReducedRightsStruct<T0>
18163 where
18164 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18165 ___E: ::fidl_next::Encoder,
18166 ___E: ::fidl_next::fuchsia::HandleEncoder,
18167 T0: ::fidl_next::Encode<
18168 crate::wire::ArrayOfVectorOfEventInTableWithReducedRights<'static>,
18169 ___E,
18170 >,
18171 {
18172 #[inline]
18173 fn encode(
18174 self,
18175 encoder_: &mut ___E,
18176 out_: &mut ::core::mem::MaybeUninit<
18177 crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct<'static>,
18178 >,
18179 _: (),
18180 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18181 ::fidl_next::munge! {
18182 let crate::wire::ArrayOfVectorOfEventInTableWithReducedRightsStruct {
18183 t,
18184
18185 } = out_;
18186 }
18187
18188 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
18189
18190 Ok(())
18191 }
18192 }
18193
18194 pub struct ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<T0> {
18196 pub u: T0,
18197 }
18198
18199 unsafe impl<___E, T0>
18200 ::fidl_next::Encode<
18201 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
18202 ___E,
18203 > for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<T0>
18204 where
18205 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18206 ___E: ::fidl_next::Encoder,
18207 ___E: ::fidl_next::fuchsia::HandleEncoder,
18208 T0: ::fidl_next::Encode<
18209 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRights<'static>,
18210 ___E,
18211 >,
18212 {
18213 #[inline]
18214 fn encode(
18215 self,
18216 encoder_: &mut ___E,
18217 out_: &mut ::core::mem::MaybeUninit<
18218 crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct<'static>,
18219 >,
18220 _: (),
18221 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18222 ::fidl_next::munge! {
18223 let crate::wire::ArrayOfVectorOfEventInUnionWithDefaultRightsStruct {
18224 u,
18225
18226 } = out_;
18227 }
18228
18229 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
18230
18231 Ok(())
18232 }
18233 }
18234
18235 pub struct ArrayOfVectorOfEventInUnionWithReducedRightsStruct<T0> {
18237 pub u: T0,
18238 }
18239
18240 unsafe impl<___E, T0>
18241 ::fidl_next::Encode<
18242 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
18243 ___E,
18244 > for ArrayOfVectorOfEventInUnionWithReducedRightsStruct<T0>
18245 where
18246 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18247 ___E: ::fidl_next::Encoder,
18248 ___E: ::fidl_next::fuchsia::HandleEncoder,
18249 T0: ::fidl_next::Encode<
18250 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRights<'static>,
18251 ___E,
18252 >,
18253 {
18254 #[inline]
18255 fn encode(
18256 self,
18257 encoder_: &mut ___E,
18258 out_: &mut ::core::mem::MaybeUninit<
18259 crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct<'static>,
18260 >,
18261 _: (),
18262 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18263 ::fidl_next::munge! {
18264 let crate::wire::ArrayOfVectorOfEventInUnionWithReducedRightsStruct {
18265 u,
18266
18267 } = out_;
18268 }
18269
18270 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
18271
18272 Ok(())
18273 }
18274 }
18275
18276 pub struct Bounded32NonnullableVectorOfHandles<T0> {
18278 pub vh0: T0,
18279 }
18280
18281 unsafe impl<___E, T0>
18282 ::fidl_next::Encode<crate::wire::Bounded32NonnullableVectorOfHandles<'static>, ___E>
18283 for Bounded32NonnullableVectorOfHandles<T0>
18284 where
18285 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18286 ___E: ::fidl_next::Encoder,
18287 ___E: ::fidl_next::fuchsia::HandleEncoder,
18288 T0: ::fidl_next::Encode<
18289 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
18290 ___E,
18291 >,
18292 {
18293 #[inline]
18294 fn encode(
18295 self,
18296 encoder_: &mut ___E,
18297 out_: &mut ::core::mem::MaybeUninit<
18298 crate::wire::Bounded32NonnullableVectorOfHandles<'static>,
18299 >,
18300 _: (),
18301 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18302 ::fidl_next::munge! {
18303 let crate::wire::Bounded32NonnullableVectorOfHandles {
18304 vh0,
18305
18306 } = out_;
18307 }
18308
18309 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (32, ()))?;
18310
18311 Ok(())
18312 }
18313 }
18314
18315 pub struct Bounded32NullableVectorOfHandles<T0> {
18317 pub vh0: T0,
18318 }
18319
18320 unsafe impl<___E, T0>
18321 ::fidl_next::Encode<crate::wire::Bounded32NullableVectorOfHandles<'static>, ___E>
18322 for Bounded32NullableVectorOfHandles<T0>
18323 where
18324 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18325 ___E: ::fidl_next::Encoder,
18326 ___E: ::fidl_next::fuchsia::HandleEncoder,
18327 T0: ::fidl_next::Encode<
18328 ::fidl_next::wire::OptionalVector<
18329 'static,
18330 ::fidl_next::wire::fuchsia::NullableHandle,
18331 >,
18332 ___E,
18333 >,
18334 {
18335 #[inline]
18336 fn encode(
18337 self,
18338 encoder_: &mut ___E,
18339 out_: &mut ::core::mem::MaybeUninit<
18340 crate::wire::Bounded32NullableVectorOfHandles<'static>,
18341 >,
18342 _: (),
18343 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18344 ::fidl_next::munge! {
18345 let crate::wire::Bounded32NullableVectorOfHandles {
18346 vh0,
18347
18348 } = out_;
18349 }
18350
18351 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (32, ()))?;
18352
18353 Ok(())
18354 }
18355 }
18356
18357 pub struct BoxOfSingleHandle<T0> {
18359 pub b: T0,
18360 }
18361
18362 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BoxOfSingleHandle<'static>, ___E>
18363 for BoxOfSingleHandle<T0>
18364 where
18365 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18366 ___E: ::fidl_next::Encoder,
18367 ___E: ::fidl_next::fuchsia::HandleEncoder,
18368 T0: ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::SingleHandle>, ___E>,
18369 {
18370 #[inline]
18371 fn encode(
18372 self,
18373 encoder_: &mut ___E,
18374 out_: &mut ::core::mem::MaybeUninit<crate::wire::BoxOfSingleHandle<'static>>,
18375 _: (),
18376 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18377 ::fidl_next::munge! {
18378 let crate::wire::BoxOfSingleHandle {
18379 b,
18380
18381 } = out_;
18382 }
18383
18384 ::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
18385
18386 Ok(())
18387 }
18388 }
18389
18390 pub struct BoxOfSingleOptionalHandle<T0> {
18392 pub b: T0,
18393 }
18394
18395 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::BoxOfSingleOptionalHandle<'static>, ___E>
18396 for BoxOfSingleOptionalHandle<T0>
18397 where
18398 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18399 ___E: ::fidl_next::Encoder,
18400 ___E: ::fidl_next::fuchsia::HandleEncoder,
18401 T0: ::fidl_next::Encode<
18402 ::fidl_next::wire::Box<'static, crate::wire::SingleOptionalHandle>,
18403 ___E,
18404 >,
18405 {
18406 #[inline]
18407 fn encode(
18408 self,
18409 encoder_: &mut ___E,
18410 out_: &mut ::core::mem::MaybeUninit<crate::wire::BoxOfSingleOptionalHandle<'static>>,
18411 _: (),
18412 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18413 ::fidl_next::munge! {
18414 let crate::wire::BoxOfSingleOptionalHandle {
18415 b,
18416
18417 } = out_;
18418 }
18419
18420 ::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
18421
18422 Ok(())
18423 }
18424 }
18425
18426 pub struct LaunchInfo<T0, T1, T2, T3, T4, T5, T6> {
18428 pub url: T0,
18429
18430 pub arguments: T1,
18431
18432 pub out: T2,
18433
18434 pub err: T3,
18435
18436 pub directory_request: T4,
18437
18438 pub flat_namespace: T5,
18439
18440 pub additional_services: T6,
18441 }
18442
18443 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
18444 ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>
18445 for LaunchInfo<T0, T1, T2, T3, T4, T5, T6>
18446 where
18447 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18448 ___E: ::fidl_next::Encoder,
18449 ___E: ::fidl_next::fuchsia::HandleEncoder,
18450 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
18451 T1: ::fidl_next::Encode<
18452 ::fidl_next::wire::OptionalVector<'static, ::fidl_next::wire::String<'static>>,
18453 ___E,
18454 >,
18455 T2: ::fidl_next::Encode<
18456 ::fidl_next::wire::Box<'static, crate::wire::TransformerEmptyStruct>,
18457 ___E,
18458 >,
18459 T3: ::fidl_next::Encode<
18460 ::fidl_next::wire::Box<'static, crate::wire::TransformerEmptyStruct>,
18461 ___E,
18462 >,
18463 T4: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalChannel, ___E>,
18464 T5: ::fidl_next::Encode<
18465 ::fidl_next::wire::Box<'static, crate::wire::TransformerEmptyStruct>,
18466 ___E,
18467 >,
18468 T6: ::fidl_next::Encode<
18469 ::fidl_next::wire::Box<'static, crate::wire::TransformerEmptyStruct>,
18470 ___E,
18471 >,
18472 {
18473 #[inline]
18474 fn encode(
18475 self,
18476 encoder_: &mut ___E,
18477 out_: &mut ::core::mem::MaybeUninit<crate::wire::LaunchInfo<'static>>,
18478 _: (),
18479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18480 ::fidl_next::munge! {
18481 let crate::wire::LaunchInfo {
18482 url,
18483 arguments,
18484 out,
18485 err,
18486 directory_request,
18487 flat_namespace,
18488 additional_services,
18489
18490 } = out_;
18491 }
18492
18493 ::fidl_next::Encode::encode(self.url, encoder_, url, 200)?;
18494
18495 ::fidl_next::Encode::encode(
18496 self.arguments,
18497 encoder_,
18498 arguments,
18499 (4294967295, 4294967295),
18500 )?;
18501
18502 ::fidl_next::Encode::encode(self.out, encoder_, out, ())?;
18503
18504 ::fidl_next::Encode::encode(self.err, encoder_, err, ())?;
18505
18506 ::fidl_next::Encode::encode(self.directory_request, encoder_, directory_request, ())?;
18507
18508 ::fidl_next::Encode::encode(self.flat_namespace, encoder_, flat_namespace, ())?;
18509
18510 ::fidl_next::Encode::encode(
18511 self.additional_services,
18512 encoder_,
18513 additional_services,
18514 (),
18515 )?;
18516
18517 Ok(())
18518 }
18519 }
18520
18521 pub struct CreateComponentRequest<T0, T1> {
18523 pub launch_info: T0,
18524
18525 pub controller: T1,
18526 }
18527
18528 unsafe impl<___E, T0, T1>
18529 ::fidl_next::Encode<crate::wire::CreateComponentRequest<'static>, ___E>
18530 for CreateComponentRequest<T0, T1>
18531 where
18532 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18533 ___E: ::fidl_next::Encoder,
18534 ___E: ::fidl_next::fuchsia::HandleEncoder,
18535 T0: ::fidl_next::Encode<crate::wire::LaunchInfo<'static>, ___E>,
18536 T1: ::fidl_next::Encode<
18537 ::fidl_next::ServerEnd<
18538 crate::ComponentController,
18539 ::fidl_next::wire::fuchsia::OptionalChannel,
18540 >,
18541 ___E,
18542 >,
18543 {
18544 #[inline]
18545 fn encode(
18546 self,
18547 encoder_: &mut ___E,
18548 out_: &mut ::core::mem::MaybeUninit<crate::wire::CreateComponentRequest<'static>>,
18549 _: (),
18550 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18551 ::fidl_next::munge! {
18552 let crate::wire::CreateComponentRequest {
18553 launch_info,
18554 controller,
18555
18556 } = out_;
18557 }
18558
18559 ::fidl_next::Encode::encode(self.launch_info, encoder_, launch_info, ())?;
18560
18561 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
18562
18563 Ok(())
18564 }
18565 }
18566
18567 pub struct EmptyResourceTableStruct<T0> {
18569 pub table: T0,
18570 }
18571
18572 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::EmptyResourceTableStruct<'static>, ___E>
18573 for EmptyResourceTableStruct<T0>
18574 where
18575 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18576 ___E: ::fidl_next::Encoder,
18577 ___E: ::fidl_next::fuchsia::HandleEncoder,
18578 T0: ::fidl_next::Encode<crate::wire::EmptyResourceTable<'static>, ___E>,
18579 {
18580 #[inline]
18581 fn encode(
18582 self,
18583 encoder_: &mut ___E,
18584 out_: &mut ::core::mem::MaybeUninit<crate::wire::EmptyResourceTableStruct<'static>>,
18585 _: (),
18586 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18587 ::fidl_next::munge! {
18588 let crate::wire::EmptyResourceTableStruct {
18589 table,
18590
18591 } = out_;
18592 }
18593
18594 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
18595
18596 Ok(())
18597 }
18598 }
18599
18600 pub struct EnvelopeInliningTestUnionStruct<T0> {
18602 pub u: T0,
18603 }
18604
18605 unsafe impl<___E, T0>
18606 ::fidl_next::Encode<crate::wire::EnvelopeInliningTestUnionStruct<'static>, ___E>
18607 for EnvelopeInliningTestUnionStruct<T0>
18608 where
18609 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18610 ___E: ::fidl_next::Encoder,
18611 ___E: ::fidl_next::fuchsia::HandleEncoder,
18612 T0: ::fidl_next::Encode<crate::wire::EnvelopeInliningTestUnion<'static>, ___E>,
18613 {
18614 #[inline]
18615 fn encode(
18616 self,
18617 encoder_: &mut ___E,
18618 out_: &mut ::core::mem::MaybeUninit<
18619 crate::wire::EnvelopeInliningTestUnionStruct<'static>,
18620 >,
18621 _: (),
18622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18623 ::fidl_next::munge! {
18624 let crate::wire::EnvelopeInliningTestUnionStruct {
18625 u,
18626
18627 } = out_;
18628 }
18629
18630 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
18631
18632 Ok(())
18633 }
18634 }
18635
18636 pub struct EventWithDefaultRights<T0> {
18638 pub h: T0,
18639 }
18640
18641 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::EventWithDefaultRights, ___E>
18642 for EventWithDefaultRights<T0>
18643 where
18644 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18645 ___E: ::fidl_next::fuchsia::HandleEncoder,
18646 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
18647 {
18648 #[inline]
18649 fn encode(
18650 self,
18651 encoder_: &mut ___E,
18652 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventWithDefaultRights>,
18653 _: (),
18654 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18655 ::fidl_next::munge! {
18656 let crate::wire::EventWithDefaultRights {
18657 h,
18658
18659 } = out_;
18660 }
18661
18662 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
18663
18664 Ok(())
18665 }
18666 }
18667
18668 pub struct EventWithReducedRights<T0> {
18670 pub h: T0,
18671 }
18672
18673 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::EventWithReducedRights, ___E>
18674 for EventWithReducedRights<T0>
18675 where
18676 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18677 ___E: ::fidl_next::fuchsia::HandleEncoder,
18678 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
18679 {
18680 #[inline]
18681 fn encode(
18682 self,
18683 encoder_: &mut ___E,
18684 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventWithReducedRights>,
18685 _: (),
18686 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18687 ::fidl_next::munge! {
18688 let crate::wire::EventWithReducedRights {
18689 h,
18690
18691 } = out_;
18692 }
18693
18694 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
18695
18696 Ok(())
18697 }
18698 }
18699
18700 pub struct FidlvizDemo<
18702 T0,
18703 T1,
18704 T2,
18705 T3,
18706 T4,
18707 T5,
18708 T6,
18709 T7,
18710 T8,
18711 T9,
18712 T10,
18713 T11,
18714 T12,
18715 T13,
18716 T14,
18717 T15,
18718 T16,
18719 T17,
18720 T18,
18721 T19,
18722 T20,
18723 T21,
18724 T22,
18725 T23,
18726 T24,
18727 T25,
18728 T26,
18729 T27,
18730 T28,
18731 T29,
18732 T30,
18733 > {
18734 pub f1: T0,
18735
18736 pub f2: T1,
18737
18738 pub f3: T2,
18739
18740 pub f4: T3,
18741
18742 pub f5: T4,
18743
18744 pub f6: T5,
18745
18746 pub f7: T6,
18747
18748 pub f8: T7,
18749
18750 pub f9: T8,
18751
18752 pub f10: T9,
18753
18754 pub f11: T10,
18755
18756 pub f12: T11,
18757
18758 pub f13: T12,
18759
18760 pub f14: T13,
18761
18762 pub f15: T14,
18763
18764 pub f16: T15,
18765
18766 pub f17: T16,
18767
18768 pub f18: T17,
18769
18770 pub f19: T18,
18771
18772 pub f20: T19,
18773
18774 pub f21: T20,
18775
18776 pub f22: T21,
18777
18778 pub f23: T22,
18779
18780 pub f24: T23,
18781
18782 pub f25: T24,
18783
18784 pub f26: T25,
18785
18786 pub f27: T26,
18787
18788 pub f28: T27,
18789
18790 pub f29: T28,
18791
18792 pub f30: T29,
18793
18794 pub f31: T30,
18795 }
18796
18797 unsafe impl<
18798 ___E,
18799 T0,
18800 T1,
18801 T2,
18802 T3,
18803 T4,
18804 T5,
18805 T6,
18806 T7,
18807 T8,
18808 T9,
18809 T10,
18810 T11,
18811 T12,
18812 T13,
18813 T14,
18814 T15,
18815 T16,
18816 T17,
18817 T18,
18818 T19,
18819 T20,
18820 T21,
18821 T22,
18822 T23,
18823 T24,
18824 T25,
18825 T26,
18826 T27,
18827 T28,
18828 T29,
18829 T30,
18830 > ::fidl_next::Encode<crate::wire::FidlvizDemo<'static>, ___E>
18831 for FidlvizDemo<
18832 T0,
18833 T1,
18834 T2,
18835 T3,
18836 T4,
18837 T5,
18838 T6,
18839 T7,
18840 T8,
18841 T9,
18842 T10,
18843 T11,
18844 T12,
18845 T13,
18846 T14,
18847 T15,
18848 T16,
18849 T17,
18850 T18,
18851 T19,
18852 T20,
18853 T21,
18854 T22,
18855 T23,
18856 T24,
18857 T25,
18858 T26,
18859 T27,
18860 T28,
18861 T29,
18862 T30,
18863 >
18864 where
18865 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18866 ___E: ::fidl_next::Encoder,
18867 ___E: ::fidl_next::fuchsia::HandleEncoder,
18868 T0: ::fidl_next::Encode<u8, ___E>,
18869 T1: ::fidl_next::Encode<i8, ___E>,
18870 T2: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
18871 T3: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
18872 T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
18873 T5: ::fidl_next::Encode<u8, ___E>,
18874 T6: ::fidl_next::Encode<u8, ___E>,
18875 T7: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
18876 T8: ::fidl_next::Encode<::fidl_next::wire::Float32, ___E>,
18877 T9: ::fidl_next::Encode<::fidl_next::wire::Float64, ___E>,
18878 T10: ::fidl_next::Encode<bool, ___E>,
18879 T11: ::fidl_next::Encode<bool, ___E>,
18880 T12: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
18881 T13: ::fidl_next::Encode<::fidl_next::wire::OptionalString<'static>, ___E>,
18882 T14: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
18883 T15: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
18884 T16: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
18885 T17: ::fidl_next::Encode<[u8; 3], ___E>,
18886 T18: ::fidl_next::Encode<
18887 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Float64>,
18888 ___E,
18889 >,
18890 T19: ::fidl_next::Encode<::fidl_next::wire::OptionalVector<'static, u8>, ___E>,
18891 T20: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
18892 T21: ::fidl_next::Encode<crate::wire::FidlvizBits, ___E>,
18893 T22: ::fidl_next::Encode<crate::wire::FidlvizEnum, ___E>,
18894 T23: ::fidl_next::Encode<crate::wire::FidlvizStruct1, ___E>,
18895 T24: ::fidl_next::Encode<crate::wire::FidlvizStruct2, ___E>,
18896 T25:
18897 ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::FidlvizStruct1>, ___E>,
18898 T26:
18899 ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::FidlvizStruct2>, ___E>,
18900 T27: ::fidl_next::Encode<crate::wire::FidlvizTable<'static>, ___E>,
18901 T28: ::fidl_next::Encode<crate::wire::FidlvizTable<'static>, ___E>,
18902 T29: ::fidl_next::Encode<crate::wire_optional::FidlvizUnion<'static>, ___E>,
18903 T30: ::fidl_next::Encode<crate::wire::FidlvizUnion<'static>, ___E>,
18904 {
18905 #[inline]
18906 fn encode(
18907 self,
18908 encoder_: &mut ___E,
18909 out_: &mut ::core::mem::MaybeUninit<crate::wire::FidlvizDemo<'static>>,
18910 _: (),
18911 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
18912 ::fidl_next::munge! {
18913 let crate::wire::FidlvizDemo {
18914 f1,
18915 f2,
18916 f3,
18917 f4,
18918 f5,
18919 f6,
18920 f7,
18921 f8,
18922 f9,
18923 f10,
18924 f11,
18925 f12,
18926 f13,
18927 f14,
18928 f15,
18929 f16,
18930 f17,
18931 f18,
18932 f19,
18933 f20,
18934 f21,
18935 f22,
18936 f23,
18937 f24,
18938 f25,
18939 f26,
18940 f27,
18941 f28,
18942 f29,
18943 f30,
18944 f31,
18945
18946 } = out_;
18947 }
18948
18949 ::fidl_next::Encode::encode(self.f1, encoder_, f1, ())?;
18950
18951 ::fidl_next::Encode::encode(self.f2, encoder_, f2, ())?;
18952
18953 ::fidl_next::Encode::encode(self.f3, encoder_, f3, ())?;
18954
18955 ::fidl_next::Encode::encode(self.f4, encoder_, f4, ())?;
18956
18957 ::fidl_next::Encode::encode(self.f5, encoder_, f5, ())?;
18958
18959 ::fidl_next::Encode::encode(self.f6, encoder_, f6, ())?;
18960
18961 ::fidl_next::Encode::encode(self.f7, encoder_, f7, ())?;
18962
18963 ::fidl_next::Encode::encode(self.f8, encoder_, f8, ())?;
18964
18965 ::fidl_next::Encode::encode(self.f9, encoder_, f9, ())?;
18966
18967 ::fidl_next::Encode::encode(self.f10, encoder_, f10, ())?;
18968
18969 ::fidl_next::Encode::encode(self.f11, encoder_, f11, ())?;
18970
18971 ::fidl_next::Encode::encode(self.f12, encoder_, f12, ())?;
18972
18973 ::fidl_next::Encode::encode(self.f13, encoder_, f13, 4294967295)?;
18974
18975 ::fidl_next::Encode::encode(self.f14, encoder_, f14, 4294967295)?;
18976
18977 ::fidl_next::Encode::encode(self.f15, encoder_, f15, 4294967295)?;
18978
18979 ::fidl_next::Encode::encode(self.f16, encoder_, f16, ())?;
18980
18981 ::fidl_next::Encode::encode(self.f17, encoder_, f17, ())?;
18982
18983 ::fidl_next::Encode::encode(self.f18, encoder_, f18, ())?;
18984
18985 ::fidl_next::Encode::encode(self.f19, encoder_, f19, (4294967295, ()))?;
18986
18987 ::fidl_next::Encode::encode(self.f20, encoder_, f20, (4294967295, ()))?;
18988
18989 ::fidl_next::Encode::encode(self.f21, encoder_, f21, (4294967295, ()))?;
18990
18991 ::fidl_next::Encode::encode(self.f22, encoder_, f22, ())?;
18992
18993 ::fidl_next::Encode::encode(self.f23, encoder_, f23, ())?;
18994
18995 ::fidl_next::Encode::encode(self.f24, encoder_, f24, ())?;
18996
18997 ::fidl_next::Encode::encode(self.f25, encoder_, f25, ())?;
18998
18999 ::fidl_next::Encode::encode(self.f26, encoder_, f26, ())?;
19000
19001 ::fidl_next::Encode::encode(self.f27, encoder_, f27, ())?;
19002
19003 ::fidl_next::Encode::encode(self.f28, encoder_, f28, ())?;
19004
19005 ::fidl_next::Encode::encode(self.f29, encoder_, f29, ())?;
19006
19007 ::fidl_next::Encode::encode(self.f30, encoder_, f30, ())?;
19008
19009 ::fidl_next::Encode::encode(self.f31, encoder_, f31, ())?;
19010
19011 Ok(())
19012 }
19013 }
19014
19015 pub struct GoldenHandleBasicRightsStruct<T0> {
19017 pub v: T0,
19018 }
19019
19020 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::GoldenHandleBasicRightsStruct, ___E>
19021 for GoldenHandleBasicRightsStruct<T0>
19022 where
19023 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19024 ___E: ::fidl_next::fuchsia::HandleEncoder,
19025 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
19026 {
19027 #[inline]
19028 fn encode(
19029 self,
19030 encoder_: &mut ___E,
19031 out_: &mut ::core::mem::MaybeUninit<crate::wire::GoldenHandleBasicRightsStruct>,
19032 _: (),
19033 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19034 ::fidl_next::munge! {
19035 let crate::wire::GoldenHandleBasicRightsStruct {
19036 v,
19037
19038 } = out_;
19039 }
19040
19041 ::fidl_next::Encode::encode(self.v, encoder_, v, ())?;
19042
19043 Ok(())
19044 }
19045 }
19046
19047 pub struct GoldenNullableHandleStruct<T0> {
19049 pub v: T0,
19050 }
19051
19052 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::GoldenNullableHandleStruct, ___E>
19053 for GoldenNullableHandleStruct<T0>
19054 where
19055 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19056 ___E: ::fidl_next::fuchsia::HandleEncoder,
19057 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
19058 {
19059 #[inline]
19060 fn encode(
19061 self,
19062 encoder_: &mut ___E,
19063 out_: &mut ::core::mem::MaybeUninit<crate::wire::GoldenNullableHandleStruct>,
19064 _: (),
19065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19066 ::fidl_next::munge! {
19067 let crate::wire::GoldenNullableHandleStruct {
19068 v,
19069
19070 } = out_;
19071 }
19072
19073 ::fidl_next::Encode::encode(self.v, encoder_, v, ())?;
19074
19075 Ok(())
19076 }
19077 }
19078
19079 pub struct MultipleBoundedNonnullableVectorsOfHandles<T0, T1> {
19081 pub vh0: T0,
19082
19083 pub vh1: T1,
19084 }
19085
19086 unsafe impl<___E, T0, T1>
19087 ::fidl_next::Encode<crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>, ___E>
19088 for MultipleBoundedNonnullableVectorsOfHandles<T0, T1>
19089 where
19090 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19091 ___E: ::fidl_next::Encoder,
19092 ___E: ::fidl_next::fuchsia::HandleEncoder,
19093 T0: ::fidl_next::Encode<
19094 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
19095 ___E,
19096 >,
19097 T1: ::fidl_next::Encode<
19098 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
19099 ___E,
19100 >,
19101 {
19102 #[inline]
19103 fn encode(
19104 self,
19105 encoder_: &mut ___E,
19106 out_: &mut ::core::mem::MaybeUninit<
19107 crate::wire::MultipleBoundedNonnullableVectorsOfHandles<'static>,
19108 >,
19109 _: (),
19110 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19111 ::fidl_next::munge! {
19112 let crate::wire::MultipleBoundedNonnullableVectorsOfHandles {
19113 vh0,
19114 vh1,
19115
19116 } = out_;
19117 }
19118
19119 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (2, ()))?;
19120
19121 ::fidl_next::Encode::encode(self.vh1, encoder_, vh1, (32, ()))?;
19122
19123 Ok(())
19124 }
19125 }
19126
19127 pub struct MultipleBoundedNullableVectorsOfHandles<T0, T1> {
19129 pub vh0: T0,
19130
19131 pub vh1: T1,
19132 }
19133
19134 unsafe impl<___E, T0, T1>
19135 ::fidl_next::Encode<crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>, ___E>
19136 for MultipleBoundedNullableVectorsOfHandles<T0, T1>
19137 where
19138 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19139 ___E: ::fidl_next::Encoder,
19140 ___E: ::fidl_next::fuchsia::HandleEncoder,
19141 T0: ::fidl_next::Encode<
19142 ::fidl_next::wire::OptionalVector<
19143 'static,
19144 ::fidl_next::wire::fuchsia::NullableHandle,
19145 >,
19146 ___E,
19147 >,
19148 T1: ::fidl_next::Encode<
19149 ::fidl_next::wire::OptionalVector<
19150 'static,
19151 ::fidl_next::wire::fuchsia::NullableHandle,
19152 >,
19153 ___E,
19154 >,
19155 {
19156 #[inline]
19157 fn encode(
19158 self,
19159 encoder_: &mut ___E,
19160 out_: &mut ::core::mem::MaybeUninit<
19161 crate::wire::MultipleBoundedNullableVectorsOfHandles<'static>,
19162 >,
19163 _: (),
19164 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19165 ::fidl_next::munge! {
19166 let crate::wire::MultipleBoundedNullableVectorsOfHandles {
19167 vh0,
19168 vh1,
19169
19170 } = out_;
19171 }
19172
19173 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (2, ()))?;
19174
19175 ::fidl_next::Encode::encode(self.vh1, encoder_, vh1, (32, ()))?;
19176
19177 Ok(())
19178 }
19179 }
19180
19181 pub struct MultipleHandleSubtypes<T0, T1, T2> {
19183 pub untyped: T0,
19184
19185 pub event: T1,
19186
19187 pub channel: T2,
19188 }
19189
19190 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::MultipleHandleSubtypes, ___E>
19191 for MultipleHandleSubtypes<T0, T1, T2>
19192 where
19193 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19194 ___E: ::fidl_next::fuchsia::HandleEncoder,
19195 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
19196 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
19197 T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
19198 {
19199 #[inline]
19200 fn encode(
19201 self,
19202 encoder_: &mut ___E,
19203 out_: &mut ::core::mem::MaybeUninit<crate::wire::MultipleHandleSubtypes>,
19204 _: (),
19205 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19206 ::fidl_next::munge! {
19207 let crate::wire::MultipleHandleSubtypes {
19208 untyped,
19209 event,
19210 channel,
19211
19212 } = out_;
19213 }
19214
19215 ::fidl_next::Encode::encode(self.untyped, encoder_, untyped, ())?;
19216
19217 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
19218
19219 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
19220
19221 Ok(())
19222 }
19223 }
19224
19225 pub struct MultipleNonnullableHandles<T0, T1, T2, T3, T4, T5> {
19227 pub data0: T0,
19228
19229 pub handle0: T1,
19230
19231 pub data1: T2,
19232
19233 pub handle1: T3,
19234
19235 pub handle2: T4,
19236
19237 pub data2: T5,
19238 }
19239
19240 unsafe impl<___E, T0, T1, T2, T3, T4, T5>
19241 ::fidl_next::Encode<crate::wire::MultipleNonnullableHandles, ___E>
19242 for MultipleNonnullableHandles<T0, T1, T2, T3, T4, T5>
19243 where
19244 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19245 ___E: ::fidl_next::fuchsia::HandleEncoder,
19246 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
19247 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
19248 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19249 T3: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
19250 T4: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
19251 T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19252 {
19253 #[inline]
19254 fn encode(
19255 self,
19256 encoder_: &mut ___E,
19257 out_: &mut ::core::mem::MaybeUninit<crate::wire::MultipleNonnullableHandles>,
19258 _: (),
19259 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19260 ::fidl_next::munge! {
19261 let crate::wire::MultipleNonnullableHandles {
19262 data0,
19263 handle0,
19264 data1,
19265 handle1,
19266 handle2,
19267 data2,
19268
19269 } = out_;
19270 }
19271
19272 ::fidl_next::Encode::encode(self.data0, encoder_, data0, ())?;
19273
19274 ::fidl_next::Encode::encode(self.handle0, encoder_, handle0, ())?;
19275
19276 ::fidl_next::Encode::encode(self.data1, encoder_, data1, ())?;
19277
19278 ::fidl_next::Encode::encode(self.handle1, encoder_, handle1, ())?;
19279
19280 ::fidl_next::Encode::encode(self.handle2, encoder_, handle2, ())?;
19281
19282 ::fidl_next::Encode::encode(self.data2, encoder_, data2, ())?;
19283
19284 Ok(())
19285 }
19286 }
19287
19288 pub struct MultipleNullableHandles<T0, T1, T2, T3, T4, T5> {
19290 pub data0: T0,
19291
19292 pub handle0: T1,
19293
19294 pub data1: T2,
19295
19296 pub handle1: T3,
19297
19298 pub handle2: T4,
19299
19300 pub data2: T5,
19301 }
19302
19303 unsafe impl<___E, T0, T1, T2, T3, T4, T5>
19304 ::fidl_next::Encode<crate::wire::MultipleNullableHandles, ___E>
19305 for MultipleNullableHandles<T0, T1, T2, T3, T4, T5>
19306 where
19307 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19308 ___E: ::fidl_next::fuchsia::HandleEncoder,
19309 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
19310 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
19311 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19312 T3: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalChannel, ___E>,
19313 T4: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>,
19314 T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
19315 {
19316 #[inline]
19317 fn encode(
19318 self,
19319 encoder_: &mut ___E,
19320 out_: &mut ::core::mem::MaybeUninit<crate::wire::MultipleNullableHandles>,
19321 _: (),
19322 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19323 ::fidl_next::munge! {
19324 let crate::wire::MultipleNullableHandles {
19325 data0,
19326 handle0,
19327 data1,
19328 handle1,
19329 handle2,
19330 data2,
19331
19332 } = out_;
19333 }
19334
19335 ::fidl_next::Encode::encode(self.data0, encoder_, data0, ())?;
19336
19337 ::fidl_next::Encode::encode(self.handle0, encoder_, handle0, ())?;
19338
19339 ::fidl_next::Encode::encode(self.data1, encoder_, data1, ())?;
19340
19341 ::fidl_next::Encode::encode(self.handle1, encoder_, handle1, ())?;
19342
19343 ::fidl_next::Encode::encode(self.handle2, encoder_, handle2, ())?;
19344
19345 ::fidl_next::Encode::encode(self.data2, encoder_, data2, ())?;
19346
19347 Ok(())
19348 }
19349 }
19350
19351 pub struct NonnullableHandle<T0> {
19353 pub h: T0,
19354 }
19355
19356 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NonnullableHandle, ___E>
19357 for NonnullableHandle<T0>
19358 where
19359 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19360 ___E: ::fidl_next::fuchsia::HandleEncoder,
19361 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
19362 {
19363 #[inline]
19364 fn encode(
19365 self,
19366 encoder_: &mut ___E,
19367 out_: &mut ::core::mem::MaybeUninit<crate::wire::NonnullableHandle>,
19368 _: (),
19369 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19370 ::fidl_next::munge! {
19371 let crate::wire::NonnullableHandle {
19372 h,
19373
19374 } = out_;
19375 }
19376
19377 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
19378
19379 Ok(())
19380 }
19381 }
19382
19383 pub struct NonnullableHandleArray<T0> {
19385 pub handles: T0,
19386 }
19387
19388 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NonnullableHandleArray, ___E>
19389 for NonnullableHandleArray<T0>
19390 where
19391 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19392 ___E: ::fidl_next::fuchsia::HandleEncoder,
19393 T0: ::fidl_next::Encode<[::fidl_next::wire::fuchsia::NullableHandle; 4], ___E>,
19394 {
19395 #[inline]
19396 fn encode(
19397 self,
19398 encoder_: &mut ___E,
19399 out_: &mut ::core::mem::MaybeUninit<crate::wire::NonnullableHandleArray>,
19400 _: (),
19401 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19402 ::fidl_next::munge! {
19403 let crate::wire::NonnullableHandleArray {
19404 handles,
19405
19406 } = out_;
19407 }
19408
19409 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
19410
19411 Ok(())
19412 }
19413 }
19414
19415 pub struct NullableHandle<T0> {
19417 pub h: T0,
19418 }
19419
19420 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NullableHandle, ___E> for NullableHandle<T0>
19421 where
19422 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19423 ___E: ::fidl_next::fuchsia::HandleEncoder,
19424 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
19425 {
19426 #[inline]
19427 fn encode(
19428 self,
19429 encoder_: &mut ___E,
19430 out_: &mut ::core::mem::MaybeUninit<crate::wire::NullableHandle>,
19431 _: (),
19432 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19433 ::fidl_next::munge! {
19434 let crate::wire::NullableHandle {
19435 h,
19436
19437 } = out_;
19438 }
19439
19440 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
19441
19442 Ok(())
19443 }
19444 }
19445
19446 pub struct OutOfLineArrayOfNonnullableHandles<T0> {
19448 pub handles: T0,
19449 }
19450
19451 unsafe impl<___E, T0>
19452 ::fidl_next::Encode<crate::wire::OutOfLineArrayOfNonnullableHandles<'static>, ___E>
19453 for OutOfLineArrayOfNonnullableHandles<T0>
19454 where
19455 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19456 ___E: ::fidl_next::Encoder,
19457 ___E: ::fidl_next::fuchsia::HandleEncoder,
19458 T0: ::fidl_next::Encode<
19459 ::fidl_next::wire::Box<'static, crate::wire::NonnullableHandleArray>,
19460 ___E,
19461 >,
19462 {
19463 #[inline]
19464 fn encode(
19465 self,
19466 encoder_: &mut ___E,
19467 out_: &mut ::core::mem::MaybeUninit<
19468 crate::wire::OutOfLineArrayOfNonnullableHandles<'static>,
19469 >,
19470 _: (),
19471 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19472 ::fidl_next::munge! {
19473 let crate::wire::OutOfLineArrayOfNonnullableHandles {
19474 handles,
19475
19476 } = out_;
19477 }
19478
19479 ::fidl_next::Encode::encode(self.handles, encoder_, handles, ())?;
19480
19481 Ok(())
19482 }
19483 }
19484
19485 pub struct Sandwich6<T0, T1, T2> {
19487 pub before: T0,
19488
19489 pub the_union: T1,
19490
19491 pub after: T2,
19492 }
19493
19494 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Sandwich6<'static>, ___E>
19495 for Sandwich6<T0, T1, T2>
19496 where
19497 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19498 ___E: ::fidl_next::Encoder,
19499 ___E: ::fidl_next::fuchsia::HandleEncoder,
19500 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
19501 T1: ::fidl_next::Encode<crate::wire::UnionWithVector<'static>, ___E>,
19502 T2: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
19503 {
19504 #[inline]
19505 fn encode(
19506 self,
19507 encoder_: &mut ___E,
19508 out_: &mut ::core::mem::MaybeUninit<crate::wire::Sandwich6<'static>>,
19509 _: (),
19510 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19511 ::fidl_next::munge! {
19512 let crate::wire::Sandwich6 {
19513 before,
19514 the_union,
19515 after,
19516
19517 } = out_;
19518 }
19519
19520 ::fidl_next::Encode::encode(self.before, encoder_, before, ())?;
19521
19522 ::fidl_next::Encode::encode(self.the_union, encoder_, the_union, ())?;
19523
19524 ::fidl_next::Encode::encode(self.after, encoder_, after, ())?;
19525
19526 Ok(())
19527 }
19528 }
19529
19530 pub struct ShortStringThenHandle<T0, T1> {
19532 pub s: T0,
19533
19534 pub h: T1,
19535 }
19536
19537 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ShortStringThenHandle<'static>, ___E>
19538 for ShortStringThenHandle<T0, T1>
19539 where
19540 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19541 ___E: ::fidl_next::Encoder,
19542 ___E: ::fidl_next::fuchsia::HandleEncoder,
19543 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
19544 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
19545 {
19546 #[inline]
19547 fn encode(
19548 self,
19549 encoder_: &mut ___E,
19550 out_: &mut ::core::mem::MaybeUninit<crate::wire::ShortStringThenHandle<'static>>,
19551 _: (),
19552 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19553 ::fidl_next::munge! {
19554 let crate::wire::ShortStringThenHandle {
19555 s,
19556 h,
19557
19558 } = out_;
19559 }
19560
19561 ::fidl_next::Encode::encode(self.s, encoder_, s, 1)?;
19562
19563 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
19564
19565 Ok(())
19566 }
19567 }
19568
19569 pub struct SingleHandle<T0> {
19571 pub h: T0,
19572 }
19573
19574 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SingleHandle, ___E> for SingleHandle<T0>
19575 where
19576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19577 ___E: ::fidl_next::fuchsia::HandleEncoder,
19578 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
19579 {
19580 #[inline]
19581 fn encode(
19582 self,
19583 encoder_: &mut ___E,
19584 out_: &mut ::core::mem::MaybeUninit<crate::wire::SingleHandle>,
19585 _: (),
19586 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19587 ::fidl_next::munge! {
19588 let crate::wire::SingleHandle {
19589 h,
19590
19591 } = out_;
19592 }
19593
19594 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
19595
19596 Ok(())
19597 }
19598 }
19599
19600 pub struct SingleOptionalHandle<T0> {
19602 pub h: T0,
19603 }
19604
19605 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SingleOptionalHandle, ___E>
19606 for SingleOptionalHandle<T0>
19607 where
19608 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19609 ___E: ::fidl_next::fuchsia::HandleEncoder,
19610 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
19611 {
19612 #[inline]
19613 fn encode(
19614 self,
19615 encoder_: &mut ___E,
19616 out_: &mut ::core::mem::MaybeUninit<crate::wire::SingleOptionalHandle>,
19617 _: (),
19618 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19619 ::fidl_next::munge! {
19620 let crate::wire::SingleOptionalHandle {
19621 h,
19622
19623 } = out_;
19624 }
19625
19626 ::fidl_next::Encode::encode(self.h, encoder_, h, ())?;
19627
19628 Ok(())
19629 }
19630 }
19631
19632 pub struct StructOfEndpoints<T0, T1, T2, T3> {
19634 pub client_end: T0,
19635
19636 pub optional_client_end: T1,
19637
19638 pub server_end: T2,
19639
19640 pub optional_server_end: T3,
19641 }
19642
19643 unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<crate::wire::StructOfEndpoints, ___E>
19644 for StructOfEndpoints<T0, T1, T2, T3>
19645 where
19646 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19647 ___E: ::fidl_next::fuchsia::HandleEncoder,
19648 T0: ::fidl_next::Encode<
19649 ::fidl_next::ClientEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
19650 ___E,
19651 >,
19652 T1: ::fidl_next::Encode<
19653 ::fidl_next::ClientEnd<
19654 crate::Protocol,
19655 ::fidl_next::wire::fuchsia::OptionalChannel,
19656 >,
19657 ___E,
19658 >,
19659 T2: ::fidl_next::Encode<
19660 ::fidl_next::ServerEnd<crate::Protocol, ::fidl_next::wire::fuchsia::Channel>,
19661 ___E,
19662 >,
19663 T3: ::fidl_next::Encode<
19664 ::fidl_next::ServerEnd<
19665 crate::Protocol,
19666 ::fidl_next::wire::fuchsia::OptionalChannel,
19667 >,
19668 ___E,
19669 >,
19670 {
19671 #[inline]
19672 fn encode(
19673 self,
19674 encoder_: &mut ___E,
19675 out_: &mut ::core::mem::MaybeUninit<crate::wire::StructOfEndpoints>,
19676 _: (),
19677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19678 ::fidl_next::munge! {
19679 let crate::wire::StructOfEndpoints {
19680 client_end,
19681 optional_client_end,
19682 server_end,
19683 optional_server_end,
19684
19685 } = out_;
19686 }
19687
19688 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
19689
19690 ::fidl_next::Encode::encode(
19691 self.optional_client_end,
19692 encoder_,
19693 optional_client_end,
19694 (),
19695 )?;
19696
19697 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
19698
19699 ::fidl_next::Encode::encode(
19700 self.optional_server_end,
19701 encoder_,
19702 optional_server_end,
19703 (),
19704 )?;
19705
19706 Ok(())
19707 }
19708 }
19709
19710 pub struct StructOfOptionalUnionOfHandle<T0> {
19712 pub u: T0,
19713 }
19714
19715 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::StructOfOptionalUnionOfHandle, ___E>
19716 for StructOfOptionalUnionOfHandle<T0>
19717 where
19718 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19719 ___E: ::fidl_next::fuchsia::HandleEncoder,
19720 T0: ::fidl_next::Encode<crate::wire_optional::UnionOfHandle, ___E>,
19721 {
19722 #[inline]
19723 fn encode(
19724 self,
19725 encoder_: &mut ___E,
19726 out_: &mut ::core::mem::MaybeUninit<crate::wire::StructOfOptionalUnionOfHandle>,
19727 _: (),
19728 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19729 ::fidl_next::munge! {
19730 let crate::wire::StructOfOptionalUnionOfHandle {
19731 u,
19732
19733 } = out_;
19734 }
19735
19736 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
19737
19738 Ok(())
19739 }
19740 }
19741
19742 pub struct StructOfSimpleResourceTable<T0> {
19744 pub table: T0,
19745 }
19746
19747 unsafe impl<___E, T0>
19748 ::fidl_next::Encode<crate::wire::StructOfSimpleResourceTable<'static>, ___E>
19749 for StructOfSimpleResourceTable<T0>
19750 where
19751 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19752 ___E: ::fidl_next::Encoder,
19753 ___E: ::fidl_next::fuchsia::HandleEncoder,
19754 T0: ::fidl_next::Encode<crate::wire::SimpleResourceTable<'static>, ___E>,
19755 {
19756 #[inline]
19757 fn encode(
19758 self,
19759 encoder_: &mut ___E,
19760 out_: &mut ::core::mem::MaybeUninit<crate::wire::StructOfSimpleResourceTable<'static>>,
19761 _: (),
19762 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19763 ::fidl_next::munge! {
19764 let crate::wire::StructOfSimpleResourceTable {
19765 table,
19766
19767 } = out_;
19768 }
19769
19770 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
19771
19772 Ok(())
19773 }
19774 }
19775
19776 pub struct TableFieldInlinedHandleStruct<T0> {
19778 pub t: T0,
19779 }
19780
19781 unsafe impl<___E, T0>
19782 ::fidl_next::Encode<crate::wire::TableFieldInlinedHandleStruct<'static>, ___E>
19783 for TableFieldInlinedHandleStruct<T0>
19784 where
19785 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19786 ___E: ::fidl_next::Encoder,
19787 ___E: ::fidl_next::fuchsia::HandleEncoder,
19788 T0: ::fidl_next::Encode<crate::wire::TableFieldInlinedHandle<'static>, ___E>,
19789 {
19790 #[inline]
19791 fn encode(
19792 self,
19793 encoder_: &mut ___E,
19794 out_: &mut ::core::mem::MaybeUninit<
19795 crate::wire::TableFieldInlinedHandleStruct<'static>,
19796 >,
19797 _: (),
19798 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19799 ::fidl_next::munge! {
19800 let crate::wire::TableFieldInlinedHandleStruct {
19801 t,
19802
19803 } = out_;
19804 }
19805
19806 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
19807
19808 Ok(())
19809 }
19810 }
19811
19812 pub struct TableFieldUnknownResourceStruct<T0> {
19814 pub t: T0,
19815 }
19816
19817 unsafe impl<___E, T0>
19818 ::fidl_next::Encode<crate::wire::TableFieldUnknownResourceStruct<'static>, ___E>
19819 for TableFieldUnknownResourceStruct<T0>
19820 where
19821 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19822 ___E: ::fidl_next::Encoder,
19823 ___E: ::fidl_next::fuchsia::HandleEncoder,
19824 T0: ::fidl_next::Encode<crate::wire::TableFieldUnknownResource<'static>, ___E>,
19825 {
19826 #[inline]
19827 fn encode(
19828 self,
19829 encoder_: &mut ___E,
19830 out_: &mut ::core::mem::MaybeUninit<
19831 crate::wire::TableFieldUnknownResourceStruct<'static>,
19832 >,
19833 _: (),
19834 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19835 ::fidl_next::munge! {
19836 let crate::wire::TableFieldUnknownResourceStruct {
19837 t,
19838
19839 } = out_;
19840 }
19841
19842 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
19843
19844 Ok(())
19845 }
19846 }
19847
19848 pub struct TableOfEndpoints<T0> {
19850 pub t: T0,
19851 }
19852
19853 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::TableOfEndpoints<'static>, ___E>
19854 for TableOfEndpoints<T0>
19855 where
19856 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19857 ___E: ::fidl_next::Encoder,
19858 ___E: ::fidl_next::fuchsia::HandleEncoder,
19859 T0: ::fidl_next::Encode<crate::wire::TableOfEndpointsTable<'static>, ___E>,
19860 {
19861 #[inline]
19862 fn encode(
19863 self,
19864 encoder_: &mut ___E,
19865 out_: &mut ::core::mem::MaybeUninit<crate::wire::TableOfEndpoints<'static>>,
19866 _: (),
19867 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19868 ::fidl_next::munge! {
19869 let crate::wire::TableOfEndpoints {
19870 t,
19871
19872 } = out_;
19873 }
19874
19875 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
19876
19877 Ok(())
19878 }
19879 }
19880
19881 pub struct TableUnionWithVectorReservedSandwichStruct<T0> {
19883 pub table: T0,
19884 }
19885
19886 unsafe impl<___E, T0>
19887 ::fidl_next::Encode<crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>, ___E>
19888 for TableUnionWithVectorReservedSandwichStruct<T0>
19889 where
19890 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19891 ___E: ::fidl_next::Encoder,
19892 ___E: ::fidl_next::fuchsia::HandleEncoder,
19893 T0: ::fidl_next::Encode<crate::wire::TableUnionWithVectorReservedSandwich<'static>, ___E>,
19894 {
19895 #[inline]
19896 fn encode(
19897 self,
19898 encoder_: &mut ___E,
19899 out_: &mut ::core::mem::MaybeUninit<
19900 crate::wire::TableUnionWithVectorReservedSandwichStruct<'static>,
19901 >,
19902 _: (),
19903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19904 ::fidl_next::munge! {
19905 let crate::wire::TableUnionWithVectorReservedSandwichStruct {
19906 table,
19907
19908 } = out_;
19909 }
19910
19911 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
19912
19913 Ok(())
19914 }
19915 }
19916
19917 pub struct TableUnionWithVectorStructSandwichStruct<T0> {
19919 pub table: T0,
19920 }
19921
19922 unsafe impl<___E, T0>
19923 ::fidl_next::Encode<crate::wire::TableUnionWithVectorStructSandwichStruct<'static>, ___E>
19924 for TableUnionWithVectorStructSandwichStruct<T0>
19925 where
19926 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19927 ___E: ::fidl_next::Encoder,
19928 ___E: ::fidl_next::fuchsia::HandleEncoder,
19929 T0: ::fidl_next::Encode<crate::wire::TableUnionWithVectorStructSandwich<'static>, ___E>,
19930 {
19931 #[inline]
19932 fn encode(
19933 self,
19934 encoder_: &mut ___E,
19935 out_: &mut ::core::mem::MaybeUninit<
19936 crate::wire::TableUnionWithVectorStructSandwichStruct<'static>,
19937 >,
19938 _: (),
19939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19940 ::fidl_next::munge! {
19941 let crate::wire::TableUnionWithVectorStructSandwichStruct {
19942 table,
19943
19944 } = out_;
19945 }
19946
19947 ::fidl_next::Encode::encode(self.table, encoder_, table, ())?;
19948
19949 Ok(())
19950 }
19951 }
19952
19953 pub struct TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<T0> {
19955 pub t: T0,
19956 }
19957
19958 unsafe impl<___E, T0>
19959 ::fidl_next::Encode<
19960 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
19961 ___E,
19962 > for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<T0>
19963 where
19964 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19965 ___E: ::fidl_next::Encoder,
19966 ___E: ::fidl_next::fuchsia::HandleEncoder,
19967 T0: ::fidl_next::Encode<
19968 crate::wire::TableWithUnknownEnvelopesAfterKnownEnvelopes<'static>,
19969 ___E,
19970 >,
19971 {
19972 #[inline]
19973 fn encode(
19974 self,
19975 encoder_: &mut ___E,
19976 out_: &mut ::core::mem::MaybeUninit<
19977 crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct<'static>,
19978 >,
19979 _: (),
19980 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
19981 ::fidl_next::munge! {
19982 let crate::wire::TableWithUnknownEnveloepsAfterKnownEnvelopesStruct {
19983 t,
19984
19985 } = out_;
19986 }
19987
19988 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
19989
19990 Ok(())
19991 }
19992 }
19993
19994 pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<T0> {
19996 pub t: T0,
19997 }
19998
19999 unsafe impl<___E, T0>
20000 ::fidl_next::Encode<
20001 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
20002 ___E,
20003 > for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<T0>
20004 where
20005 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20006 ___E: ::fidl_next::Encoder,
20007 ___E: ::fidl_next::fuchsia::HandleEncoder,
20008 T0: ::fidl_next::Encode<
20009 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopes<'static>,
20010 ___E,
20011 >,
20012 {
20013 #[inline]
20014 fn encode(
20015 self,
20016 encoder_: &mut ___E,
20017 out_: &mut ::core::mem::MaybeUninit<
20018 crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct<'static>,
20019 >,
20020 _: (),
20021 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20022 ::fidl_next::munge! {
20023 let crate::wire::TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct {
20024 t,
20025
20026 } = out_;
20027 }
20028
20029 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
20030
20031 Ok(())
20032 }
20033 }
20034
20035 pub struct TestFlexibleResourceXUnionInStruct<T0> {
20037 pub xu: T0,
20038 }
20039
20040 unsafe impl<___E, T0>
20041 ::fidl_next::Encode<crate::wire::TestFlexibleResourceXUnionInStruct<'static>, ___E>
20042 for TestFlexibleResourceXUnionInStruct<T0>
20043 where
20044 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20045 ___E: ::fidl_next::Encoder,
20046 ___E: ::fidl_next::fuchsia::HandleEncoder,
20047 T0: ::fidl_next::Encode<crate::wire::SampleResourceXUnion<'static>, ___E>,
20048 {
20049 #[inline]
20050 fn encode(
20051 self,
20052 encoder_: &mut ___E,
20053 out_: &mut ::core::mem::MaybeUninit<
20054 crate::wire::TestFlexibleResourceXUnionInStruct<'static>,
20055 >,
20056 _: (),
20057 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20058 ::fidl_next::munge! {
20059 let crate::wire::TestFlexibleResourceXUnionInStruct {
20060 xu,
20061
20062 } = out_;
20063 }
20064
20065 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
20066
20067 Ok(())
20068 }
20069 }
20070
20071 pub struct TestOptionalFlexibleResourceXUnionInStruct<T0> {
20073 pub xu: T0,
20074 }
20075
20076 unsafe impl<___E, T0>
20077 ::fidl_next::Encode<crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>, ___E>
20078 for TestOptionalFlexibleResourceXUnionInStruct<T0>
20079 where
20080 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20081 ___E: ::fidl_next::Encoder,
20082 ___E: ::fidl_next::fuchsia::HandleEncoder,
20083 T0: ::fidl_next::Encode<crate::wire_optional::SampleResourceXUnion<'static>, ___E>,
20084 {
20085 #[inline]
20086 fn encode(
20087 self,
20088 encoder_: &mut ___E,
20089 out_: &mut ::core::mem::MaybeUninit<
20090 crate::wire::TestOptionalFlexibleResourceXUnionInStruct<'static>,
20091 >,
20092 _: (),
20093 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20094 ::fidl_next::munge! {
20095 let crate::wire::TestOptionalFlexibleResourceXUnionInStruct {
20096 xu,
20097
20098 } = out_;
20099 }
20100
20101 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
20102
20103 Ok(())
20104 }
20105 }
20106
20107 pub struct TestOptionalStrictResourceXUnionInStruct<T0> {
20109 pub xu: T0,
20110 }
20111
20112 unsafe impl<___E, T0>
20113 ::fidl_next::Encode<crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>, ___E>
20114 for TestOptionalStrictResourceXUnionInStruct<T0>
20115 where
20116 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20117 ___E: ::fidl_next::Encoder,
20118 ___E: ::fidl_next::fuchsia::HandleEncoder,
20119 T0: ::fidl_next::Encode<crate::wire_optional::SampleStrictResourceXUnion<'static>, ___E>,
20120 {
20121 #[inline]
20122 fn encode(
20123 self,
20124 encoder_: &mut ___E,
20125 out_: &mut ::core::mem::MaybeUninit<
20126 crate::wire::TestOptionalStrictResourceXUnionInStruct<'static>,
20127 >,
20128 _: (),
20129 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20130 ::fidl_next::munge! {
20131 let crate::wire::TestOptionalStrictResourceXUnionInStruct {
20132 xu,
20133
20134 } = out_;
20135 }
20136
20137 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
20138
20139 Ok(())
20140 }
20141 }
20142
20143 pub struct TestPackageResolverResolveRequest<T0, T1, T2, T3> {
20145 pub package_url: T0,
20146
20147 pub selectors: T1,
20148
20149 pub update_policy: T2,
20150
20151 pub this_should_be_a_handle: T3,
20152 }
20153
20154 unsafe impl<___E, T0, T1, T2, T3>
20155 ::fidl_next::Encode<crate::wire::TestPackageResolverResolveRequest<'static>, ___E>
20156 for TestPackageResolverResolveRequest<T0, T1, T2, T3>
20157 where
20158 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20159 ___E: ::fidl_next::Encoder,
20160 ___E: ::fidl_next::fuchsia::HandleEncoder,
20161 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
20162 T1: ::fidl_next::Encode<
20163 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
20164 ___E,
20165 >,
20166 T2: ::fidl_next::Encode<crate::wire::UpdatePolicy, ___E>,
20167 T3: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
20168 {
20169 #[inline]
20170 fn encode(
20171 self,
20172 encoder_: &mut ___E,
20173 out_: &mut ::core::mem::MaybeUninit<
20174 crate::wire::TestPackageResolverResolveRequest<'static>,
20175 >,
20176 _: (),
20177 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20178 ::fidl_next::munge! {
20179 let crate::wire::TestPackageResolverResolveRequest {
20180 package_url,
20181 selectors,
20182 update_policy,
20183 this_should_be_a_handle,
20184
20185 } = out_;
20186 }
20187
20188 ::fidl_next::Encode::encode(self.package_url, encoder_, package_url, 4294967295)?;
20189
20190 ::fidl_next::Encode::encode(
20191 self.selectors,
20192 encoder_,
20193 selectors,
20194 (4294967295, 4294967295),
20195 )?;
20196
20197 ::fidl_next::Encode::encode(self.update_policy, encoder_, update_policy, ())?;
20198
20199 ::fidl_next::Encode::encode(
20200 self.this_should_be_a_handle,
20201 encoder_,
20202 this_should_be_a_handle,
20203 (),
20204 )?;
20205
20206 Ok(())
20207 }
20208 }
20209
20210 pub struct TestStrictResourceXUnionInStruct<T0> {
20212 pub xu: T0,
20213 }
20214
20215 unsafe impl<___E, T0>
20216 ::fidl_next::Encode<crate::wire::TestStrictResourceXUnionInStruct<'static>, ___E>
20217 for TestStrictResourceXUnionInStruct<T0>
20218 where
20219 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20220 ___E: ::fidl_next::Encoder,
20221 ___E: ::fidl_next::fuchsia::HandleEncoder,
20222 T0: ::fidl_next::Encode<crate::wire::SampleStrictResourceXUnion<'static>, ___E>,
20223 {
20224 #[inline]
20225 fn encode(
20226 self,
20227 encoder_: &mut ___E,
20228 out_: &mut ::core::mem::MaybeUninit<
20229 crate::wire::TestStrictResourceXUnionInStruct<'static>,
20230 >,
20231 _: (),
20232 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20233 ::fidl_next::munge! {
20234 let crate::wire::TestStrictResourceXUnionInStruct {
20235 xu,
20236
20237 } = out_;
20238 }
20239
20240 ::fidl_next::Encode::encode(self.xu, encoder_, xu, ())?;
20241
20242 Ok(())
20243 }
20244 }
20245
20246 pub struct UnboundedNonnullableVectorOfHandles<T0> {
20248 pub vh0: T0,
20249 }
20250
20251 unsafe impl<___E, T0>
20252 ::fidl_next::Encode<crate::wire::UnboundedNonnullableVectorOfHandles<'static>, ___E>
20253 for UnboundedNonnullableVectorOfHandles<T0>
20254 where
20255 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20256 ___E: ::fidl_next::Encoder,
20257 ___E: ::fidl_next::fuchsia::HandleEncoder,
20258 T0: ::fidl_next::Encode<
20259 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
20260 ___E,
20261 >,
20262 {
20263 #[inline]
20264 fn encode(
20265 self,
20266 encoder_: &mut ___E,
20267 out_: &mut ::core::mem::MaybeUninit<
20268 crate::wire::UnboundedNonnullableVectorOfHandles<'static>,
20269 >,
20270 _: (),
20271 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20272 ::fidl_next::munge! {
20273 let crate::wire::UnboundedNonnullableVectorOfHandles {
20274 vh0,
20275
20276 } = out_;
20277 }
20278
20279 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (4294967295, ()))?;
20280
20281 Ok(())
20282 }
20283 }
20284
20285 pub struct UnboundedNullableVectorOfHandles<T0> {
20287 pub vh0: T0,
20288 }
20289
20290 unsafe impl<___E, T0>
20291 ::fidl_next::Encode<crate::wire::UnboundedNullableVectorOfHandles<'static>, ___E>
20292 for UnboundedNullableVectorOfHandles<T0>
20293 where
20294 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20295 ___E: ::fidl_next::Encoder,
20296 ___E: ::fidl_next::fuchsia::HandleEncoder,
20297 T0: ::fidl_next::Encode<
20298 ::fidl_next::wire::OptionalVector<
20299 'static,
20300 ::fidl_next::wire::fuchsia::NullableHandle,
20301 >,
20302 ___E,
20303 >,
20304 {
20305 #[inline]
20306 fn encode(
20307 self,
20308 encoder_: &mut ___E,
20309 out_: &mut ::core::mem::MaybeUninit<
20310 crate::wire::UnboundedNullableVectorOfHandles<'static>,
20311 >,
20312 _: (),
20313 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20314 ::fidl_next::munge! {
20315 let crate::wire::UnboundedNullableVectorOfHandles {
20316 vh0,
20317
20318 } = out_;
20319 }
20320
20321 ::fidl_next::Encode::encode(self.vh0, encoder_, vh0, (4294967295, ()))?;
20322
20323 Ok(())
20324 }
20325 }
20326
20327 pub struct UnionOfEndpoints<T0> {
20329 pub u: T0,
20330 }
20331
20332 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::UnionOfEndpoints<'static>, ___E>
20333 for UnionOfEndpoints<T0>
20334 where
20335 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20336 ___E: ::fidl_next::Encoder,
20337 ___E: ::fidl_next::fuchsia::HandleEncoder,
20338 T0: ::fidl_next::Encode<crate::wire::UnionOfEndpointsUnion<'static>, ___E>,
20339 {
20340 #[inline]
20341 fn encode(
20342 self,
20343 encoder_: &mut ___E,
20344 out_: &mut ::core::mem::MaybeUninit<crate::wire::UnionOfEndpoints<'static>>,
20345 _: (),
20346 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20347 ::fidl_next::munge! {
20348 let crate::wire::UnionOfEndpoints {
20349 u,
20350
20351 } = out_;
20352 }
20353
20354 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
20355
20356 Ok(())
20357 }
20358 }
20359
20360 pub struct VectorOfArrayOfEventInStructWithDefaultRights<T0> {
20362 pub h: T0,
20363 }
20364
20365 unsafe impl<___E, T0>
20366 ::fidl_next::Encode<
20367 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
20368 ___E,
20369 > for VectorOfArrayOfEventInStructWithDefaultRights<T0>
20370 where
20371 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20372 ___E: ::fidl_next::Encoder,
20373 ___E: ::fidl_next::fuchsia::HandleEncoder,
20374 T0: ::fidl_next::Encode<
20375 ::fidl_next::wire::Vector<'static, [::fidl_next::wire::fuchsia::Event; 1]>,
20376 ___E,
20377 >,
20378 {
20379 #[inline]
20380 fn encode(
20381 self,
20382 encoder_: &mut ___E,
20383 out_: &mut ::core::mem::MaybeUninit<
20384 crate::wire::VectorOfArrayOfEventInStructWithDefaultRights<'static>,
20385 >,
20386 _: (),
20387 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20388 ::fidl_next::munge! {
20389 let crate::wire::VectorOfArrayOfEventInStructWithDefaultRights {
20390 h,
20391
20392 } = out_;
20393 }
20394
20395 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
20396
20397 Ok(())
20398 }
20399 }
20400
20401 pub struct VectorOfArrayOfEventInStructWithReducedRights<T0> {
20403 pub h: T0,
20404 }
20405
20406 unsafe impl<___E, T0>
20407 ::fidl_next::Encode<
20408 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
20409 ___E,
20410 > for VectorOfArrayOfEventInStructWithReducedRights<T0>
20411 where
20412 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20413 ___E: ::fidl_next::Encoder,
20414 ___E: ::fidl_next::fuchsia::HandleEncoder,
20415 T0: ::fidl_next::Encode<
20416 ::fidl_next::wire::Vector<'static, [::fidl_next::wire::fuchsia::Event; 1]>,
20417 ___E,
20418 >,
20419 {
20420 #[inline]
20421 fn encode(
20422 self,
20423 encoder_: &mut ___E,
20424 out_: &mut ::core::mem::MaybeUninit<
20425 crate::wire::VectorOfArrayOfEventInStructWithReducedRights<'static>,
20426 >,
20427 _: (),
20428 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20429 ::fidl_next::munge! {
20430 let crate::wire::VectorOfArrayOfEventInStructWithReducedRights {
20431 h,
20432
20433 } = out_;
20434 }
20435
20436 ::fidl_next::Encode::encode(self.h, encoder_, h, (1, ()))?;
20437
20438 Ok(())
20439 }
20440 }
20441
20442 pub struct VectorOfArrayOfEventInTableWithReducedRightsStruct<T0> {
20444 pub t: T0,
20445 }
20446
20447 unsafe impl<___E, T0>
20448 ::fidl_next::Encode<
20449 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
20450 ___E,
20451 > for VectorOfArrayOfEventInTableWithReducedRightsStruct<T0>
20452 where
20453 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20454 ___E: ::fidl_next::Encoder,
20455 ___E: ::fidl_next::fuchsia::HandleEncoder,
20456 T0: ::fidl_next::Encode<
20457 crate::wire::VectorOfArrayOfEventInTableWithReducedRights<'static>,
20458 ___E,
20459 >,
20460 {
20461 #[inline]
20462 fn encode(
20463 self,
20464 encoder_: &mut ___E,
20465 out_: &mut ::core::mem::MaybeUninit<
20466 crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct<'static>,
20467 >,
20468 _: (),
20469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20470 ::fidl_next::munge! {
20471 let crate::wire::VectorOfArrayOfEventInTableWithReducedRightsStruct {
20472 t,
20473
20474 } = out_;
20475 }
20476
20477 ::fidl_next::Encode::encode(self.t, encoder_, t, ())?;
20478
20479 Ok(())
20480 }
20481 }
20482
20483 pub struct VectorOfArrayOfEventInUnionWithReducedRightsStruct<T0> {
20485 pub u: T0,
20486 }
20487
20488 unsafe impl<___E, T0>
20489 ::fidl_next::Encode<
20490 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
20491 ___E,
20492 > for VectorOfArrayOfEventInUnionWithReducedRightsStruct<T0>
20493 where
20494 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20495 ___E: ::fidl_next::Encoder,
20496 ___E: ::fidl_next::fuchsia::HandleEncoder,
20497 T0: ::fidl_next::Encode<
20498 crate::wire::VectorOfArrayOfEventInUnionWithReducedRights<'static>,
20499 ___E,
20500 >,
20501 {
20502 #[inline]
20503 fn encode(
20504 self,
20505 encoder_: &mut ___E,
20506 out_: &mut ::core::mem::MaybeUninit<
20507 crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct<'static>,
20508 >,
20509 _: (),
20510 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20511 ::fidl_next::munge! {
20512 let crate::wire::VectorOfArrayOfEventInUnionWithReducedRightsStruct {
20513 u,
20514
20515 } = out_;
20516 }
20517
20518 ::fidl_next::Encode::encode(self.u, encoder_, u, ())?;
20519
20520 Ok(())
20521 }
20522 }
20523
20524 pub struct VectorOfHandles<T0> {
20526 pub v: T0,
20527 }
20528
20529 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::VectorOfHandles<'static>, ___E>
20530 for VectorOfHandles<T0>
20531 where
20532 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20533 ___E: ::fidl_next::Encoder,
20534 ___E: ::fidl_next::fuchsia::HandleEncoder,
20535 T0: ::fidl_next::Encode<
20536 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
20537 ___E,
20538 >,
20539 {
20540 #[inline]
20541 fn encode(
20542 self,
20543 encoder_: &mut ___E,
20544 out_: &mut ::core::mem::MaybeUninit<crate::wire::VectorOfHandles<'static>>,
20545 _: (),
20546 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20547 ::fidl_next::munge! {
20548 let crate::wire::VectorOfHandles {
20549 v,
20550
20551 } = out_;
20552 }
20553
20554 ::fidl_next::Encode::encode(self.v, encoder_, v, (4294967295, ()))?;
20555
20556 Ok(())
20557 }
20558 }
20559
20560 pub struct VectorOfOptionalHandles<T0> {
20562 pub v: T0,
20563 }
20564
20565 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::VectorOfOptionalHandles<'static>, ___E>
20566 for VectorOfOptionalHandles<T0>
20567 where
20568 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20569 ___E: ::fidl_next::Encoder,
20570 ___E: ::fidl_next::fuchsia::HandleEncoder,
20571 T0: ::fidl_next::Encode<
20572 ::fidl_next::wire::Vector<
20573 'static,
20574 ::fidl_next::wire::fuchsia::OptionalNullableHandle,
20575 >,
20576 ___E,
20577 >,
20578 {
20579 #[inline]
20580 fn encode(
20581 self,
20582 encoder_: &mut ___E,
20583 out_: &mut ::core::mem::MaybeUninit<crate::wire::VectorOfOptionalHandles<'static>>,
20584 _: (),
20585 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20586 ::fidl_next::munge! {
20587 let crate::wire::VectorOfOptionalHandles {
20588 v,
20589
20590 } = out_;
20591 }
20592
20593 ::fidl_next::Encode::encode(self.v, encoder_, v, (4294967295, ()))?;
20594
20595 Ok(())
20596 }
20597 }
20598
20599 pub struct VectorOfUpTo2Handles<T0> {
20601 pub v: T0,
20602 }
20603
20604 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::VectorOfUpTo2Handles<'static>, ___E>
20605 for VectorOfUpTo2Handles<T0>
20606 where
20607 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
20608 ___E: ::fidl_next::Encoder,
20609 ___E: ::fidl_next::fuchsia::HandleEncoder,
20610 T0: ::fidl_next::Encode<
20611 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::fuchsia::NullableHandle>,
20612 ___E,
20613 >,
20614 {
20615 #[inline]
20616 fn encode(
20617 self,
20618 encoder_: &mut ___E,
20619 out_: &mut ::core::mem::MaybeUninit<crate::wire::VectorOfUpTo2Handles<'static>>,
20620 _: (),
20621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
20622 ::fidl_next::munge! {
20623 let crate::wire::VectorOfUpTo2Handles {
20624 v,
20625
20626 } = out_;
20627 }
20628
20629 ::fidl_next::Encode::encode(self.v, encoder_, v, (2, ()))?;
20630
20631 Ok(())
20632 }
20633 }
20634}
20635
20636pub use self::natural::*;
20637
20638pub use fidl_next_common_test_conformance::*;