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