1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_examples_calculator__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct CalculatorMarker;
16
17impl fidl::endpoints::ProtocolMarker for CalculatorMarker {
18 type Proxy = CalculatorProxy;
19 type RequestStream = CalculatorRequestStream;
20 #[cfg(target_os = "fuchsia")]
21 type SynchronousProxy = CalculatorSynchronousProxy;
22
23 const DEBUG_NAME: &'static str = "(anonymous) Calculator";
24}
25pub type CalculatorDivideResult = Result<(i32, i32), DivisionError>;
26
27pub trait CalculatorProxyInterface: Send + Sync {
28 type AddResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
29 fn r#add(&self, a: i32, b: i32) -> Self::AddResponseFut;
30 type DivideResponseFut: std::future::Future<Output = Result<CalculatorDivideResult, fidl::Error>>
31 + Send;
32 fn r#divide(&self, dividend: i32, divisor: i32) -> Self::DivideResponseFut;
33 fn r#clear(&self) -> Result<(), fidl::Error>;
34}
35#[derive(Debug)]
36#[cfg(target_os = "fuchsia")]
37pub struct CalculatorSynchronousProxy {
38 client: fidl::client::sync::Client,
39}
40
41#[cfg(target_os = "fuchsia")]
42impl fidl::endpoints::SynchronousProxy for CalculatorSynchronousProxy {
43 type Proxy = CalculatorProxy;
44 type Protocol = CalculatorMarker;
45
46 fn from_channel(inner: fidl::Channel) -> Self {
47 Self::new(inner)
48 }
49
50 fn into_channel(self) -> fidl::Channel {
51 self.client.into_channel()
52 }
53
54 fn as_channel(&self) -> &fidl::Channel {
55 self.client.as_channel()
56 }
57}
58
59#[cfg(target_os = "fuchsia")]
60impl CalculatorSynchronousProxy {
61 pub fn new(channel: fidl::Channel) -> Self {
62 let protocol_name = <CalculatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
63 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
64 }
65
66 pub fn into_channel(self) -> fidl::Channel {
67 self.client.into_channel()
68 }
69
70 pub fn wait_for_event(
73 &self,
74 deadline: zx::MonotonicInstant,
75 ) -> Result<CalculatorEvent, fidl::Error> {
76 CalculatorEvent::decode(self.client.wait_for_event(deadline)?)
77 }
78
79 pub fn r#add(
80 &self,
81 mut a: i32,
82 mut b: i32,
83 ___deadline: zx::MonotonicInstant,
84 ) -> Result<i32, fidl::Error> {
85 let _response = self.client.send_query::<
86 CalculatorAddRequest,
87 fidl::encoding::FlexibleType<CalculatorAddResponse>,
88 >(
89 (a, b,),
90 0x77e89989c55e6e01,
91 fidl::encoding::DynamicFlags::FLEXIBLE,
92 ___deadline,
93 )?
94 .into_result::<CalculatorMarker>("add")?;
95 Ok(_response.sum)
96 }
97
98 pub fn r#divide(
99 &self,
100 mut dividend: i32,
101 mut divisor: i32,
102 ___deadline: zx::MonotonicInstant,
103 ) -> Result<CalculatorDivideResult, fidl::Error> {
104 let _response = self.client.send_query::<
105 CalculatorDivideRequest,
106 fidl::encoding::FlexibleResultType<CalculatorDivideResponse, DivisionError>,
107 >(
108 (dividend, divisor,),
109 0x4c4ca20ded067af7,
110 fidl::encoding::DynamicFlags::FLEXIBLE,
111 ___deadline,
112 )?
113 .into_result::<CalculatorMarker>("divide")?;
114 Ok(_response.map(|x| (x.quotient, x.remainder)))
115 }
116
117 pub fn r#clear(&self) -> Result<(), fidl::Error> {
118 self.client.send::<fidl::encoding::EmptyPayload>(
119 (),
120 0x673e190d87949c89,
121 fidl::encoding::DynamicFlags::FLEXIBLE,
122 )
123 }
124}
125
126#[cfg(target_os = "fuchsia")]
127impl From<CalculatorSynchronousProxy> for zx::Handle {
128 fn from(value: CalculatorSynchronousProxy) -> Self {
129 value.into_channel().into()
130 }
131}
132
133#[cfg(target_os = "fuchsia")]
134impl From<fidl::Channel> for CalculatorSynchronousProxy {
135 fn from(value: fidl::Channel) -> Self {
136 Self::new(value)
137 }
138}
139
140#[cfg(target_os = "fuchsia")]
141impl fidl::endpoints::FromClient for CalculatorSynchronousProxy {
142 type Protocol = CalculatorMarker;
143
144 fn from_client(value: fidl::endpoints::ClientEnd<CalculatorMarker>) -> Self {
145 Self::new(value.into_channel())
146 }
147}
148
149#[derive(Debug, Clone)]
150pub struct CalculatorProxy {
151 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
152}
153
154impl fidl::endpoints::Proxy for CalculatorProxy {
155 type Protocol = CalculatorMarker;
156
157 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
158 Self::new(inner)
159 }
160
161 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
162 self.client.into_channel().map_err(|client| Self { client })
163 }
164
165 fn as_channel(&self) -> &::fidl::AsyncChannel {
166 self.client.as_channel()
167 }
168}
169
170impl CalculatorProxy {
171 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
173 let protocol_name = <CalculatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
174 Self { client: fidl::client::Client::new(channel, protocol_name) }
175 }
176
177 pub fn take_event_stream(&self) -> CalculatorEventStream {
183 CalculatorEventStream { event_receiver: self.client.take_event_receiver() }
184 }
185
186 pub fn r#add(
187 &self,
188 mut a: i32,
189 mut b: i32,
190 ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
191 CalculatorProxyInterface::r#add(self, a, b)
192 }
193
194 pub fn r#divide(
195 &self,
196 mut dividend: i32,
197 mut divisor: i32,
198 ) -> fidl::client::QueryResponseFut<
199 CalculatorDivideResult,
200 fidl::encoding::DefaultFuchsiaResourceDialect,
201 > {
202 CalculatorProxyInterface::r#divide(self, dividend, divisor)
203 }
204
205 pub fn r#clear(&self) -> Result<(), fidl::Error> {
206 CalculatorProxyInterface::r#clear(self)
207 }
208}
209
210impl CalculatorProxyInterface for CalculatorProxy {
211 type AddResponseFut =
212 fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
213 fn r#add(&self, mut a: i32, mut b: i32) -> Self::AddResponseFut {
214 fn _decode(
215 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
216 ) -> Result<i32, fidl::Error> {
217 let _response = fidl::client::decode_transaction_body::<
218 fidl::encoding::FlexibleType<CalculatorAddResponse>,
219 fidl::encoding::DefaultFuchsiaResourceDialect,
220 0x77e89989c55e6e01,
221 >(_buf?)?
222 .into_result::<CalculatorMarker>("add")?;
223 Ok(_response.sum)
224 }
225 self.client.send_query_and_decode::<CalculatorAddRequest, i32>(
226 (a, b),
227 0x77e89989c55e6e01,
228 fidl::encoding::DynamicFlags::FLEXIBLE,
229 _decode,
230 )
231 }
232
233 type DivideResponseFut = fidl::client::QueryResponseFut<
234 CalculatorDivideResult,
235 fidl::encoding::DefaultFuchsiaResourceDialect,
236 >;
237 fn r#divide(&self, mut dividend: i32, mut divisor: i32) -> Self::DivideResponseFut {
238 fn _decode(
239 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
240 ) -> Result<CalculatorDivideResult, fidl::Error> {
241 let _response = fidl::client::decode_transaction_body::<
242 fidl::encoding::FlexibleResultType<CalculatorDivideResponse, DivisionError>,
243 fidl::encoding::DefaultFuchsiaResourceDialect,
244 0x4c4ca20ded067af7,
245 >(_buf?)?
246 .into_result::<CalculatorMarker>("divide")?;
247 Ok(_response.map(|x| (x.quotient, x.remainder)))
248 }
249 self.client.send_query_and_decode::<CalculatorDivideRequest, CalculatorDivideResult>(
250 (dividend, divisor),
251 0x4c4ca20ded067af7,
252 fidl::encoding::DynamicFlags::FLEXIBLE,
253 _decode,
254 )
255 }
256
257 fn r#clear(&self) -> Result<(), fidl::Error> {
258 self.client.send::<fidl::encoding::EmptyPayload>(
259 (),
260 0x673e190d87949c89,
261 fidl::encoding::DynamicFlags::FLEXIBLE,
262 )
263 }
264}
265
266pub struct CalculatorEventStream {
267 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
268}
269
270impl std::marker::Unpin for CalculatorEventStream {}
271
272impl futures::stream::FusedStream for CalculatorEventStream {
273 fn is_terminated(&self) -> bool {
274 self.event_receiver.is_terminated()
275 }
276}
277
278impl futures::Stream for CalculatorEventStream {
279 type Item = Result<CalculatorEvent, fidl::Error>;
280
281 fn poll_next(
282 mut self: std::pin::Pin<&mut Self>,
283 cx: &mut std::task::Context<'_>,
284 ) -> std::task::Poll<Option<Self::Item>> {
285 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
286 &mut self.event_receiver,
287 cx
288 )?) {
289 Some(buf) => std::task::Poll::Ready(Some(CalculatorEvent::decode(buf))),
290 None => std::task::Poll::Ready(None),
291 }
292 }
293}
294
295#[derive(Debug)]
296pub enum CalculatorEvent {
297 OnError {
298 status_code: u32,
299 },
300 #[non_exhaustive]
301 _UnknownEvent {
302 ordinal: u64,
304 },
305}
306
307impl CalculatorEvent {
308 #[allow(irrefutable_let_patterns)]
309 pub fn into_on_error(self) -> Option<u32> {
310 if let CalculatorEvent::OnError { status_code } = self {
311 Some((status_code))
312 } else {
313 None
314 }
315 }
316
317 fn decode(
319 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
320 ) -> Result<CalculatorEvent, fidl::Error> {
321 let (bytes, _handles) = buf.split_mut();
322 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
323 debug_assert_eq!(tx_header.tx_id, 0);
324 match tx_header.ordinal {
325 0x7c1350cc0144d3fc => {
326 let mut out = fidl::new_empty!(
327 CalculatorOnErrorRequest,
328 fidl::encoding::DefaultFuchsiaResourceDialect
329 );
330 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CalculatorOnErrorRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
331 Ok((CalculatorEvent::OnError { status_code: out.status_code }))
332 }
333 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
334 Ok(CalculatorEvent::_UnknownEvent { ordinal: tx_header.ordinal })
335 }
336 _ => Err(fidl::Error::UnknownOrdinal {
337 ordinal: tx_header.ordinal,
338 protocol_name: <CalculatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
339 }),
340 }
341 }
342}
343
344pub struct CalculatorRequestStream {
346 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
347 is_terminated: bool,
348}
349
350impl std::marker::Unpin for CalculatorRequestStream {}
351
352impl futures::stream::FusedStream for CalculatorRequestStream {
353 fn is_terminated(&self) -> bool {
354 self.is_terminated
355 }
356}
357
358impl fidl::endpoints::RequestStream for CalculatorRequestStream {
359 type Protocol = CalculatorMarker;
360 type ControlHandle = CalculatorControlHandle;
361
362 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
363 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
364 }
365
366 fn control_handle(&self) -> Self::ControlHandle {
367 CalculatorControlHandle { inner: self.inner.clone() }
368 }
369
370 fn into_inner(
371 self,
372 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
373 {
374 (self.inner, self.is_terminated)
375 }
376
377 fn from_inner(
378 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
379 is_terminated: bool,
380 ) -> Self {
381 Self { inner, is_terminated }
382 }
383}
384
385impl futures::Stream for CalculatorRequestStream {
386 type Item = Result<CalculatorRequest, fidl::Error>;
387
388 fn poll_next(
389 mut self: std::pin::Pin<&mut Self>,
390 cx: &mut std::task::Context<'_>,
391 ) -> std::task::Poll<Option<Self::Item>> {
392 let this = &mut *self;
393 if this.inner.check_shutdown(cx) {
394 this.is_terminated = true;
395 return std::task::Poll::Ready(None);
396 }
397 if this.is_terminated {
398 panic!("polled CalculatorRequestStream after completion");
399 }
400 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
401 |bytes, handles| {
402 match this.inner.channel().read_etc(cx, bytes, handles) {
403 std::task::Poll::Ready(Ok(())) => {}
404 std::task::Poll::Pending => return std::task::Poll::Pending,
405 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
406 this.is_terminated = true;
407 return std::task::Poll::Ready(None);
408 }
409 std::task::Poll::Ready(Err(e)) => {
410 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
411 e.into(),
412 ))))
413 }
414 }
415
416 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
418
419 std::task::Poll::Ready(Some(match header.ordinal {
420 0x77e89989c55e6e01 => {
421 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
422 let mut req = fidl::new_empty!(
423 CalculatorAddRequest,
424 fidl::encoding::DefaultFuchsiaResourceDialect
425 );
426 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CalculatorAddRequest>(&header, _body_bytes, handles, &mut req)?;
427 let control_handle = CalculatorControlHandle { inner: this.inner.clone() };
428 Ok(CalculatorRequest::Add {
429 a: req.a,
430 b: req.b,
431
432 responder: CalculatorAddResponder {
433 control_handle: std::mem::ManuallyDrop::new(control_handle),
434 tx_id: header.tx_id,
435 },
436 })
437 }
438 0x4c4ca20ded067af7 => {
439 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
440 let mut req = fidl::new_empty!(
441 CalculatorDivideRequest,
442 fidl::encoding::DefaultFuchsiaResourceDialect
443 );
444 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CalculatorDivideRequest>(&header, _body_bytes, handles, &mut req)?;
445 let control_handle = CalculatorControlHandle { inner: this.inner.clone() };
446 Ok(CalculatorRequest::Divide {
447 dividend: req.dividend,
448 divisor: req.divisor,
449
450 responder: CalculatorDivideResponder {
451 control_handle: std::mem::ManuallyDrop::new(control_handle),
452 tx_id: header.tx_id,
453 },
454 })
455 }
456 0x673e190d87949c89 => {
457 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
458 let mut req = fidl::new_empty!(
459 fidl::encoding::EmptyPayload,
460 fidl::encoding::DefaultFuchsiaResourceDialect
461 );
462 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
463 let control_handle = CalculatorControlHandle { inner: this.inner.clone() };
464 Ok(CalculatorRequest::Clear { control_handle })
465 }
466 _ if header.tx_id == 0
467 && header
468 .dynamic_flags()
469 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
470 {
471 Ok(CalculatorRequest::_UnknownMethod {
472 ordinal: header.ordinal,
473 control_handle: CalculatorControlHandle { inner: this.inner.clone() },
474 method_type: fidl::MethodType::OneWay,
475 })
476 }
477 _ if header
478 .dynamic_flags()
479 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
480 {
481 this.inner.send_framework_err(
482 fidl::encoding::FrameworkErr::UnknownMethod,
483 header.tx_id,
484 header.ordinal,
485 header.dynamic_flags(),
486 (bytes, handles),
487 )?;
488 Ok(CalculatorRequest::_UnknownMethod {
489 ordinal: header.ordinal,
490 control_handle: CalculatorControlHandle { inner: this.inner.clone() },
491 method_type: fidl::MethodType::TwoWay,
492 })
493 }
494 _ => Err(fidl::Error::UnknownOrdinal {
495 ordinal: header.ordinal,
496 protocol_name:
497 <CalculatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
498 }),
499 }))
500 },
501 )
502 }
503}
504
505#[derive(Debug)]
506pub enum CalculatorRequest {
507 Add {
508 a: i32,
509 b: i32,
510 responder: CalculatorAddResponder,
511 },
512 Divide {
513 dividend: i32,
514 divisor: i32,
515 responder: CalculatorDivideResponder,
516 },
517 Clear {
518 control_handle: CalculatorControlHandle,
519 },
520 #[non_exhaustive]
522 _UnknownMethod {
523 ordinal: u64,
525 control_handle: CalculatorControlHandle,
526 method_type: fidl::MethodType,
527 },
528}
529
530impl CalculatorRequest {
531 #[allow(irrefutable_let_patterns)]
532 pub fn into_add(self) -> Option<(i32, i32, CalculatorAddResponder)> {
533 if let CalculatorRequest::Add { a, b, responder } = self {
534 Some((a, b, responder))
535 } else {
536 None
537 }
538 }
539
540 #[allow(irrefutable_let_patterns)]
541 pub fn into_divide(self) -> Option<(i32, i32, CalculatorDivideResponder)> {
542 if let CalculatorRequest::Divide { dividend, divisor, responder } = self {
543 Some((dividend, divisor, responder))
544 } else {
545 None
546 }
547 }
548
549 #[allow(irrefutable_let_patterns)]
550 pub fn into_clear(self) -> Option<(CalculatorControlHandle)> {
551 if let CalculatorRequest::Clear { control_handle } = self {
552 Some((control_handle))
553 } else {
554 None
555 }
556 }
557
558 pub fn method_name(&self) -> &'static str {
560 match *self {
561 CalculatorRequest::Add { .. } => "add",
562 CalculatorRequest::Divide { .. } => "divide",
563 CalculatorRequest::Clear { .. } => "clear",
564 CalculatorRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
565 "unknown one-way method"
566 }
567 CalculatorRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
568 "unknown two-way method"
569 }
570 }
571 }
572}
573
574#[derive(Debug, Clone)]
575pub struct CalculatorControlHandle {
576 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
577}
578
579impl fidl::endpoints::ControlHandle for CalculatorControlHandle {
580 fn shutdown(&self) {
581 self.inner.shutdown()
582 }
583 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
584 self.inner.shutdown_with_epitaph(status)
585 }
586
587 fn is_closed(&self) -> bool {
588 self.inner.channel().is_closed()
589 }
590 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
591 self.inner.channel().on_closed()
592 }
593
594 #[cfg(target_os = "fuchsia")]
595 fn signal_peer(
596 &self,
597 clear_mask: zx::Signals,
598 set_mask: zx::Signals,
599 ) -> Result<(), zx_status::Status> {
600 use fidl::Peered;
601 self.inner.channel().signal_peer(clear_mask, set_mask)
602 }
603}
604
605impl CalculatorControlHandle {
606 pub fn send_on_error(&self, mut status_code: u32) -> Result<(), fidl::Error> {
607 self.inner.send::<CalculatorOnErrorRequest>(
608 (status_code,),
609 0,
610 0x7c1350cc0144d3fc,
611 fidl::encoding::DynamicFlags::FLEXIBLE,
612 )
613 }
614}
615
616#[must_use = "FIDL methods require a response to be sent"]
617#[derive(Debug)]
618pub struct CalculatorAddResponder {
619 control_handle: std::mem::ManuallyDrop<CalculatorControlHandle>,
620 tx_id: u32,
621}
622
623impl std::ops::Drop for CalculatorAddResponder {
627 fn drop(&mut self) {
628 self.control_handle.shutdown();
629 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
631 }
632}
633
634impl fidl::endpoints::Responder for CalculatorAddResponder {
635 type ControlHandle = CalculatorControlHandle;
636
637 fn control_handle(&self) -> &CalculatorControlHandle {
638 &self.control_handle
639 }
640
641 fn drop_without_shutdown(mut self) {
642 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
644 std::mem::forget(self);
646 }
647}
648
649impl CalculatorAddResponder {
650 pub fn send(self, mut sum: i32) -> Result<(), fidl::Error> {
654 let _result = self.send_raw(sum);
655 if _result.is_err() {
656 self.control_handle.shutdown();
657 }
658 self.drop_without_shutdown();
659 _result
660 }
661
662 pub fn send_no_shutdown_on_err(self, mut sum: i32) -> Result<(), fidl::Error> {
664 let _result = self.send_raw(sum);
665 self.drop_without_shutdown();
666 _result
667 }
668
669 fn send_raw(&self, mut sum: i32) -> Result<(), fidl::Error> {
670 self.control_handle.inner.send::<fidl::encoding::FlexibleType<CalculatorAddResponse>>(
671 fidl::encoding::Flexible::new((sum,)),
672 self.tx_id,
673 0x77e89989c55e6e01,
674 fidl::encoding::DynamicFlags::FLEXIBLE,
675 )
676 }
677}
678
679#[must_use = "FIDL methods require a response to be sent"]
680#[derive(Debug)]
681pub struct CalculatorDivideResponder {
682 control_handle: std::mem::ManuallyDrop<CalculatorControlHandle>,
683 tx_id: u32,
684}
685
686impl std::ops::Drop for CalculatorDivideResponder {
690 fn drop(&mut self) {
691 self.control_handle.shutdown();
692 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
694 }
695}
696
697impl fidl::endpoints::Responder for CalculatorDivideResponder {
698 type ControlHandle = CalculatorControlHandle;
699
700 fn control_handle(&self) -> &CalculatorControlHandle {
701 &self.control_handle
702 }
703
704 fn drop_without_shutdown(mut self) {
705 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
707 std::mem::forget(self);
709 }
710}
711
712impl CalculatorDivideResponder {
713 pub fn send(self, mut result: Result<(i32, i32), DivisionError>) -> Result<(), fidl::Error> {
717 let _result = self.send_raw(result);
718 if _result.is_err() {
719 self.control_handle.shutdown();
720 }
721 self.drop_without_shutdown();
722 _result
723 }
724
725 pub fn send_no_shutdown_on_err(
727 self,
728 mut result: Result<(i32, i32), DivisionError>,
729 ) -> Result<(), fidl::Error> {
730 let _result = self.send_raw(result);
731 self.drop_without_shutdown();
732 _result
733 }
734
735 fn send_raw(&self, mut result: Result<(i32, i32), DivisionError>) -> Result<(), fidl::Error> {
736 self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
737 CalculatorDivideResponse,
738 DivisionError,
739 >>(
740 fidl::encoding::FlexibleResult::new(result),
741 self.tx_id,
742 0x4c4ca20ded067af7,
743 fidl::encoding::DynamicFlags::FLEXIBLE,
744 )
745 }
746}
747
748mod internal {
749 use super::*;
750}