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 pub struct ArgumentsGetStringResponse<T0> {
3717 pub value: T0,
3718 }
3719
3720 unsafe impl<___E, T0>
3721 ::fidl_next::Encode<crate::wire::ArgumentsGetStringResponse<'static>, ___E>
3722 for ArgumentsGetStringResponse<T0>
3723 where
3724 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3725 ___E: ::fidl_next::Encoder,
3726 T0: ::fidl_next::Encode<::fidl_next::wire::OptionalString<'static>, ___E>,
3727 {
3728 #[inline]
3729 fn encode(
3730 self,
3731 encoder_: &mut ___E,
3732 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetStringResponse<'static>>,
3733 _: (),
3734 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3735 ::fidl_next::munge! {
3736 let crate::wire::ArgumentsGetStringResponse {
3737 value,
3738
3739 } = out_;
3740 }
3741
3742 ::fidl_next::Encode::encode(self.value, encoder_, value, 128)?;
3743
3744 Ok(())
3745 }
3746 }
3747
3748 pub struct ArgumentsGetStringsRequest<T0> {
3750 pub keys: T0,
3751 }
3752
3753 unsafe impl<___E, T0>
3754 ::fidl_next::Encode<crate::wire::ArgumentsGetStringsRequest<'static>, ___E>
3755 for ArgumentsGetStringsRequest<T0>
3756 where
3757 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3758 ___E: ::fidl_next::Encoder,
3759 T0: ::fidl_next::Encode<
3760 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
3761 ___E,
3762 >,
3763 {
3764 #[inline]
3765 fn encode(
3766 self,
3767 encoder_: &mut ___E,
3768 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetStringsRequest<'static>>,
3769 _: (),
3770 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3771 ::fidl_next::munge! {
3772 let crate::wire::ArgumentsGetStringsRequest {
3773 keys,
3774
3775 } = out_;
3776 }
3777
3778 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (255, 64))?;
3779
3780 Ok(())
3781 }
3782 }
3783
3784 pub struct ArgumentsGetStringsResponse<T0> {
3786 pub values: T0,
3787 }
3788
3789 unsafe impl<___E, T0>
3790 ::fidl_next::Encode<crate::wire::ArgumentsGetStringsResponse<'static>, ___E>
3791 for ArgumentsGetStringsResponse<T0>
3792 where
3793 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3794 ___E: ::fidl_next::Encoder,
3795 T0: ::fidl_next::Encode<
3796 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::OptionalString<'static>>,
3797 ___E,
3798 >,
3799 {
3800 #[inline]
3801 fn encode(
3802 self,
3803 encoder_: &mut ___E,
3804 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetStringsResponse<'static>>,
3805 _: (),
3806 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3807 ::fidl_next::munge! {
3808 let crate::wire::ArgumentsGetStringsResponse {
3809 values,
3810
3811 } = out_;
3812 }
3813
3814 ::fidl_next::Encode::encode(self.values, encoder_, values, (255, 128))?;
3815
3816 Ok(())
3817 }
3818 }
3819
3820 pub struct ArgumentsGetBoolRequest<T0, T1> {
3822 pub key: T0,
3823
3824 pub defaultval: T1,
3825 }
3826
3827 unsafe impl<___E, T0, T1>
3828 ::fidl_next::Encode<crate::wire::ArgumentsGetBoolRequest<'static>, ___E>
3829 for ArgumentsGetBoolRequest<T0, T1>
3830 where
3831 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3832 ___E: ::fidl_next::Encoder,
3833 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
3834 T1: ::fidl_next::Encode<bool, ___E>,
3835 {
3836 #[inline]
3837 fn encode(
3838 self,
3839 encoder_: &mut ___E,
3840 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetBoolRequest<'static>>,
3841 _: (),
3842 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3843 ::fidl_next::munge! {
3844 let crate::wire::ArgumentsGetBoolRequest {
3845 key,
3846 defaultval,
3847
3848 } = out_;
3849 }
3850
3851 ::fidl_next::Encode::encode(self.key, encoder_, key, 64)?;
3852
3853 ::fidl_next::Encode::encode(self.defaultval, encoder_, defaultval, ())?;
3854
3855 Ok(())
3856 }
3857 }
3858
3859 pub struct ArgumentsGetBoolResponse<T0> {
3861 pub value: T0,
3862 }
3863
3864 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArgumentsGetBoolResponse, ___E>
3865 for ArgumentsGetBoolResponse<T0>
3866 where
3867 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3868 T0: ::fidl_next::Encode<bool, ___E>,
3869 {
3870 #[inline]
3871 fn encode(
3872 self,
3873 encoder_: &mut ___E,
3874 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetBoolResponse>,
3875 _: (),
3876 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3877 ::fidl_next::munge! {
3878 let crate::wire::ArgumentsGetBoolResponse {
3879 value,
3880
3881 } = out_;
3882 }
3883
3884 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
3885
3886 Ok(())
3887 }
3888 }
3889
3890 pub struct BoolPair<T0, T1> {
3892 pub key: T0,
3893
3894 pub defaultval: T1,
3895 }
3896
3897 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::BoolPair<'static>, ___E>
3898 for BoolPair<T0, T1>
3899 where
3900 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3901 ___E: ::fidl_next::Encoder,
3902 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
3903 T1: ::fidl_next::Encode<bool, ___E>,
3904 {
3905 #[inline]
3906 fn encode(
3907 self,
3908 encoder_: &mut ___E,
3909 out_: &mut ::core::mem::MaybeUninit<crate::wire::BoolPair<'static>>,
3910 _: (),
3911 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3912 ::fidl_next::munge! {
3913 let crate::wire::BoolPair {
3914 key,
3915 defaultval,
3916
3917 } = out_;
3918 }
3919
3920 ::fidl_next::Encode::encode(self.key, encoder_, key, 64)?;
3921
3922 ::fidl_next::Encode::encode(self.defaultval, encoder_, defaultval, ())?;
3923
3924 Ok(())
3925 }
3926 }
3927
3928 pub struct ArgumentsGetBoolsRequest<T0> {
3930 pub keys: T0,
3931 }
3932
3933 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArgumentsGetBoolsRequest<'static>, ___E>
3934 for ArgumentsGetBoolsRequest<T0>
3935 where
3936 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3937 ___E: ::fidl_next::Encoder,
3938 T0: ::fidl_next::Encode<
3939 ::fidl_next::wire::Vector<'static, crate::wire::BoolPair<'static>>,
3940 ___E,
3941 >,
3942 {
3943 #[inline]
3944 fn encode(
3945 self,
3946 encoder_: &mut ___E,
3947 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetBoolsRequest<'static>>,
3948 _: (),
3949 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3950 ::fidl_next::munge! {
3951 let crate::wire::ArgumentsGetBoolsRequest {
3952 keys,
3953
3954 } = out_;
3955 }
3956
3957 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (255, ()))?;
3958
3959 Ok(())
3960 }
3961 }
3962
3963 pub struct ArgumentsGetBoolsResponse<T0> {
3965 pub values: T0,
3966 }
3967
3968 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArgumentsGetBoolsResponse<'static>, ___E>
3969 for ArgumentsGetBoolsResponse<T0>
3970 where
3971 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3972 ___E: ::fidl_next::Encoder,
3973 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, bool>, ___E>,
3974 {
3975 #[inline]
3976 fn encode(
3977 self,
3978 encoder_: &mut ___E,
3979 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsGetBoolsResponse<'static>>,
3980 _: (),
3981 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3982 ::fidl_next::munge! {
3983 let crate::wire::ArgumentsGetBoolsResponse {
3984 values,
3985
3986 } = out_;
3987 }
3988
3989 ::fidl_next::Encode::encode(self.values, encoder_, values, (255, ()))?;
3990
3991 Ok(())
3992 }
3993 }
3994
3995 pub struct ArgumentsCollectRequest<T0> {
3997 pub prefix: T0,
3998 }
3999
4000 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArgumentsCollectRequest<'static>, ___E>
4001 for ArgumentsCollectRequest<T0>
4002 where
4003 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4004 ___E: ::fidl_next::Encoder,
4005 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4006 {
4007 #[inline]
4008 fn encode(
4009 self,
4010 encoder_: &mut ___E,
4011 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsCollectRequest<'static>>,
4012 _: (),
4013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4014 ::fidl_next::munge! {
4015 let crate::wire::ArgumentsCollectRequest {
4016 prefix,
4017
4018 } = out_;
4019 }
4020
4021 ::fidl_next::Encode::encode(self.prefix, encoder_, prefix, 64)?;
4022
4023 Ok(())
4024 }
4025 }
4026
4027 pub struct ArgumentsCollectResponse<T0> {
4029 pub results: T0,
4030 }
4031
4032 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ArgumentsCollectResponse<'static>, ___E>
4033 for ArgumentsCollectResponse<T0>
4034 where
4035 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4036 ___E: ::fidl_next::Encoder,
4037 T0: ::fidl_next::Encode<
4038 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
4039 ___E,
4040 >,
4041 {
4042 #[inline]
4043 fn encode(
4044 self,
4045 encoder_: &mut ___E,
4046 out_: &mut ::core::mem::MaybeUninit<crate::wire::ArgumentsCollectResponse<'static>>,
4047 _: (),
4048 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4049 ::fidl_next::munge! {
4050 let crate::wire::ArgumentsCollectResponse {
4051 results,
4052
4053 } = out_;
4054 }
4055
4056 ::fidl_next::Encode::encode(self.results, encoder_, results, (255, 193))?;
4057
4058 Ok(())
4059 }
4060 }
4061
4062 pub struct Extra<T0> {
4064 pub n: T0,
4065 }
4066
4067 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::Extra, ___E> for Extra<T0>
4068 where
4069 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4070 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
4071 {
4072 #[inline]
4073 fn encode(
4074 self,
4075 encoder_: &mut ___E,
4076 out_: &mut ::core::mem::MaybeUninit<crate::wire::Extra>,
4077 _: (),
4078 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4079 ::fidl_next::munge! {
4080 let crate::wire::Extra {
4081 n,
4082
4083 } = out_;
4084 }
4085
4086 ::fidl_next::Encode::encode(self.n, encoder_, n, ())?;
4087
4088 Ok(())
4089 }
4090 }
4091
4092 pub struct FactoryItemsGetRequest<T0> {
4094 pub extra: T0,
4095 }
4096
4097 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FactoryItemsGetRequest, ___E>
4098 for FactoryItemsGetRequest<T0>
4099 where
4100 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4101 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
4102 {
4103 #[inline]
4104 fn encode(
4105 self,
4106 encoder_: &mut ___E,
4107 out_: &mut ::core::mem::MaybeUninit<crate::wire::FactoryItemsGetRequest>,
4108 _: (),
4109 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4110 ::fidl_next::munge! {
4111 let crate::wire::FactoryItemsGetRequest {
4112 extra,
4113
4114 } = out_;
4115 }
4116
4117 ::fidl_next::Encode::encode(self.extra, encoder_, extra, ())?;
4118
4119 Ok(())
4120 }
4121 }
4122
4123 pub struct ItemsGetRequest<T0, T1> {
4125 pub type_: T0,
4126
4127 pub extra: T1,
4128 }
4129
4130 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ItemsGetRequest, ___E>
4131 for ItemsGetRequest<T0, T1>
4132 where
4133 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4134 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
4135 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
4136 {
4137 #[inline]
4138 fn encode(
4139 self,
4140 encoder_: &mut ___E,
4141 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGetRequest>,
4142 _: (),
4143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4144 ::fidl_next::munge! {
4145 let crate::wire::ItemsGetRequest {
4146 type_,
4147 extra,
4148
4149 } = out_;
4150 }
4151
4152 ::fidl_next::Encode::encode(self.type_, encoder_, type_, ())?;
4153
4154 ::fidl_next::Encode::encode(self.extra, encoder_, extra, ())?;
4155
4156 Ok(())
4157 }
4158 }
4159
4160 pub struct ItemsGet2Request<T0, T1> {
4162 pub type_: T0,
4163
4164 pub extra: T1,
4165 }
4166
4167 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ItemsGet2Request<'static>, ___E>
4168 for ItemsGet2Request<T0, T1>
4169 where
4170 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4171 ___E: ::fidl_next::Encoder,
4172 T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
4173 T1: ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::Extra>, ___E>,
4174 {
4175 #[inline]
4176 fn encode(
4177 self,
4178 encoder_: &mut ___E,
4179 out_: &mut ::core::mem::MaybeUninit<crate::wire::ItemsGet2Request<'static>>,
4180 _: (),
4181 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4182 ::fidl_next::munge! {
4183 let crate::wire::ItemsGet2Request {
4184 type_,
4185 extra,
4186
4187 } = out_;
4188 }
4189
4190 ::fidl_next::Encode::encode(self.type_, encoder_, type_, ())?;
4191
4192 ::fidl_next::Encode::encode(self.extra, encoder_, extra, ())?;
4193
4194 Ok(())
4195 }
4196 }
4197
4198 pub struct ItemsGetBootloaderFileRequest<T0> {
4200 pub filename: T0,
4201 }
4202
4203 unsafe impl<___E, T0>
4204 ::fidl_next::Encode<crate::wire::ItemsGetBootloaderFileRequest<'static>, ___E>
4205 for ItemsGetBootloaderFileRequest<T0>
4206 where
4207 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4208 ___E: ::fidl_next::Encoder,
4209 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4210 {
4211 #[inline]
4212 fn encode(
4213 self,
4214 encoder_: &mut ___E,
4215 out_: &mut ::core::mem::MaybeUninit<
4216 crate::wire::ItemsGetBootloaderFileRequest<'static>,
4217 >,
4218 _: (),
4219 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4220 ::fidl_next::munge! {
4221 let crate::wire::ItemsGetBootloaderFileRequest {
4222 filename,
4223
4224 } = out_;
4225 }
4226
4227 ::fidl_next::Encode::encode(self.filename, encoder_, filename, 255)?;
4228
4229 Ok(())
4230 }
4231 }
4232}
4233
4234pub use self::natural::*;
4235
4236pub const MAX_ARGS_NAME_LENGTH: u8 = 64 as u8;
4237
4238pub const MAX_ARGS_VALUE_LENGTH: u8 = 128 as u8;
4239
4240pub const MAX_ARGS_VECTOR_LENGTH: u8 = 255 as u8;
4241
4242pub const MAX_ARGS_COLLECT_LENGTH: u8 = 193 as u8;
4243
4244#[doc = " Protocol for retrieving boot arguments.\n"]
4246#[derive(PartialEq, Debug)]
4247pub struct Arguments;
4248
4249impl ::fidl_next::Discoverable for Arguments {
4250 const PROTOCOL_NAME: &'static str = "fuchsia.boot.Arguments";
4251}
4252
4253#[cfg(target_os = "fuchsia")]
4254impl ::fidl_next::HasTransport for Arguments {
4255 type Transport = ::fidl_next::fuchsia::zx::Channel;
4256}
4257
4258pub mod arguments {
4259 pub mod prelude {
4260 pub use crate::{
4261 Arguments, ArgumentsClientHandler, ArgumentsLocalClientHandler,
4262 ArgumentsLocalServerHandler, ArgumentsServerHandler, arguments,
4263 };
4264
4265 pub use crate::natural::ArgumentsCollectRequest;
4266
4267 pub use crate::natural::ArgumentsCollectResponse;
4268
4269 pub use crate::natural::ArgumentsGetBoolRequest;
4270
4271 pub use crate::natural::ArgumentsGetBoolResponse;
4272
4273 pub use crate::natural::ArgumentsGetBoolsRequest;
4274
4275 pub use crate::natural::ArgumentsGetBoolsResponse;
4276
4277 pub use crate::natural::ArgumentsGetStringRequest;
4278
4279 pub use crate::natural::ArgumentsGetStringResponse;
4280
4281 pub use crate::natural::ArgumentsGetStringsRequest;
4282
4283 pub use crate::natural::ArgumentsGetStringsResponse;
4284 }
4285
4286 pub struct GetString;
4287
4288 impl ::fidl_next::Method for GetString {
4289 const ORDINAL: u64 = 299137698355411198;
4290 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4291 ::fidl_next::protocol::Flexibility::Strict;
4292
4293 type Protocol = crate::Arguments;
4294
4295 type Request = crate::wire::ArgumentsGetStringRequest<'static>;
4296 }
4297
4298 impl ::fidl_next::TwoWayMethod for GetString {
4299 type Response = ::fidl_next::wire::Strict<crate::wire::ArgumentsGetStringResponse<'static>>;
4300 }
4301
4302 impl<___R> ::fidl_next::Respond<___R> for GetString {
4303 type Output = ::fidl_next::Strict<crate::generic::ArgumentsGetStringResponse<___R>>;
4304
4305 fn respond(response: ___R) -> Self::Output {
4306 ::fidl_next::Strict(crate::generic::ArgumentsGetStringResponse { value: response })
4307 }
4308 }
4309
4310 pub struct GetStrings;
4311
4312 impl ::fidl_next::Method for GetStrings {
4313 const ORDINAL: u64 = 3643331513240164087;
4314 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4315 ::fidl_next::protocol::Flexibility::Strict;
4316
4317 type Protocol = crate::Arguments;
4318
4319 type Request = crate::wire::ArgumentsGetStringsRequest<'static>;
4320 }
4321
4322 impl ::fidl_next::TwoWayMethod for GetStrings {
4323 type Response =
4324 ::fidl_next::wire::Strict<crate::wire::ArgumentsGetStringsResponse<'static>>;
4325 }
4326
4327 impl<___R> ::fidl_next::Respond<___R> for GetStrings {
4328 type Output = ::fidl_next::Strict<crate::generic::ArgumentsGetStringsResponse<___R>>;
4329
4330 fn respond(response: ___R) -> Self::Output {
4331 ::fidl_next::Strict(crate::generic::ArgumentsGetStringsResponse { values: response })
4332 }
4333 }
4334
4335 pub struct GetBool;
4336
4337 impl ::fidl_next::Method for GetBool {
4338 const ORDINAL: u64 = 5502786405120986317;
4339 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4340 ::fidl_next::protocol::Flexibility::Strict;
4341
4342 type Protocol = crate::Arguments;
4343
4344 type Request = crate::wire::ArgumentsGetBoolRequest<'static>;
4345 }
4346
4347 impl ::fidl_next::TwoWayMethod for GetBool {
4348 type Response = ::fidl_next::wire::Strict<crate::wire::ArgumentsGetBoolResponse>;
4349 }
4350
4351 impl<___R> ::fidl_next::Respond<___R> for GetBool {
4352 type Output = ::fidl_next::Strict<crate::generic::ArgumentsGetBoolResponse<___R>>;
4353
4354 fn respond(response: ___R) -> Self::Output {
4355 ::fidl_next::Strict(crate::generic::ArgumentsGetBoolResponse { value: response })
4356 }
4357 }
4358
4359 pub struct GetBools;
4360
4361 impl ::fidl_next::Method for GetBools {
4362 const ORDINAL: u64 = 1138460494155359765;
4363 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4364 ::fidl_next::protocol::Flexibility::Strict;
4365
4366 type Protocol = crate::Arguments;
4367
4368 type Request = crate::wire::ArgumentsGetBoolsRequest<'static>;
4369 }
4370
4371 impl ::fidl_next::TwoWayMethod for GetBools {
4372 type Response = ::fidl_next::wire::Strict<crate::wire::ArgumentsGetBoolsResponse<'static>>;
4373 }
4374
4375 impl<___R> ::fidl_next::Respond<___R> for GetBools {
4376 type Output = ::fidl_next::Strict<crate::generic::ArgumentsGetBoolsResponse<___R>>;
4377
4378 fn respond(response: ___R) -> Self::Output {
4379 ::fidl_next::Strict(crate::generic::ArgumentsGetBoolsResponse { values: response })
4380 }
4381 }
4382
4383 pub struct Collect;
4384
4385 impl ::fidl_next::Method for Collect {
4386 const ORDINAL: u64 = 2658721200428314160;
4387 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
4388 ::fidl_next::protocol::Flexibility::Strict;
4389
4390 type Protocol = crate::Arguments;
4391
4392 type Request = crate::wire::ArgumentsCollectRequest<'static>;
4393 }
4394
4395 impl ::fidl_next::TwoWayMethod for Collect {
4396 type Response = ::fidl_next::wire::Strict<crate::wire::ArgumentsCollectResponse<'static>>;
4397 }
4398
4399 impl<___R> ::fidl_next::Respond<___R> for Collect {
4400 type Output = ::fidl_next::Strict<crate::generic::ArgumentsCollectResponse<___R>>;
4401
4402 fn respond(response: ___R) -> Self::Output {
4403 ::fidl_next::Strict(crate::generic::ArgumentsCollectResponse { results: response })
4404 }
4405 }
4406
4407 mod ___detail {
4408 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Arguments
4409 where
4410 ___T: ::fidl_next::Transport,
4411 {
4412 type Client = ArgumentsClient<___T>;
4413 type Server = ArgumentsServer<___T>;
4414 }
4415
4416 #[repr(transparent)]
4418 pub struct ArgumentsClient<___T: ::fidl_next::Transport> {
4419 #[allow(dead_code)]
4420 client: ::fidl_next::protocol::Client<___T>,
4421 }
4422
4423 impl<___T> ArgumentsClient<___T>
4424 where
4425 ___T: ::fidl_next::Transport,
4426 {
4427 #[doc = " Get the value of a boot argument `key`.\n"]
4428 pub fn get_string(
4429 &self,
4430
4431 key: impl ::fidl_next::Encode<
4432 ::fidl_next::wire::String<'static>,
4433 <___T as ::fidl_next::Transport>::SendBuffer,
4434 >,
4435 ) -> ::fidl_next::TwoWayFuture<'_, super::GetString, ___T>
4436 where
4437 <___T as ::fidl_next::Transport>::SendBuffer:
4438 ::fidl_next::encoder::InternalHandleEncoder,
4439 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4440 {
4441 self.get_string_with(crate::generic::ArgumentsGetStringRequest { key })
4442 }
4443
4444 #[doc = " Get the value of a boot argument `key`.\n"]
4445 pub fn get_string_with<___R>(
4446 &self,
4447 request: ___R,
4448 ) -> ::fidl_next::TwoWayFuture<'_, super::GetString, ___T>
4449 where
4450 ___R: ::fidl_next::Encode<
4451 crate::wire::ArgumentsGetStringRequest<'static>,
4452 <___T as ::fidl_next::Transport>::SendBuffer,
4453 >,
4454 {
4455 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4456 299137698355411198,
4457 <super::GetString as ::fidl_next::Method>::FLEXIBILITY,
4458 request,
4459 ))
4460 }
4461
4462 #[doc = " Get the values of a list of arguments specified in `keys`.\n"]
4463 pub fn get_strings(
4464 &self,
4465
4466 keys: impl ::fidl_next::Encode<
4467 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
4468 <___T as ::fidl_next::Transport>::SendBuffer,
4469 >,
4470 ) -> ::fidl_next::TwoWayFuture<'_, super::GetStrings, ___T>
4471 where
4472 <___T as ::fidl_next::Transport>::SendBuffer:
4473 ::fidl_next::encoder::InternalHandleEncoder,
4474 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4475 {
4476 self.get_strings_with(crate::generic::ArgumentsGetStringsRequest { keys })
4477 }
4478
4479 #[doc = " Get the values of a list of arguments specified in `keys`.\n"]
4480 pub fn get_strings_with<___R>(
4481 &self,
4482 request: ___R,
4483 ) -> ::fidl_next::TwoWayFuture<'_, super::GetStrings, ___T>
4484 where
4485 ___R: ::fidl_next::Encode<
4486 crate::wire::ArgumentsGetStringsRequest<'static>,
4487 <___T as ::fidl_next::Transport>::SendBuffer,
4488 >,
4489 {
4490 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4491 3643331513240164087,
4492 <super::GetStrings as ::fidl_next::Method>::FLEXIBILITY,
4493 request,
4494 ))
4495 }
4496
4497 #[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"]
4498 pub fn get_bool(
4499 &self,
4500
4501 key: impl ::fidl_next::Encode<
4502 ::fidl_next::wire::String<'static>,
4503 <___T as ::fidl_next::Transport>::SendBuffer,
4504 >,
4505
4506 defaultval: impl ::fidl_next::Encode<bool, <___T as ::fidl_next::Transport>::SendBuffer>,
4507 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBool, ___T>
4508 where
4509 <___T as ::fidl_next::Transport>::SendBuffer:
4510 ::fidl_next::encoder::InternalHandleEncoder,
4511 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4512 {
4513 self.get_bool_with(crate::generic::ArgumentsGetBoolRequest { key, defaultval })
4514 }
4515
4516 #[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"]
4517 pub fn get_bool_with<___R>(
4518 &self,
4519 request: ___R,
4520 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBool, ___T>
4521 where
4522 ___R: ::fidl_next::Encode<
4523 crate::wire::ArgumentsGetBoolRequest<'static>,
4524 <___T as ::fidl_next::Transport>::SendBuffer,
4525 >,
4526 {
4527 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4528 5502786405120986317,
4529 <super::GetBool as ::fidl_next::Method>::FLEXIBILITY,
4530 request,
4531 ))
4532 }
4533
4534 #[doc = " Get the boolean values of a list of boot arguments `keys.key`,\n or return `keys.defaultval` for each if not present.\n"]
4535 pub fn get_bools(
4536 &self,
4537
4538 keys: impl ::fidl_next::Encode<
4539 ::fidl_next::wire::Vector<'static, crate::wire::BoolPair<'static>>,
4540 <___T as ::fidl_next::Transport>::SendBuffer,
4541 >,
4542 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBools, ___T>
4543 where
4544 <___T as ::fidl_next::Transport>::SendBuffer:
4545 ::fidl_next::encoder::InternalHandleEncoder,
4546 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4547 {
4548 self.get_bools_with(crate::generic::ArgumentsGetBoolsRequest { keys })
4549 }
4550
4551 #[doc = " Get the boolean values of a list of boot arguments `keys.key`,\n or return `keys.defaultval` for each if not present.\n"]
4552 pub fn get_bools_with<___R>(
4553 &self,
4554 request: ___R,
4555 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBools, ___T>
4556 where
4557 ___R: ::fidl_next::Encode<
4558 crate::wire::ArgumentsGetBoolsRequest<'static>,
4559 <___T as ::fidl_next::Transport>::SendBuffer,
4560 >,
4561 {
4562 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4563 1138460494155359765,
4564 <super::GetBools as ::fidl_next::Method>::FLEXIBILITY,
4565 request,
4566 ))
4567 }
4568
4569 #[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"]
4570 pub fn collect(
4571 &self,
4572
4573 prefix: impl ::fidl_next::Encode<
4574 ::fidl_next::wire::String<'static>,
4575 <___T as ::fidl_next::Transport>::SendBuffer,
4576 >,
4577 ) -> ::fidl_next::TwoWayFuture<'_, super::Collect, ___T>
4578 where
4579 <___T as ::fidl_next::Transport>::SendBuffer:
4580 ::fidl_next::encoder::InternalHandleEncoder,
4581 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
4582 {
4583 self.collect_with(crate::generic::ArgumentsCollectRequest { prefix })
4584 }
4585
4586 #[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"]
4587 pub fn collect_with<___R>(
4588 &self,
4589 request: ___R,
4590 ) -> ::fidl_next::TwoWayFuture<'_, super::Collect, ___T>
4591 where
4592 ___R: ::fidl_next::Encode<
4593 crate::wire::ArgumentsCollectRequest<'static>,
4594 <___T as ::fidl_next::Transport>::SendBuffer,
4595 >,
4596 {
4597 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
4598 2658721200428314160,
4599 <super::Collect as ::fidl_next::Method>::FLEXIBILITY,
4600 request,
4601 ))
4602 }
4603 }
4604
4605 #[repr(transparent)]
4607 pub struct ArgumentsServer<___T: ::fidl_next::Transport> {
4608 server: ::fidl_next::protocol::Server<___T>,
4609 }
4610
4611 impl<___T> ArgumentsServer<___T> where ___T: ::fidl_next::Transport {}
4612 }
4613}
4614
4615#[diagnostic::on_unimplemented(
4616 note = "If {Self} implements the non-local ArgumentsClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4617)]
4618
4619pub trait ArgumentsLocalClientHandler<
4623 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4624 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4625>
4626{
4627}
4628
4629impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Arguments
4630where
4631 ___H: ArgumentsLocalClientHandler<___T>,
4632 ___T: ::fidl_next::Transport,
4633{
4634 async fn on_event(
4635 handler: &mut ___H,
4636 mut message: ::fidl_next::Message<___T>,
4637 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4638 match *message.header().ordinal {
4639 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4640 }
4641 }
4642}
4643
4644#[diagnostic::on_unimplemented(
4645 note = "If {Self} implements the non-local ArgumentsServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
4646)]
4647
4648pub trait ArgumentsLocalServerHandler<
4652 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4653 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4654>
4655{
4656 #[doc = " Get the value of a boot argument `key`.\n"]
4657 fn get_string(
4658 &mut self,
4659
4660 request: ::fidl_next::Request<arguments::GetString, ___T>,
4661
4662 responder: ::fidl_next::Responder<arguments::GetString, ___T>,
4663 ) -> impl ::core::future::Future<Output = ()>;
4664
4665 #[doc = " Get the values of a list of arguments specified in `keys`.\n"]
4666 fn get_strings(
4667 &mut self,
4668
4669 request: ::fidl_next::Request<arguments::GetStrings, ___T>,
4670
4671 responder: ::fidl_next::Responder<arguments::GetStrings, ___T>,
4672 ) -> impl ::core::future::Future<Output = ()>;
4673
4674 #[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"]
4675 fn get_bool(
4676 &mut self,
4677
4678 request: ::fidl_next::Request<arguments::GetBool, ___T>,
4679
4680 responder: ::fidl_next::Responder<arguments::GetBool, ___T>,
4681 ) -> impl ::core::future::Future<Output = ()>;
4682
4683 #[doc = " Get the boolean values of a list of boot arguments `keys.key`,\n or return `keys.defaultval` for each if not present.\n"]
4684 fn get_bools(
4685 &mut self,
4686
4687 request: ::fidl_next::Request<arguments::GetBools, ___T>,
4688
4689 responder: ::fidl_next::Responder<arguments::GetBools, ___T>,
4690 ) -> impl ::core::future::Future<Output = ()>;
4691
4692 #[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"]
4693 fn collect(
4694 &mut self,
4695
4696 request: ::fidl_next::Request<arguments::Collect, ___T>,
4697
4698 responder: ::fidl_next::Responder<arguments::Collect, ___T>,
4699 ) -> impl ::core::future::Future<Output = ()>;
4700}
4701
4702impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Arguments
4703where
4704 ___H: ArgumentsLocalServerHandler<___T>,
4705 ___T: ::fidl_next::Transport,
4706 for<'de> crate::wire::ArgumentsGetStringRequest<'de>: ::fidl_next::Decode<
4707 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4708 Constraint = (),
4709 >,
4710 for<'de> crate::wire::ArgumentsGetStringsRequest<'de>: ::fidl_next::Decode<
4711 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4712 Constraint = (),
4713 >,
4714 for<'de> crate::wire::ArgumentsGetBoolRequest<'de>: ::fidl_next::Decode<
4715 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4716 Constraint = (),
4717 >,
4718 for<'de> crate::wire::ArgumentsGetBoolsRequest<'de>: ::fidl_next::Decode<
4719 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4720 Constraint = (),
4721 >,
4722 for<'de> crate::wire::ArgumentsCollectRequest<'de>: ::fidl_next::Decode<
4723 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4724 Constraint = (),
4725 >,
4726{
4727 async fn on_one_way(
4728 handler: &mut ___H,
4729 mut message: ::fidl_next::Message<___T>,
4730 ) -> ::core::result::Result<
4731 (),
4732 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4733 > {
4734 match *message.header().ordinal {
4735 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4736 }
4737 }
4738
4739 async fn on_two_way(
4740 handler: &mut ___H,
4741 mut message: ::fidl_next::Message<___T>,
4742 responder: ::fidl_next::protocol::Responder<___T>,
4743 ) -> ::core::result::Result<
4744 (),
4745 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4746 > {
4747 match *message.header().ordinal {
4748 299137698355411198 => {
4749 let responder = ::fidl_next::Responder::from_untyped(responder);
4750
4751 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4752 Ok(decoded) => {
4753 handler
4754 .get_string(::fidl_next::Request::from_decoded(decoded), responder)
4755 .await;
4756 Ok(())
4757 }
4758 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4759 ordinal: 299137698355411198,
4760 error,
4761 }),
4762 }
4763 }
4764
4765 3643331513240164087 => {
4766 let responder = ::fidl_next::Responder::from_untyped(responder);
4767
4768 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4769 Ok(decoded) => {
4770 handler
4771 .get_strings(::fidl_next::Request::from_decoded(decoded), responder)
4772 .await;
4773 Ok(())
4774 }
4775 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4776 ordinal: 3643331513240164087,
4777 error,
4778 }),
4779 }
4780 }
4781
4782 5502786405120986317 => {
4783 let responder = ::fidl_next::Responder::from_untyped(responder);
4784
4785 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4786 Ok(decoded) => {
4787 handler
4788 .get_bool(::fidl_next::Request::from_decoded(decoded), responder)
4789 .await;
4790 Ok(())
4791 }
4792 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4793 ordinal: 5502786405120986317,
4794 error,
4795 }),
4796 }
4797 }
4798
4799 1138460494155359765 => {
4800 let responder = ::fidl_next::Responder::from_untyped(responder);
4801
4802 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4803 Ok(decoded) => {
4804 handler
4805 .get_bools(::fidl_next::Request::from_decoded(decoded), responder)
4806 .await;
4807 Ok(())
4808 }
4809 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4810 ordinal: 1138460494155359765,
4811 error,
4812 }),
4813 }
4814 }
4815
4816 2658721200428314160 => {
4817 let responder = ::fidl_next::Responder::from_untyped(responder);
4818
4819 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4820 Ok(decoded) => {
4821 handler
4822 .collect(::fidl_next::Request::from_decoded(decoded), responder)
4823 .await;
4824 Ok(())
4825 }
4826 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4827 ordinal: 2658721200428314160,
4828 error,
4829 }),
4830 }
4831 }
4832
4833 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4834 }
4835 }
4836}
4837
4838pub trait ArgumentsClientHandler<
4842 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4843 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4844>
4845{
4846}
4847
4848impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Arguments
4849where
4850 ___H: ArgumentsClientHandler<___T> + ::core::marker::Send,
4851 ___T: ::fidl_next::Transport,
4852{
4853 async fn on_event(
4854 handler: &mut ___H,
4855 mut message: ::fidl_next::Message<___T>,
4856 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4857 match *message.header().ordinal {
4858 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4859 }
4860 }
4861}
4862
4863pub trait ArgumentsServerHandler<
4867 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4868 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4869>
4870{
4871 #[doc = " Get the value of a boot argument `key`.\n"]
4872 fn get_string(
4873 &mut self,
4874
4875 request: ::fidl_next::Request<arguments::GetString, ___T>,
4876
4877 responder: ::fidl_next::Responder<arguments::GetString, ___T>,
4878 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4879
4880 #[doc = " Get the values of a list of arguments specified in `keys`.\n"]
4881 fn get_strings(
4882 &mut self,
4883
4884 request: ::fidl_next::Request<arguments::GetStrings, ___T>,
4885
4886 responder: ::fidl_next::Responder<arguments::GetStrings, ___T>,
4887 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4888
4889 #[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"]
4890 fn get_bool(
4891 &mut self,
4892
4893 request: ::fidl_next::Request<arguments::GetBool, ___T>,
4894
4895 responder: ::fidl_next::Responder<arguments::GetBool, ___T>,
4896 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4897
4898 #[doc = " Get the boolean values of a list of boot arguments `keys.key`,\n or return `keys.defaultval` for each if not present.\n"]
4899 fn get_bools(
4900 &mut self,
4901
4902 request: ::fidl_next::Request<arguments::GetBools, ___T>,
4903
4904 responder: ::fidl_next::Responder<arguments::GetBools, ___T>,
4905 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4906
4907 #[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"]
4908 fn collect(
4909 &mut self,
4910
4911 request: ::fidl_next::Request<arguments::Collect, ___T>,
4912
4913 responder: ::fidl_next::Responder<arguments::Collect, ___T>,
4914 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
4915}
4916
4917impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Arguments
4918where
4919 ___H: ArgumentsServerHandler<___T> + ::core::marker::Send,
4920 ___T: ::fidl_next::Transport,
4921 for<'de> crate::wire::ArgumentsGetStringRequest<'de>: ::fidl_next::Decode<
4922 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4923 Constraint = (),
4924 >,
4925 for<'de> crate::wire::ArgumentsGetStringsRequest<'de>: ::fidl_next::Decode<
4926 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4927 Constraint = (),
4928 >,
4929 for<'de> crate::wire::ArgumentsGetBoolRequest<'de>: ::fidl_next::Decode<
4930 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4931 Constraint = (),
4932 >,
4933 for<'de> crate::wire::ArgumentsGetBoolsRequest<'de>: ::fidl_next::Decode<
4934 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4935 Constraint = (),
4936 >,
4937 for<'de> crate::wire::ArgumentsCollectRequest<'de>: ::fidl_next::Decode<
4938 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
4939 Constraint = (),
4940 >,
4941{
4942 async fn on_one_way(
4943 handler: &mut ___H,
4944 mut message: ::fidl_next::Message<___T>,
4945 ) -> ::core::result::Result<
4946 (),
4947 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4948 > {
4949 match *message.header().ordinal {
4950 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4951 }
4952 }
4953
4954 async fn on_two_way(
4955 handler: &mut ___H,
4956 mut message: ::fidl_next::Message<___T>,
4957 responder: ::fidl_next::protocol::Responder<___T>,
4958 ) -> ::core::result::Result<
4959 (),
4960 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4961 > {
4962 match *message.header().ordinal {
4963 299137698355411198 => {
4964 let responder = ::fidl_next::Responder::from_untyped(responder);
4965
4966 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4967 Ok(decoded) => {
4968 handler
4969 .get_string(::fidl_next::Request::from_decoded(decoded), responder)
4970 .await;
4971 Ok(())
4972 }
4973 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4974 ordinal: 299137698355411198,
4975 error,
4976 }),
4977 }
4978 }
4979
4980 3643331513240164087 => {
4981 let responder = ::fidl_next::Responder::from_untyped(responder);
4982
4983 match ::fidl_next::AsDecoderExt::into_decoded(message) {
4984 Ok(decoded) => {
4985 handler
4986 .get_strings(::fidl_next::Request::from_decoded(decoded), responder)
4987 .await;
4988 Ok(())
4989 }
4990 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
4991 ordinal: 3643331513240164087,
4992 error,
4993 }),
4994 }
4995 }
4996
4997 5502786405120986317 => {
4998 let responder = ::fidl_next::Responder::from_untyped(responder);
4999
5000 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5001 Ok(decoded) => {
5002 handler
5003 .get_bool(::fidl_next::Request::from_decoded(decoded), responder)
5004 .await;
5005 Ok(())
5006 }
5007 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5008 ordinal: 5502786405120986317,
5009 error,
5010 }),
5011 }
5012 }
5013
5014 1138460494155359765 => {
5015 let responder = ::fidl_next::Responder::from_untyped(responder);
5016
5017 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5018 Ok(decoded) => {
5019 handler
5020 .get_bools(::fidl_next::Request::from_decoded(decoded), responder)
5021 .await;
5022 Ok(())
5023 }
5024 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5025 ordinal: 1138460494155359765,
5026 error,
5027 }),
5028 }
5029 }
5030
5031 2658721200428314160 => {
5032 let responder = ::fidl_next::Responder::from_untyped(responder);
5033
5034 match ::fidl_next::AsDecoderExt::into_decoded(message) {
5035 Ok(decoded) => {
5036 handler
5037 .collect(::fidl_next::Request::from_decoded(decoded), responder)
5038 .await;
5039 Ok(())
5040 }
5041 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5042 ordinal: 2658721200428314160,
5043 error,
5044 }),
5045 }
5046 }
5047
5048 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5049 }
5050 }
5051}
5052
5053impl<___T> ArgumentsClientHandler<___T> for ::fidl_next::IgnoreEvents where
5054 ___T: ::fidl_next::Transport
5055{
5056}
5057
5058impl<___H, ___T> ArgumentsLocalClientHandler<___T> for ::fidl_next::Local<___H>
5059where
5060 ___H: ArgumentsClientHandler<___T>,
5061 ___T: ::fidl_next::Transport,
5062{
5063}
5064
5065impl<___H, ___T> ArgumentsLocalServerHandler<___T> for ::fidl_next::Local<___H>
5066where
5067 ___H: ArgumentsServerHandler<___T>,
5068 ___T: ::fidl_next::Transport,
5069{
5070 async fn get_string(
5071 &mut self,
5072
5073 request: ::fidl_next::Request<arguments::GetString, ___T>,
5074
5075 responder: ::fidl_next::Responder<arguments::GetString, ___T>,
5076 ) {
5077 ___H::get_string(&mut self.0, request, responder).await
5078 }
5079
5080 async fn get_strings(
5081 &mut self,
5082
5083 request: ::fidl_next::Request<arguments::GetStrings, ___T>,
5084
5085 responder: ::fidl_next::Responder<arguments::GetStrings, ___T>,
5086 ) {
5087 ___H::get_strings(&mut self.0, request, responder).await
5088 }
5089
5090 async fn get_bool(
5091 &mut self,
5092
5093 request: ::fidl_next::Request<arguments::GetBool, ___T>,
5094
5095 responder: ::fidl_next::Responder<arguments::GetBool, ___T>,
5096 ) {
5097 ___H::get_bool(&mut self.0, request, responder).await
5098 }
5099
5100 async fn get_bools(
5101 &mut self,
5102
5103 request: ::fidl_next::Request<arguments::GetBools, ___T>,
5104
5105 responder: ::fidl_next::Responder<arguments::GetBools, ___T>,
5106 ) {
5107 ___H::get_bools(&mut self.0, request, responder).await
5108 }
5109
5110 async fn collect(
5111 &mut self,
5112
5113 request: ::fidl_next::Request<arguments::Collect, ___T>,
5114
5115 responder: ::fidl_next::Responder<arguments::Collect, ___T>,
5116 ) {
5117 ___H::collect(&mut self.0, request, responder).await
5118 }
5119}
5120
5121pub const MAX_FILE_NAME_LENGTH: u8 = 255 as u8;