1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[derive(PartialEq, Clone, Debug)]
8 #[repr(C)]
9 pub struct CalculatorAddRequest {
10 pub a: i32,
11
12 pub b: i32,
13 }
14
15 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CalculatorAddRequest, ___E>
16 for CalculatorAddRequest
17 where
18 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19 {
20 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
21 Self,
22 crate::wire::CalculatorAddRequest,
23 > = unsafe {
24 ::fidl_next::CopyOptimization::enable_if(
25 true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
26 .is_enabled()
27 && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
28 .is_enabled(),
29 )
30 };
31
32 #[inline]
33 fn encode(
34 self,
35 encoder_: &mut ___E,
36 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorAddRequest>,
37 _: (),
38 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
39 ::fidl_next::munge! {
40 let crate::wire::CalculatorAddRequest {
41 a,
42 b,
43
44 } = out_;
45 }
46
47 ::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
48
49 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
50
51 ::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
52
53 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
54
55 Ok(())
56 }
57 }
58
59 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CalculatorAddRequest, ___E>
60 for &'a CalculatorAddRequest
61 where
62 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
63 {
64 #[inline]
65 fn encode(
66 self,
67 encoder_: &mut ___E,
68 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorAddRequest>,
69 _: (),
70 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
71 ::fidl_next::munge! {
72 let crate::wire::CalculatorAddRequest {
73
74 a,
75 b,
76
77 } = out_;
78 }
79
80 ::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
81
82 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
83
84 ::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
85
86 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
87
88 Ok(())
89 }
90 }
91
92 unsafe impl<___E>
93 ::fidl_next::EncodeOption<
94 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddRequest>,
95 ___E,
96 > for CalculatorAddRequest
97 where
98 ___E: ::fidl_next::Encoder + ?Sized,
99 CalculatorAddRequest: ::fidl_next::Encode<crate::wire::CalculatorAddRequest, ___E>,
100 {
101 #[inline]
102 fn encode_option(
103 this: ::core::option::Option<Self>,
104 encoder: &mut ___E,
105 out: &mut ::core::mem::MaybeUninit<
106 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddRequest>,
107 >,
108 _: (),
109 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
110 if let Some(inner) = this {
111 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
112 ::fidl_next::WireBox::encode_present(out);
113 } else {
114 ::fidl_next::WireBox::encode_absent(out);
115 }
116
117 Ok(())
118 }
119 }
120
121 unsafe impl<'a, ___E>
122 ::fidl_next::EncodeOption<
123 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddRequest>,
124 ___E,
125 > for &'a CalculatorAddRequest
126 where
127 ___E: ::fidl_next::Encoder + ?Sized,
128 &'a CalculatorAddRequest: ::fidl_next::Encode<crate::wire::CalculatorAddRequest, ___E>,
129 {
130 #[inline]
131 fn encode_option(
132 this: ::core::option::Option<Self>,
133 encoder: &mut ___E,
134 out: &mut ::core::mem::MaybeUninit<
135 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddRequest>,
136 >,
137 _: (),
138 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
139 if let Some(inner) = this {
140 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
141 ::fidl_next::WireBox::encode_present(out);
142 } else {
143 ::fidl_next::WireBox::encode_absent(out);
144 }
145
146 Ok(())
147 }
148 }
149
150 impl ::fidl_next::FromWire<crate::wire::CalculatorAddRequest> for CalculatorAddRequest {
151 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
152 crate::wire::CalculatorAddRequest,
153 Self,
154 > = unsafe {
155 ::fidl_next::CopyOptimization::enable_if(
156 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
157 .is_enabled()
158 && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
159 .is_enabled(),
160 )
161 };
162
163 #[inline]
164 fn from_wire(wire: crate::wire::CalculatorAddRequest) -> Self {
165 Self {
166 a: ::fidl_next::FromWire::from_wire(wire.a),
167
168 b: ::fidl_next::FromWire::from_wire(wire.b),
169 }
170 }
171 }
172
173 impl ::fidl_next::FromWireRef<crate::wire::CalculatorAddRequest> for CalculatorAddRequest {
174 #[inline]
175 fn from_wire_ref(wire: &crate::wire::CalculatorAddRequest) -> Self {
176 Self {
177 a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
178
179 b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
180 }
181 }
182 }
183
184 #[derive(PartialEq, Clone, Debug)]
185 #[repr(C)]
186 pub struct CalculatorAddResponse {
187 pub sum: i32,
188 }
189
190 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CalculatorAddResponse, ___E>
191 for CalculatorAddResponse
192 where
193 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
194 {
195 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
196 Self,
197 crate::wire::CalculatorAddResponse,
198 > = unsafe {
199 ::fidl_next::CopyOptimization::enable_if(
200 true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
201 .is_enabled(),
202 )
203 };
204
205 #[inline]
206 fn encode(
207 self,
208 encoder_: &mut ___E,
209 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorAddResponse>,
210 _: (),
211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
212 ::fidl_next::munge! {
213 let crate::wire::CalculatorAddResponse {
214 sum,
215
216 } = out_;
217 }
218
219 ::fidl_next::Encode::encode(self.sum, encoder_, sum, ())?;
220
221 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sum.as_mut_ptr()) };
222
223 Ok(())
224 }
225 }
226
227 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CalculatorAddResponse, ___E>
228 for &'a CalculatorAddResponse
229 where
230 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
231 {
232 #[inline]
233 fn encode(
234 self,
235 encoder_: &mut ___E,
236 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorAddResponse>,
237 _: (),
238 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
239 ::fidl_next::munge! {
240 let crate::wire::CalculatorAddResponse {
241
242 sum,
243
244 } = out_;
245 }
246
247 ::fidl_next::Encode::encode(&self.sum, encoder_, sum, ())?;
248
249 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sum.as_mut_ptr()) };
250
251 Ok(())
252 }
253 }
254
255 unsafe impl<___E>
256 ::fidl_next::EncodeOption<
257 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddResponse>,
258 ___E,
259 > for CalculatorAddResponse
260 where
261 ___E: ::fidl_next::Encoder + ?Sized,
262 CalculatorAddResponse: ::fidl_next::Encode<crate::wire::CalculatorAddResponse, ___E>,
263 {
264 #[inline]
265 fn encode_option(
266 this: ::core::option::Option<Self>,
267 encoder: &mut ___E,
268 out: &mut ::core::mem::MaybeUninit<
269 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddResponse>,
270 >,
271 _: (),
272 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
273 if let Some(inner) = this {
274 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
275 ::fidl_next::WireBox::encode_present(out);
276 } else {
277 ::fidl_next::WireBox::encode_absent(out);
278 }
279
280 Ok(())
281 }
282 }
283
284 unsafe impl<'a, ___E>
285 ::fidl_next::EncodeOption<
286 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddResponse>,
287 ___E,
288 > for &'a CalculatorAddResponse
289 where
290 ___E: ::fidl_next::Encoder + ?Sized,
291 &'a CalculatorAddResponse: ::fidl_next::Encode<crate::wire::CalculatorAddResponse, ___E>,
292 {
293 #[inline]
294 fn encode_option(
295 this: ::core::option::Option<Self>,
296 encoder: &mut ___E,
297 out: &mut ::core::mem::MaybeUninit<
298 ::fidl_next::WireBox<'static, crate::wire::CalculatorAddResponse>,
299 >,
300 _: (),
301 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
302 if let Some(inner) = this {
303 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
304 ::fidl_next::WireBox::encode_present(out);
305 } else {
306 ::fidl_next::WireBox::encode_absent(out);
307 }
308
309 Ok(())
310 }
311 }
312
313 impl ::fidl_next::FromWire<crate::wire::CalculatorAddResponse> for CalculatorAddResponse {
314 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
315 crate::wire::CalculatorAddResponse,
316 Self,
317 > = unsafe {
318 ::fidl_next::CopyOptimization::enable_if(
319 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
320 .is_enabled(),
321 )
322 };
323
324 #[inline]
325 fn from_wire(wire: crate::wire::CalculatorAddResponse) -> Self {
326 Self { sum: ::fidl_next::FromWire::from_wire(wire.sum) }
327 }
328 }
329
330 impl ::fidl_next::FromWireRef<crate::wire::CalculatorAddResponse> for CalculatorAddResponse {
331 #[inline]
332 fn from_wire_ref(wire: &crate::wire::CalculatorAddResponse) -> Self {
333 Self { sum: ::fidl_next::FromWireRef::from_wire_ref(&wire.sum) }
334 }
335 }
336
337 #[derive(PartialEq, Clone, Debug)]
338 #[repr(C)]
339 pub struct CalculatorDivideRequest {
340 pub dividend: i32,
341
342 pub divisor: i32,
343 }
344
345 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CalculatorDivideRequest, ___E>
346 for CalculatorDivideRequest
347 where
348 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
349 {
350 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
351 Self,
352 crate::wire::CalculatorDivideRequest,
353 > = unsafe {
354 ::fidl_next::CopyOptimization::enable_if(
355 true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
356 .is_enabled()
357 && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
358 .is_enabled(),
359 )
360 };
361
362 #[inline]
363 fn encode(
364 self,
365 encoder_: &mut ___E,
366 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorDivideRequest>,
367 _: (),
368 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
369 ::fidl_next::munge! {
370 let crate::wire::CalculatorDivideRequest {
371 dividend,
372 divisor,
373
374 } = out_;
375 }
376
377 ::fidl_next::Encode::encode(self.dividend, encoder_, dividend, ())?;
378
379 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dividend.as_mut_ptr()) };
380
381 ::fidl_next::Encode::encode(self.divisor, encoder_, divisor, ())?;
382
383 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(divisor.as_mut_ptr()) };
384
385 Ok(())
386 }
387 }
388
389 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CalculatorDivideRequest, ___E>
390 for &'a CalculatorDivideRequest
391 where
392 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
393 {
394 #[inline]
395 fn encode(
396 self,
397 encoder_: &mut ___E,
398 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorDivideRequest>,
399 _: (),
400 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
401 ::fidl_next::munge! {
402 let crate::wire::CalculatorDivideRequest {
403
404 dividend,
405 divisor,
406
407 } = out_;
408 }
409
410 ::fidl_next::Encode::encode(&self.dividend, encoder_, dividend, ())?;
411
412 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dividend.as_mut_ptr()) };
413
414 ::fidl_next::Encode::encode(&self.divisor, encoder_, divisor, ())?;
415
416 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(divisor.as_mut_ptr()) };
417
418 Ok(())
419 }
420 }
421
422 unsafe impl<___E>
423 ::fidl_next::EncodeOption<
424 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideRequest>,
425 ___E,
426 > for CalculatorDivideRequest
427 where
428 ___E: ::fidl_next::Encoder + ?Sized,
429 CalculatorDivideRequest: ::fidl_next::Encode<crate::wire::CalculatorDivideRequest, ___E>,
430 {
431 #[inline]
432 fn encode_option(
433 this: ::core::option::Option<Self>,
434 encoder: &mut ___E,
435 out: &mut ::core::mem::MaybeUninit<
436 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideRequest>,
437 >,
438 _: (),
439 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
440 if let Some(inner) = this {
441 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
442 ::fidl_next::WireBox::encode_present(out);
443 } else {
444 ::fidl_next::WireBox::encode_absent(out);
445 }
446
447 Ok(())
448 }
449 }
450
451 unsafe impl<'a, ___E>
452 ::fidl_next::EncodeOption<
453 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideRequest>,
454 ___E,
455 > for &'a CalculatorDivideRequest
456 where
457 ___E: ::fidl_next::Encoder + ?Sized,
458 &'a CalculatorDivideRequest:
459 ::fidl_next::Encode<crate::wire::CalculatorDivideRequest, ___E>,
460 {
461 #[inline]
462 fn encode_option(
463 this: ::core::option::Option<Self>,
464 encoder: &mut ___E,
465 out: &mut ::core::mem::MaybeUninit<
466 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideRequest>,
467 >,
468 _: (),
469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
470 if let Some(inner) = this {
471 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
472 ::fidl_next::WireBox::encode_present(out);
473 } else {
474 ::fidl_next::WireBox::encode_absent(out);
475 }
476
477 Ok(())
478 }
479 }
480
481 impl ::fidl_next::FromWire<crate::wire::CalculatorDivideRequest> for CalculatorDivideRequest {
482 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
483 crate::wire::CalculatorDivideRequest,
484 Self,
485 > = unsafe {
486 ::fidl_next::CopyOptimization::enable_if(
487 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
488 .is_enabled()
489 && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
490 .is_enabled(),
491 )
492 };
493
494 #[inline]
495 fn from_wire(wire: crate::wire::CalculatorDivideRequest) -> Self {
496 Self {
497 dividend: ::fidl_next::FromWire::from_wire(wire.dividend),
498
499 divisor: ::fidl_next::FromWire::from_wire(wire.divisor),
500 }
501 }
502 }
503
504 impl ::fidl_next::FromWireRef<crate::wire::CalculatorDivideRequest> for CalculatorDivideRequest {
505 #[inline]
506 fn from_wire_ref(wire: &crate::wire::CalculatorDivideRequest) -> Self {
507 Self {
508 dividend: ::fidl_next::FromWireRef::from_wire_ref(&wire.dividend),
509
510 divisor: ::fidl_next::FromWireRef::from_wire_ref(&wire.divisor),
511 }
512 }
513 }
514
515 #[derive(PartialEq, Clone, Debug)]
516 #[repr(C)]
517 pub struct CalculatorDivideResponse {
518 pub quotient: i32,
519
520 pub remainder: i32,
521 }
522
523 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CalculatorDivideResponse, ___E>
524 for CalculatorDivideResponse
525 where
526 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
527 {
528 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
529 Self,
530 crate::wire::CalculatorDivideResponse,
531 > = unsafe {
532 ::fidl_next::CopyOptimization::enable_if(
533 true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
534 .is_enabled()
535 && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
536 .is_enabled(),
537 )
538 };
539
540 #[inline]
541 fn encode(
542 self,
543 encoder_: &mut ___E,
544 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorDivideResponse>,
545 _: (),
546 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
547 ::fidl_next::munge! {
548 let crate::wire::CalculatorDivideResponse {
549 quotient,
550 remainder,
551
552 } = out_;
553 }
554
555 ::fidl_next::Encode::encode(self.quotient, encoder_, quotient, ())?;
556
557 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(quotient.as_mut_ptr()) };
558
559 ::fidl_next::Encode::encode(self.remainder, encoder_, remainder, ())?;
560
561 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(remainder.as_mut_ptr()) };
562
563 Ok(())
564 }
565 }
566
567 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CalculatorDivideResponse, ___E>
568 for &'a CalculatorDivideResponse
569 where
570 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
571 {
572 #[inline]
573 fn encode(
574 self,
575 encoder_: &mut ___E,
576 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorDivideResponse>,
577 _: (),
578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
579 ::fidl_next::munge! {
580 let crate::wire::CalculatorDivideResponse {
581
582 quotient,
583 remainder,
584
585 } = out_;
586 }
587
588 ::fidl_next::Encode::encode(&self.quotient, encoder_, quotient, ())?;
589
590 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(quotient.as_mut_ptr()) };
591
592 ::fidl_next::Encode::encode(&self.remainder, encoder_, remainder, ())?;
593
594 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(remainder.as_mut_ptr()) };
595
596 Ok(())
597 }
598 }
599
600 unsafe impl<___E>
601 ::fidl_next::EncodeOption<
602 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideResponse>,
603 ___E,
604 > for CalculatorDivideResponse
605 where
606 ___E: ::fidl_next::Encoder + ?Sized,
607 CalculatorDivideResponse: ::fidl_next::Encode<crate::wire::CalculatorDivideResponse, ___E>,
608 {
609 #[inline]
610 fn encode_option(
611 this: ::core::option::Option<Self>,
612 encoder: &mut ___E,
613 out: &mut ::core::mem::MaybeUninit<
614 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideResponse>,
615 >,
616 _: (),
617 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
618 if let Some(inner) = this {
619 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
620 ::fidl_next::WireBox::encode_present(out);
621 } else {
622 ::fidl_next::WireBox::encode_absent(out);
623 }
624
625 Ok(())
626 }
627 }
628
629 unsafe impl<'a, ___E>
630 ::fidl_next::EncodeOption<
631 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideResponse>,
632 ___E,
633 > for &'a CalculatorDivideResponse
634 where
635 ___E: ::fidl_next::Encoder + ?Sized,
636 &'a CalculatorDivideResponse:
637 ::fidl_next::Encode<crate::wire::CalculatorDivideResponse, ___E>,
638 {
639 #[inline]
640 fn encode_option(
641 this: ::core::option::Option<Self>,
642 encoder: &mut ___E,
643 out: &mut ::core::mem::MaybeUninit<
644 ::fidl_next::WireBox<'static, crate::wire::CalculatorDivideResponse>,
645 >,
646 _: (),
647 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
648 if let Some(inner) = this {
649 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
650 ::fidl_next::WireBox::encode_present(out);
651 } else {
652 ::fidl_next::WireBox::encode_absent(out);
653 }
654
655 Ok(())
656 }
657 }
658
659 impl ::fidl_next::FromWire<crate::wire::CalculatorDivideResponse> for CalculatorDivideResponse {
660 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
661 crate::wire::CalculatorDivideResponse,
662 Self,
663 > = unsafe {
664 ::fidl_next::CopyOptimization::enable_if(
665 true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
666 .is_enabled()
667 && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
668 .is_enabled(),
669 )
670 };
671
672 #[inline]
673 fn from_wire(wire: crate::wire::CalculatorDivideResponse) -> Self {
674 Self {
675 quotient: ::fidl_next::FromWire::from_wire(wire.quotient),
676
677 remainder: ::fidl_next::FromWire::from_wire(wire.remainder),
678 }
679 }
680 }
681
682 impl ::fidl_next::FromWireRef<crate::wire::CalculatorDivideResponse> for CalculatorDivideResponse {
683 #[inline]
684 fn from_wire_ref(wire: &crate::wire::CalculatorDivideResponse) -> Self {
685 Self {
686 quotient: ::fidl_next::FromWireRef::from_wire_ref(&wire.quotient),
687
688 remainder: ::fidl_next::FromWireRef::from_wire_ref(&wire.remainder),
689 }
690 }
691 }
692
693 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
694 #[repr(u32)]
695 pub enum DivisionError {
696 DivideByZero = 1,
697 }
698 impl ::core::convert::TryFrom<u32> for DivisionError {
699 type Error = ::fidl_next::UnknownStrictEnumMemberError;
700 fn try_from(
701 value: u32,
702 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
703 match value {
704 1 => Ok(Self::DivideByZero),
705
706 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
707 }
708 }
709 }
710
711 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DivisionError, ___E> for DivisionError
712 where
713 ___E: ?Sized,
714 {
715 #[inline]
716 fn encode(
717 self,
718 encoder: &mut ___E,
719 out: &mut ::core::mem::MaybeUninit<crate::wire::DivisionError>,
720 _: (),
721 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
722 ::fidl_next::Encode::encode(&self, encoder, out, ())
723 }
724 }
725
726 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DivisionError, ___E> for &'a DivisionError
727 where
728 ___E: ?Sized,
729 {
730 #[inline]
731 fn encode(
732 self,
733 encoder: &mut ___E,
734 out: &mut ::core::mem::MaybeUninit<crate::wire::DivisionError>,
735 _: (),
736 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
737 ::fidl_next::munge!(let crate::wire::DivisionError { value } = out);
738 let _ = value.write(::fidl_next::WireU32::from(match *self {
739 DivisionError::DivideByZero => 1,
740 }));
741
742 Ok(())
743 }
744 }
745
746 impl ::core::convert::From<crate::wire::DivisionError> for DivisionError {
747 fn from(wire: crate::wire::DivisionError) -> Self {
748 match u32::from(wire.value) {
749 1 => Self::DivideByZero,
750
751 _ => unsafe { ::core::hint::unreachable_unchecked() },
752 }
753 }
754 }
755
756 impl ::fidl_next::FromWire<crate::wire::DivisionError> for DivisionError {
757 #[inline]
758 fn from_wire(wire: crate::wire::DivisionError) -> Self {
759 Self::from(wire)
760 }
761 }
762
763 impl ::fidl_next::FromWireRef<crate::wire::DivisionError> for DivisionError {
764 #[inline]
765 fn from_wire_ref(wire: &crate::wire::DivisionError) -> Self {
766 Self::from(*wire)
767 }
768 }
769
770 #[derive(PartialEq, Clone, Debug)]
771 #[repr(C)]
772 pub struct CalculatorOnErrorRequest {
773 pub status_code: u32,
774 }
775
776 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CalculatorOnErrorRequest, ___E>
777 for CalculatorOnErrorRequest
778 where
779 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
780 {
781 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
782 Self,
783 crate::wire::CalculatorOnErrorRequest,
784 > = unsafe {
785 ::fidl_next::CopyOptimization::enable_if(
786 true && <u32 as ::fidl_next::Encode<::fidl_next::WireU32, ___E>>::COPY_OPTIMIZATION
787 .is_enabled(),
788 )
789 };
790
791 #[inline]
792 fn encode(
793 self,
794 encoder_: &mut ___E,
795 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorOnErrorRequest>,
796 _: (),
797 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
798 ::fidl_next::munge! {
799 let crate::wire::CalculatorOnErrorRequest {
800 status_code,
801
802 } = out_;
803 }
804
805 ::fidl_next::Encode::encode(self.status_code, encoder_, status_code, ())?;
806
807 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status_code.as_mut_ptr()) };
808
809 Ok(())
810 }
811 }
812
813 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CalculatorOnErrorRequest, ___E>
814 for &'a CalculatorOnErrorRequest
815 where
816 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
817 {
818 #[inline]
819 fn encode(
820 self,
821 encoder_: &mut ___E,
822 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorOnErrorRequest>,
823 _: (),
824 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
825 ::fidl_next::munge! {
826 let crate::wire::CalculatorOnErrorRequest {
827
828 status_code,
829
830 } = out_;
831 }
832
833 ::fidl_next::Encode::encode(&self.status_code, encoder_, status_code, ())?;
834
835 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(status_code.as_mut_ptr()) };
836
837 Ok(())
838 }
839 }
840
841 unsafe impl<___E>
842 ::fidl_next::EncodeOption<
843 ::fidl_next::WireBox<'static, crate::wire::CalculatorOnErrorRequest>,
844 ___E,
845 > for CalculatorOnErrorRequest
846 where
847 ___E: ::fidl_next::Encoder + ?Sized,
848 CalculatorOnErrorRequest: ::fidl_next::Encode<crate::wire::CalculatorOnErrorRequest, ___E>,
849 {
850 #[inline]
851 fn encode_option(
852 this: ::core::option::Option<Self>,
853 encoder: &mut ___E,
854 out: &mut ::core::mem::MaybeUninit<
855 ::fidl_next::WireBox<'static, crate::wire::CalculatorOnErrorRequest>,
856 >,
857 _: (),
858 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
859 if let Some(inner) = this {
860 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
861 ::fidl_next::WireBox::encode_present(out);
862 } else {
863 ::fidl_next::WireBox::encode_absent(out);
864 }
865
866 Ok(())
867 }
868 }
869
870 unsafe impl<'a, ___E>
871 ::fidl_next::EncodeOption<
872 ::fidl_next::WireBox<'static, crate::wire::CalculatorOnErrorRequest>,
873 ___E,
874 > for &'a CalculatorOnErrorRequest
875 where
876 ___E: ::fidl_next::Encoder + ?Sized,
877 &'a CalculatorOnErrorRequest:
878 ::fidl_next::Encode<crate::wire::CalculatorOnErrorRequest, ___E>,
879 {
880 #[inline]
881 fn encode_option(
882 this: ::core::option::Option<Self>,
883 encoder: &mut ___E,
884 out: &mut ::core::mem::MaybeUninit<
885 ::fidl_next::WireBox<'static, crate::wire::CalculatorOnErrorRequest>,
886 >,
887 _: (),
888 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
889 if let Some(inner) = this {
890 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
891 ::fidl_next::WireBox::encode_present(out);
892 } else {
893 ::fidl_next::WireBox::encode_absent(out);
894 }
895
896 Ok(())
897 }
898 }
899
900 impl ::fidl_next::FromWire<crate::wire::CalculatorOnErrorRequest> for CalculatorOnErrorRequest {
901 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
902 crate::wire::CalculatorOnErrorRequest,
903 Self,
904 > = unsafe {
905 ::fidl_next::CopyOptimization::enable_if(
906 true && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
907 .is_enabled(),
908 )
909 };
910
911 #[inline]
912 fn from_wire(wire: crate::wire::CalculatorOnErrorRequest) -> Self {
913 Self { status_code: ::fidl_next::FromWire::from_wire(wire.status_code) }
914 }
915 }
916
917 impl ::fidl_next::FromWireRef<crate::wire::CalculatorOnErrorRequest> for CalculatorOnErrorRequest {
918 #[inline]
919 fn from_wire_ref(wire: &crate::wire::CalculatorOnErrorRequest) -> Self {
920 Self { status_code: ::fidl_next::FromWireRef::from_wire_ref(&wire.status_code) }
921 }
922 }
923}
924
925pub mod wire {
926
927 #[derive(Clone, Debug)]
929 #[repr(C)]
930 pub struct CalculatorAddRequest {
931 pub a: ::fidl_next::WireI32,
932
933 pub b: ::fidl_next::WireI32,
934 }
935
936 static_assertions::const_assert_eq!(std::mem::size_of::<CalculatorAddRequest>(), 8);
937 static_assertions::const_assert_eq!(std::mem::align_of::<CalculatorAddRequest>(), 4);
938
939 static_assertions::const_assert_eq!(std::mem::offset_of!(CalculatorAddRequest, a), 0);
940
941 static_assertions::const_assert_eq!(std::mem::offset_of!(CalculatorAddRequest, b), 4);
942
943 unsafe impl ::fidl_next::Wire for CalculatorAddRequest {
944 type Owned<'de> = CalculatorAddRequest;
945
946 #[inline]
947 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
948 ::fidl_next::munge! {
949 let Self {
950
951 a,
952 b,
953
954 } = &mut *out_;
955 }
956
957 ::fidl_next::Wire::zero_padding(a);
958
959 ::fidl_next::Wire::zero_padding(b);
960 }
961 }
962
963 unsafe impl<___D> ::fidl_next::Decode<___D> for CalculatorAddRequest
964 where
965 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
966 {
967 fn decode(
968 slot_: ::fidl_next::Slot<'_, Self>,
969 decoder_: &mut ___D,
970 _: (),
971 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
972 ::fidl_next::munge! {
973 let Self {
974
975 mut a,
976 mut b,
977
978 } = slot_;
979 }
980
981 let _field = a.as_mut();
982
983 ::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
984
985 let _field = b.as_mut();
986
987 ::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
988
989 Ok(())
990 }
991 }
992
993 impl ::fidl_next::IntoNatural for CalculatorAddRequest {
994 type Natural = crate::natural::CalculatorAddRequest;
995 }
996
997 impl ::fidl_next::Unconstrained for CalculatorAddRequest {}
998
999 #[derive(Clone, Debug)]
1001 #[repr(C)]
1002 pub struct CalculatorAddResponse {
1003 pub sum: ::fidl_next::WireI32,
1004 }
1005
1006 static_assertions::const_assert_eq!(std::mem::size_of::<CalculatorAddResponse>(), 4);
1007 static_assertions::const_assert_eq!(std::mem::align_of::<CalculatorAddResponse>(), 4);
1008
1009 static_assertions::const_assert_eq!(std::mem::offset_of!(CalculatorAddResponse, sum), 0);
1010
1011 unsafe impl ::fidl_next::Wire for CalculatorAddResponse {
1012 type Owned<'de> = CalculatorAddResponse;
1013
1014 #[inline]
1015 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1016 ::fidl_next::munge! {
1017 let Self {
1018
1019 sum,
1020
1021 } = &mut *out_;
1022 }
1023
1024 ::fidl_next::Wire::zero_padding(sum);
1025 }
1026 }
1027
1028 unsafe impl<___D> ::fidl_next::Decode<___D> for CalculatorAddResponse
1029 where
1030 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1031 {
1032 fn decode(
1033 slot_: ::fidl_next::Slot<'_, Self>,
1034 decoder_: &mut ___D,
1035 _: (),
1036 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1037 ::fidl_next::munge! {
1038 let Self {
1039
1040 mut sum,
1041
1042 } = slot_;
1043 }
1044
1045 let _field = sum.as_mut();
1046
1047 ::fidl_next::Decode::decode(sum.as_mut(), decoder_, ())?;
1048
1049 Ok(())
1050 }
1051 }
1052
1053 impl ::fidl_next::IntoNatural for CalculatorAddResponse {
1054 type Natural = crate::natural::CalculatorAddResponse;
1055 }
1056
1057 impl ::fidl_next::Unconstrained for CalculatorAddResponse {}
1058
1059 #[derive(Clone, Debug)]
1061 #[repr(C)]
1062 pub struct CalculatorDivideRequest {
1063 pub dividend: ::fidl_next::WireI32,
1064
1065 pub divisor: ::fidl_next::WireI32,
1066 }
1067
1068 static_assertions::const_assert_eq!(std::mem::size_of::<CalculatorDivideRequest>(), 8);
1069 static_assertions::const_assert_eq!(std::mem::align_of::<CalculatorDivideRequest>(), 4);
1070
1071 static_assertions::const_assert_eq!(std::mem::offset_of!(CalculatorDivideRequest, dividend), 0);
1072
1073 static_assertions::const_assert_eq!(std::mem::offset_of!(CalculatorDivideRequest, divisor), 4);
1074
1075 unsafe impl ::fidl_next::Wire for CalculatorDivideRequest {
1076 type Owned<'de> = CalculatorDivideRequest;
1077
1078 #[inline]
1079 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1080 ::fidl_next::munge! {
1081 let Self {
1082
1083 dividend,
1084 divisor,
1085
1086 } = &mut *out_;
1087 }
1088
1089 ::fidl_next::Wire::zero_padding(dividend);
1090
1091 ::fidl_next::Wire::zero_padding(divisor);
1092 }
1093 }
1094
1095 unsafe impl<___D> ::fidl_next::Decode<___D> for CalculatorDivideRequest
1096 where
1097 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1098 {
1099 fn decode(
1100 slot_: ::fidl_next::Slot<'_, Self>,
1101 decoder_: &mut ___D,
1102 _: (),
1103 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1104 ::fidl_next::munge! {
1105 let Self {
1106
1107 mut dividend,
1108 mut divisor,
1109
1110 } = slot_;
1111 }
1112
1113 let _field = dividend.as_mut();
1114
1115 ::fidl_next::Decode::decode(dividend.as_mut(), decoder_, ())?;
1116
1117 let _field = divisor.as_mut();
1118
1119 ::fidl_next::Decode::decode(divisor.as_mut(), decoder_, ())?;
1120
1121 Ok(())
1122 }
1123 }
1124
1125 impl ::fidl_next::IntoNatural for CalculatorDivideRequest {
1126 type Natural = crate::natural::CalculatorDivideRequest;
1127 }
1128
1129 impl ::fidl_next::Unconstrained for CalculatorDivideRequest {}
1130
1131 #[derive(Clone, Debug)]
1133 #[repr(C)]
1134 pub struct CalculatorDivideResponse {
1135 pub quotient: ::fidl_next::WireI32,
1136
1137 pub remainder: ::fidl_next::WireI32,
1138 }
1139
1140 static_assertions::const_assert_eq!(std::mem::size_of::<CalculatorDivideResponse>(), 8);
1141 static_assertions::const_assert_eq!(std::mem::align_of::<CalculatorDivideResponse>(), 4);
1142
1143 static_assertions::const_assert_eq!(
1144 std::mem::offset_of!(CalculatorDivideResponse, quotient),
1145 0
1146 );
1147
1148 static_assertions::const_assert_eq!(
1149 std::mem::offset_of!(CalculatorDivideResponse, remainder),
1150 4
1151 );
1152
1153 unsafe impl ::fidl_next::Wire for CalculatorDivideResponse {
1154 type Owned<'de> = CalculatorDivideResponse;
1155
1156 #[inline]
1157 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1158 ::fidl_next::munge! {
1159 let Self {
1160
1161 quotient,
1162 remainder,
1163
1164 } = &mut *out_;
1165 }
1166
1167 ::fidl_next::Wire::zero_padding(quotient);
1168
1169 ::fidl_next::Wire::zero_padding(remainder);
1170 }
1171 }
1172
1173 unsafe impl<___D> ::fidl_next::Decode<___D> for CalculatorDivideResponse
1174 where
1175 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1176 {
1177 fn decode(
1178 slot_: ::fidl_next::Slot<'_, Self>,
1179 decoder_: &mut ___D,
1180 _: (),
1181 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1182 ::fidl_next::munge! {
1183 let Self {
1184
1185 mut quotient,
1186 mut remainder,
1187
1188 } = slot_;
1189 }
1190
1191 let _field = quotient.as_mut();
1192
1193 ::fidl_next::Decode::decode(quotient.as_mut(), decoder_, ())?;
1194
1195 let _field = remainder.as_mut();
1196
1197 ::fidl_next::Decode::decode(remainder.as_mut(), decoder_, ())?;
1198
1199 Ok(())
1200 }
1201 }
1202
1203 impl ::fidl_next::IntoNatural for CalculatorDivideResponse {
1204 type Natural = crate::natural::CalculatorDivideResponse;
1205 }
1206
1207 impl ::fidl_next::Unconstrained for CalculatorDivideResponse {}
1208
1209 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1211 #[repr(transparent)]
1212 pub struct DivisionError {
1213 pub(crate) value: ::fidl_next::WireU32,
1214 }
1215
1216 unsafe impl ::fidl_next::Wire for DivisionError {
1217 type Owned<'de> = Self;
1218
1219 #[inline]
1220 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1221 }
1223 }
1224
1225 impl DivisionError {
1226 pub const DIVIDE_BY_ZERO: DivisionError = DivisionError { value: ::fidl_next::WireU32(1) };
1227 }
1228
1229 unsafe impl<___D> ::fidl_next::Decode<___D> for DivisionError
1230 where
1231 ___D: ?Sized,
1232 {
1233 fn decode(
1234 slot: ::fidl_next::Slot<'_, Self>,
1235 _: &mut ___D,
1236 _: (),
1237 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1238 ::fidl_next::munge!(let Self { value } = slot);
1239
1240 match u32::from(*value) {
1241 1 => (),
1242 unknown => {
1243 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
1244 }
1245 }
1246
1247 Ok(())
1248 }
1249 }
1250
1251 impl ::core::convert::From<crate::natural::DivisionError> for DivisionError {
1252 fn from(natural: crate::natural::DivisionError) -> Self {
1253 match natural {
1254 crate::natural::DivisionError::DivideByZero => DivisionError::DIVIDE_BY_ZERO,
1255 }
1256 }
1257 }
1258
1259 impl ::fidl_next::IntoNatural for DivisionError {
1260 type Natural = crate::natural::DivisionError;
1261 }
1262
1263 impl ::fidl_next::Unconstrained for DivisionError {}
1264
1265 #[derive(Clone, Debug)]
1267 #[repr(C)]
1268 pub struct CalculatorOnErrorRequest {
1269 pub status_code: ::fidl_next::WireU32,
1270 }
1271
1272 static_assertions::const_assert_eq!(std::mem::size_of::<CalculatorOnErrorRequest>(), 4);
1273 static_assertions::const_assert_eq!(std::mem::align_of::<CalculatorOnErrorRequest>(), 4);
1274
1275 static_assertions::const_assert_eq!(
1276 std::mem::offset_of!(CalculatorOnErrorRequest, status_code),
1277 0
1278 );
1279
1280 unsafe impl ::fidl_next::Wire for CalculatorOnErrorRequest {
1281 type Owned<'de> = CalculatorOnErrorRequest;
1282
1283 #[inline]
1284 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1285 ::fidl_next::munge! {
1286 let Self {
1287
1288 status_code,
1289
1290 } = &mut *out_;
1291 }
1292
1293 ::fidl_next::Wire::zero_padding(status_code);
1294 }
1295 }
1296
1297 unsafe impl<___D> ::fidl_next::Decode<___D> for CalculatorOnErrorRequest
1298 where
1299 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1300 {
1301 fn decode(
1302 slot_: ::fidl_next::Slot<'_, Self>,
1303 decoder_: &mut ___D,
1304 _: (),
1305 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1306 ::fidl_next::munge! {
1307 let Self {
1308
1309 mut status_code,
1310
1311 } = slot_;
1312 }
1313
1314 let _field = status_code.as_mut();
1315
1316 ::fidl_next::Decode::decode(status_code.as_mut(), decoder_, ())?;
1317
1318 Ok(())
1319 }
1320 }
1321
1322 impl ::fidl_next::IntoNatural for CalculatorOnErrorRequest {
1323 type Natural = crate::natural::CalculatorOnErrorRequest;
1324 }
1325
1326 impl ::fidl_next::Unconstrained for CalculatorOnErrorRequest {}
1327}
1328
1329pub mod wire_optional {}
1330
1331pub mod generic {
1332
1333 pub struct CalculatorAddRequest<T0, T1> {
1334 pub a: T0,
1335
1336 pub b: T1,
1337 }
1338
1339 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::CalculatorAddRequest, ___E>
1340 for CalculatorAddRequest<T0, T1>
1341 where
1342 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1343 T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1344 T1: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1345 {
1346 #[inline]
1347 fn encode(
1348 self,
1349 encoder_: &mut ___E,
1350 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorAddRequest>,
1351 _: (),
1352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1353 ::fidl_next::munge! {
1354 let crate::wire::CalculatorAddRequest {
1355
1356 a,
1357 b,
1358
1359 } = out_;
1360 }
1361
1362 ::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
1363
1364 ::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
1365
1366 Ok(())
1367 }
1368 }
1369
1370 pub struct CalculatorAddResponse<T0> {
1371 pub sum: T0,
1372 }
1373
1374 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CalculatorAddResponse, ___E>
1375 for CalculatorAddResponse<T0>
1376 where
1377 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1378 T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1379 {
1380 #[inline]
1381 fn encode(
1382 self,
1383 encoder_: &mut ___E,
1384 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorAddResponse>,
1385 _: (),
1386 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1387 ::fidl_next::munge! {
1388 let crate::wire::CalculatorAddResponse {
1389
1390 sum,
1391
1392 } = out_;
1393 }
1394
1395 ::fidl_next::Encode::encode(self.sum, encoder_, sum, ())?;
1396
1397 Ok(())
1398 }
1399 }
1400
1401 pub struct CalculatorDivideRequest<T0, T1> {
1402 pub dividend: T0,
1403
1404 pub divisor: T1,
1405 }
1406
1407 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::CalculatorDivideRequest, ___E>
1408 for CalculatorDivideRequest<T0, T1>
1409 where
1410 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1411 T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1412 T1: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1413 {
1414 #[inline]
1415 fn encode(
1416 self,
1417 encoder_: &mut ___E,
1418 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorDivideRequest>,
1419 _: (),
1420 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1421 ::fidl_next::munge! {
1422 let crate::wire::CalculatorDivideRequest {
1423
1424 dividend,
1425 divisor,
1426
1427 } = out_;
1428 }
1429
1430 ::fidl_next::Encode::encode(self.dividend, encoder_, dividend, ())?;
1431
1432 ::fidl_next::Encode::encode(self.divisor, encoder_, divisor, ())?;
1433
1434 Ok(())
1435 }
1436 }
1437
1438 pub struct CalculatorDivideResponse<T0, T1> {
1439 pub quotient: T0,
1440
1441 pub remainder: T1,
1442 }
1443
1444 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::CalculatorDivideResponse, ___E>
1445 for CalculatorDivideResponse<T0, T1>
1446 where
1447 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1448 T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1449 T1: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
1450 {
1451 #[inline]
1452 fn encode(
1453 self,
1454 encoder_: &mut ___E,
1455 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorDivideResponse>,
1456 _: (),
1457 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1458 ::fidl_next::munge! {
1459 let crate::wire::CalculatorDivideResponse {
1460
1461 quotient,
1462 remainder,
1463
1464 } = out_;
1465 }
1466
1467 ::fidl_next::Encode::encode(self.quotient, encoder_, quotient, ())?;
1468
1469 ::fidl_next::Encode::encode(self.remainder, encoder_, remainder, ())?;
1470
1471 Ok(())
1472 }
1473 }
1474
1475 pub struct CalculatorOnErrorRequest<T0> {
1476 pub status_code: T0,
1477 }
1478
1479 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CalculatorOnErrorRequest, ___E>
1480 for CalculatorOnErrorRequest<T0>
1481 where
1482 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1483 T0: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
1484 {
1485 #[inline]
1486 fn encode(
1487 self,
1488 encoder_: &mut ___E,
1489 out_: &mut ::core::mem::MaybeUninit<crate::wire::CalculatorOnErrorRequest>,
1490 _: (),
1491 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1492 ::fidl_next::munge! {
1493 let crate::wire::CalculatorOnErrorRequest {
1494
1495 status_code,
1496
1497 } = out_;
1498 }
1499
1500 ::fidl_next::Encode::encode(self.status_code, encoder_, status_code, ())?;
1501
1502 Ok(())
1503 }
1504 }
1505}
1506
1507pub use self::natural::*;
1508
1509#[derive(PartialEq, Debug)]
1511pub struct Calculator;
1512
1513#[cfg(target_os = "fuchsia")]
1514impl ::fidl_next::HasTransport for Calculator {
1515 type Transport = ::fidl_next::fuchsia::zx::Channel;
1516}
1517
1518pub mod calculator {
1519 pub mod prelude {
1520 pub use crate::{Calculator, CalculatorClientHandler, CalculatorServerHandler, calculator};
1521
1522 pub use crate::natural::CalculatorAddRequest;
1523
1524 pub use crate::natural::CalculatorDivideRequest;
1525
1526 pub use crate::natural::CalculatorOnErrorRequest;
1527
1528 pub use crate::natural::CalculatorAddResponse;
1529
1530 pub use crate::natural::CalculatorDivideResponse;
1531
1532 pub use crate::natural::DivisionError;
1533 }
1534
1535 pub struct Add;
1536
1537 impl ::fidl_next::Method for Add {
1538 const ORDINAL: u64 = 8640324702111165953;
1539 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
1540 ::fidl_next::protocol::Flexibility::Flexible;
1541
1542 type Protocol = crate::Calculator;
1543
1544 type Request = crate::wire::CalculatorAddRequest;
1545 }
1546
1547 impl ::fidl_next::TwoWayMethod for Add {
1548 type Response = ::fidl_next::WireFlexible<'static, crate::wire::CalculatorAddResponse>;
1549 }
1550
1551 impl<___R> ::fidl_next::Respond<___R> for Add {
1552 type Output = ::fidl_next::Flexible<crate::generic::CalculatorAddResponse<___R>>;
1553
1554 fn respond(response: ___R) -> Self::Output {
1555 ::fidl_next::Flexible::Ok(crate::generic::CalculatorAddResponse { sum: response })
1556 }
1557 }
1558
1559 pub struct Divide;
1560
1561 impl ::fidl_next::Method for Divide {
1562 const ORDINAL: u64 = 5497947425807432439;
1563 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
1564 ::fidl_next::protocol::Flexibility::Flexible;
1565
1566 type Protocol = crate::Calculator;
1567
1568 type Request = crate::wire::CalculatorDivideRequest;
1569 }
1570
1571 impl ::fidl_next::TwoWayMethod for Divide {
1572 type Response = ::fidl_next::WireFlexibleResult<
1573 'static,
1574 crate::wire::CalculatorDivideResponse,
1575 crate::wire::DivisionError,
1576 >;
1577 }
1578
1579 impl<___R> ::fidl_next::Respond<___R> for Divide {
1580 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
1581
1582 fn respond(response: ___R) -> Self::Output {
1583 ::fidl_next::FlexibleResult::Ok(response)
1584 }
1585 }
1586
1587 impl<___R> ::fidl_next::RespondErr<___R> for Divide {
1588 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
1589
1590 fn respond_err(response: ___R) -> Self::Output {
1591 ::fidl_next::FlexibleResult::Err(response)
1592 }
1593 }
1594
1595 pub struct Clear;
1596
1597 impl ::fidl_next::Method for Clear {
1598 const ORDINAL: u64 = 7439411180362570889;
1599 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
1600 ::fidl_next::protocol::Flexibility::Flexible;
1601
1602 type Protocol = crate::Calculator;
1603
1604 type Request = ();
1605 }
1606
1607 pub struct OnError;
1608
1609 impl ::fidl_next::Method for OnError {
1610 const ORDINAL: u64 = 8940578522385404924;
1611 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
1612 ::fidl_next::protocol::Flexibility::Flexible;
1613
1614 type Protocol = crate::Calculator;
1615
1616 type Request = crate::wire::CalculatorOnErrorRequest;
1617 }
1618
1619 mod ___detail {
1620 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Calculator
1621 where
1622 ___T: ::fidl_next::Transport,
1623 {
1624 type Client = CalculatorClient<___T>;
1625 type Server = CalculatorServer<___T>;
1626 }
1627
1628 #[repr(transparent)]
1630 pub struct CalculatorClient<___T: ::fidl_next::Transport> {
1631 #[allow(dead_code)]
1632 client: ::fidl_next::protocol::Client<___T>,
1633 }
1634
1635 impl<___T> CalculatorClient<___T>
1636 where
1637 ___T: ::fidl_next::Transport,
1638 {
1639 pub fn add(
1640 &self,
1641
1642 a: impl ::fidl_next::Encode<
1643 ::fidl_next::WireI32,
1644 <___T as ::fidl_next::Transport>::SendBuffer,
1645 >,
1646
1647 b: impl ::fidl_next::Encode<
1648 ::fidl_next::WireI32,
1649 <___T as ::fidl_next::Transport>::SendBuffer,
1650 >,
1651 ) -> ::fidl_next::TwoWayFuture<'_, super::Add, ___T>
1652 where
1653 <___T as ::fidl_next::Transport>::SendBuffer:
1654 ::fidl_next::encoder::InternalHandleEncoder,
1655 {
1656 self.add_with(crate::generic::CalculatorAddRequest { a, b })
1657 }
1658
1659 pub fn add_with<___R>(
1660 &self,
1661 request: ___R,
1662 ) -> ::fidl_next::TwoWayFuture<'_, super::Add, ___T>
1663 where
1664 ___R: ::fidl_next::Encode<
1665 crate::wire::CalculatorAddRequest,
1666 <___T as ::fidl_next::Transport>::SendBuffer,
1667 >,
1668 {
1669 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
1670 8640324702111165953,
1671 <super::Add as ::fidl_next::Method>::FLEXIBILITY,
1672 request,
1673 ))
1674 }
1675
1676 pub fn divide(
1677 &self,
1678
1679 dividend: impl ::fidl_next::Encode<
1680 ::fidl_next::WireI32,
1681 <___T as ::fidl_next::Transport>::SendBuffer,
1682 >,
1683
1684 divisor: impl ::fidl_next::Encode<
1685 ::fidl_next::WireI32,
1686 <___T as ::fidl_next::Transport>::SendBuffer,
1687 >,
1688 ) -> ::fidl_next::TwoWayFuture<'_, super::Divide, ___T>
1689 where
1690 <___T as ::fidl_next::Transport>::SendBuffer:
1691 ::fidl_next::encoder::InternalHandleEncoder,
1692 {
1693 self.divide_with(crate::generic::CalculatorDivideRequest { dividend, divisor })
1694 }
1695
1696 pub fn divide_with<___R>(
1697 &self,
1698 request: ___R,
1699 ) -> ::fidl_next::TwoWayFuture<'_, super::Divide, ___T>
1700 where
1701 ___R: ::fidl_next::Encode<
1702 crate::wire::CalculatorDivideRequest,
1703 <___T as ::fidl_next::Transport>::SendBuffer,
1704 >,
1705 {
1706 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
1707 5497947425807432439,
1708 <super::Divide as ::fidl_next::Method>::FLEXIBILITY,
1709 request,
1710 ))
1711 }
1712
1713 pub fn clear(&self) -> ::fidl_next::SendFuture<'_, ___T> {
1714 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
1715 7439411180362570889,
1716 <super::Clear as ::fidl_next::Method>::FLEXIBILITY,
1717 (),
1718 ))
1719 }
1720 }
1721
1722 #[repr(transparent)]
1724 pub struct CalculatorServer<___T: ::fidl_next::Transport> {
1725 server: ::fidl_next::protocol::Server<___T>,
1726 }
1727
1728 impl<___T> CalculatorServer<___T>
1729 where
1730 ___T: ::fidl_next::Transport,
1731 {
1732 pub fn on_error(
1733 &self,
1734
1735 status_code: impl ::fidl_next::Encode<
1736 ::fidl_next::WireU32,
1737 <___T as ::fidl_next::Transport>::SendBuffer,
1738 >,
1739 ) -> ::fidl_next::SendFuture<'_, ___T>
1740 where
1741 <___T as ::fidl_next::Transport>::SendBuffer:
1742 ::fidl_next::encoder::InternalHandleEncoder,
1743 {
1744 self.on_error_with(crate::generic::CalculatorOnErrorRequest { status_code })
1745 }
1746
1747 pub fn on_error_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
1748 where
1749 ___R: ::fidl_next::Encode<
1750 <super::OnError as ::fidl_next::Method>::Request,
1751 <___T as ::fidl_next::Transport>::SendBuffer,
1752 >,
1753 {
1754 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
1755 8940578522385404924,
1756 <super::OnError as ::fidl_next::Method>::FLEXIBILITY,
1757 request,
1758 ))
1759 }
1760 }
1761 }
1762}
1763
1764pub trait CalculatorClientHandler<
1768 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1769 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1770>
1771{
1772 fn on_error(
1773 &mut self,
1774
1775 request: ::fidl_next::Request<calculator::OnError, ___T>,
1776 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1777
1778 fn on_unknown_interaction(
1779 &mut self,
1780 ordinal: u64,
1781 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
1782 ::core::future::ready(())
1783 }
1784}
1785
1786impl<___T> CalculatorClientHandler<___T> for ::fidl_next::IgnoreEvents
1787where
1788 ___T: ::fidl_next::Transport,
1789{
1790 async fn on_error(&mut self, _: ::fidl_next::Request<calculator::OnError, ___T>) {}
1791
1792 async fn on_unknown_interaction(&mut self, _: u64) {}
1793}
1794
1795impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Calculator
1796where
1797 ___H: CalculatorClientHandler<___T> + ::core::marker::Send,
1798 ___T: ::fidl_next::Transport,
1799 <calculator::OnError as ::fidl_next::Method>::Request:
1800 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1801{
1802 async fn on_event(
1803 handler: &mut ___H,
1804 ordinal: u64,
1805 flexibility: ::fidl_next::protocol::Flexibility,
1806 buffer: ___T::RecvBuffer,
1807 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
1808 match ordinal {
1809 8940578522385404924 => match ::fidl_next::DecoderExt::decode(buffer) {
1810 Ok(decoded) => {
1811 handler.on_error(::fidl_next::Request::from_decoded(decoded)).await;
1812 Ok(())
1813 }
1814 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1815 ordinal: 8940578522385404924,
1816 error,
1817 }),
1818 },
1819
1820 ordinal => {
1821 handler.on_unknown_interaction(ordinal).await;
1822 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
1823 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1824 } else {
1825 Ok(())
1826 }
1827 }
1828 }
1829 }
1830}
1831
1832pub trait CalculatorServerHandler<
1836 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
1837 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
1838>
1839{
1840 fn add(
1841 &mut self,
1842
1843 request: ::fidl_next::Request<calculator::Add, ___T>,
1844
1845 responder: ::fidl_next::Responder<calculator::Add, ___T>,
1846 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1847
1848 fn divide(
1849 &mut self,
1850
1851 request: ::fidl_next::Request<calculator::Divide, ___T>,
1852
1853 responder: ::fidl_next::Responder<calculator::Divide, ___T>,
1854 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1855
1856 fn clear(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
1857
1858 fn on_unknown_interaction(
1859 &mut self,
1860 ordinal: u64,
1861 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
1862 ::core::future::ready(())
1863 }
1864}
1865
1866impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Calculator
1867where
1868 ___H: CalculatorServerHandler<___T> + ::core::marker::Send,
1869 ___T: ::fidl_next::Transport,
1870 <calculator::Add as ::fidl_next::Method>::Request:
1871 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1872 <calculator::Divide as ::fidl_next::Method>::Request:
1873 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
1874{
1875 async fn on_one_way(
1876 handler: &mut ___H,
1877 ordinal: u64,
1878 flexibility: ::fidl_next::protocol::Flexibility,
1879 buffer: ___T::RecvBuffer,
1880 ) -> ::core::result::Result<
1881 (),
1882 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1883 > {
1884 match ordinal {
1885 7439411180362570889 => {
1886 handler.clear().await;
1887 Ok(())
1888 }
1889
1890 ordinal => {
1891 handler.on_unknown_interaction(ordinal).await;
1892 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
1893 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1894 } else {
1895 Ok(())
1896 }
1897 }
1898 }
1899 }
1900
1901 async fn on_two_way(
1902 handler: &mut ___H,
1903 ordinal: u64,
1904 flexibility: ::fidl_next::protocol::Flexibility,
1905 buffer: ___T::RecvBuffer,
1906 responder: ::fidl_next::protocol::Responder<___T>,
1907 ) -> ::core::result::Result<
1908 (),
1909 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
1910 > {
1911 match ordinal {
1912 8640324702111165953 => {
1913 let responder = ::fidl_next::Responder::from_untyped(responder);
1914
1915 match ::fidl_next::DecoderExt::decode(buffer) {
1916 Ok(decoded) => {
1917 handler.add(::fidl_next::Request::from_decoded(decoded), responder).await;
1918 Ok(())
1919 }
1920 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1921 ordinal: 8640324702111165953,
1922 error,
1923 }),
1924 }
1925 }
1926
1927 5497947425807432439 => {
1928 let responder = ::fidl_next::Responder::from_untyped(responder);
1929
1930 match ::fidl_next::DecoderExt::decode(buffer) {
1931 Ok(decoded) => {
1932 handler
1933 .divide(::fidl_next::Request::from_decoded(decoded), responder)
1934 .await;
1935 Ok(())
1936 }
1937 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
1938 ordinal: 5497947425807432439,
1939 error,
1940 }),
1941 }
1942 }
1943
1944 ordinal => {
1945 handler.on_unknown_interaction(ordinal).await;
1946 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
1947 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
1948 } else {
1949 responder
1950 .respond(
1951 ordinal,
1952 flexibility,
1953 ::fidl_next::Flexible::<()>::FrameworkErr(
1954 ::fidl_next::FrameworkError::UnknownMethod,
1955 ),
1956 )
1957 .expect("encoding a framework error should never fail")
1958 .await?;
1959 Ok(())
1960 }
1961 }
1962 }
1963 }
1964}
1965
1966pub mod compat {
1968
1969 impl ::fidl_next::CompatFrom<crate::CalculatorAddRequest>
1970 for ::fidl_examples_calculator::CalculatorAddRequest
1971 {
1972 #[inline]
1973 fn compat_from(value: crate::CalculatorAddRequest) -> Self {
1974 Self {
1975 a: ::fidl_next::CompatFrom::compat_from(value.a),
1976
1977 b: ::fidl_next::CompatFrom::compat_from(value.b),
1978 }
1979 }
1980 }
1981
1982 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::CalculatorAddRequest>
1983 for crate::CalculatorAddRequest
1984 {
1985 #[inline]
1986 fn compat_from(value: ::fidl_examples_calculator::CalculatorAddRequest) -> Self {
1987 Self {
1988 a: ::fidl_next::CompatFrom::compat_from(value.a),
1989
1990 b: ::fidl_next::CompatFrom::compat_from(value.b),
1991 }
1992 }
1993 }
1994
1995 impl ::fidl_next::CompatFrom<crate::CalculatorAddResponse>
1996 for ::fidl_examples_calculator::CalculatorAddResponse
1997 {
1998 #[inline]
1999 fn compat_from(value: crate::CalculatorAddResponse) -> Self {
2000 Self { sum: ::fidl_next::CompatFrom::compat_from(value.sum) }
2001 }
2002 }
2003
2004 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::CalculatorAddResponse>
2005 for crate::CalculatorAddResponse
2006 {
2007 #[inline]
2008 fn compat_from(value: ::fidl_examples_calculator::CalculatorAddResponse) -> Self {
2009 Self { sum: ::fidl_next::CompatFrom::compat_from(value.sum) }
2010 }
2011 }
2012
2013 impl ::fidl_next::CompatFrom<crate::CalculatorDivideRequest>
2014 for ::fidl_examples_calculator::CalculatorDivideRequest
2015 {
2016 #[inline]
2017 fn compat_from(value: crate::CalculatorDivideRequest) -> Self {
2018 Self {
2019 dividend: ::fidl_next::CompatFrom::compat_from(value.dividend),
2020
2021 divisor: ::fidl_next::CompatFrom::compat_from(value.divisor),
2022 }
2023 }
2024 }
2025
2026 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::CalculatorDivideRequest>
2027 for crate::CalculatorDivideRequest
2028 {
2029 #[inline]
2030 fn compat_from(value: ::fidl_examples_calculator::CalculatorDivideRequest) -> Self {
2031 Self {
2032 dividend: ::fidl_next::CompatFrom::compat_from(value.dividend),
2033
2034 divisor: ::fidl_next::CompatFrom::compat_from(value.divisor),
2035 }
2036 }
2037 }
2038
2039 impl ::fidl_next::CompatFrom<crate::CalculatorDivideResponse>
2040 for ::fidl_examples_calculator::CalculatorDivideResponse
2041 {
2042 #[inline]
2043 fn compat_from(value: crate::CalculatorDivideResponse) -> Self {
2044 Self {
2045 quotient: ::fidl_next::CompatFrom::compat_from(value.quotient),
2046
2047 remainder: ::fidl_next::CompatFrom::compat_from(value.remainder),
2048 }
2049 }
2050 }
2051
2052 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::CalculatorDivideResponse>
2053 for crate::CalculatorDivideResponse
2054 {
2055 #[inline]
2056 fn compat_from(value: ::fidl_examples_calculator::CalculatorDivideResponse) -> Self {
2057 Self {
2058 quotient: ::fidl_next::CompatFrom::compat_from(value.quotient),
2059
2060 remainder: ::fidl_next::CompatFrom::compat_from(value.remainder),
2061 }
2062 }
2063 }
2064
2065 impl ::fidl_next::CompatFrom<crate::DivisionError> for ::fidl_examples_calculator::DivisionError {
2066 fn compat_from(value: crate::DivisionError) -> Self {
2067 match value {
2068 crate::DivisionError::DivideByZero => Self::DivideByZero,
2069 }
2070 }
2071 }
2072
2073 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::DivisionError> for crate::DivisionError {
2074 fn compat_from(value: ::fidl_examples_calculator::DivisionError) -> Self {
2075 match value {
2076 ::fidl_examples_calculator::DivisionError::DivideByZero => Self::DivideByZero,
2077 }
2078 }
2079 }
2080
2081 impl ::fidl_next::CompatFrom<crate::CalculatorOnErrorRequest>
2082 for ::fidl_examples_calculator::CalculatorOnErrorRequest
2083 {
2084 #[inline]
2085 fn compat_from(value: crate::CalculatorOnErrorRequest) -> Self {
2086 Self { status_code: ::fidl_next::CompatFrom::compat_from(value.status_code) }
2087 }
2088 }
2089
2090 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::CalculatorOnErrorRequest>
2091 for crate::CalculatorOnErrorRequest
2092 {
2093 #[inline]
2094 fn compat_from(value: ::fidl_examples_calculator::CalculatorOnErrorRequest) -> Self {
2095 Self { status_code: ::fidl_next::CompatFrom::compat_from(value.status_code) }
2096 }
2097 }
2098
2099 #[cfg(target_os = "fuchsia")]
2100 pub type CalculatorProxy = ::fidl_next::Client<crate::Calculator>;
2103
2104 impl ::fidl_next::CompatFrom<crate::Calculator> for ::fidl_examples_calculator::CalculatorMarker {
2105 fn compat_from(_: crate::Calculator) -> Self {
2106 Self
2107 }
2108 }
2109
2110 impl ::fidl_next::CompatFrom<::fidl_examples_calculator::CalculatorMarker> for crate::Calculator {
2111 fn compat_from(_: ::fidl_examples_calculator::CalculatorMarker) -> Self {
2112 Self
2113 }
2114 }
2115
2116 #[cfg(target_os = "fuchsia")]
2117
2118 impl ::fidl_next::ClientCompatFrom<::fidl_examples_calculator::CalculatorProxy>
2119 for crate::Calculator
2120 {
2121 fn client_compat_from(
2122 proxy: ::fidl_examples_calculator::CalculatorProxy,
2123 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
2124 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
2125 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
2126 ::fidl_next::ClientDispatcher::new(client_end)
2127 }
2128 }
2129}