fidl_inspect_selfprofile_test/
fidl_inspect_selfprofile_test.rs

Help
1// WARNING: This file is machine generated by fidlgen.
2
3#![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_inspect_selfprofile_test_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct PuppetMarker;
16
17impl fidl::endpoints::ProtocolMarker for PuppetMarker {
18    type Proxy = PuppetProxy;
19    type RequestStream = PuppetRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = PuppetSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "inspect.selfprofile.test.Puppet";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for PuppetMarker {}
26
27pub trait PuppetProxyInterface: Send + Sync {
28    type StartProfilingResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
29    fn r#start_profiling(&self) -> Self::StartProfilingResponseFut;
30    type StopProfilingResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
31    fn r#stop_profiling(&self) -> Self::StopProfilingResponseFut;
32    type RunProfiledFunctionResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
33        + Send;
34    fn r#run_profiled_function(&self) -> Self::RunProfiledFunctionResponseFut;
35}
36#[derive(Debug)]
37#[cfg(target_os = "fuchsia")]
38pub struct PuppetSynchronousProxy {
39    client: fidl::client::sync::Client,
40}
41
42#[cfg(target_os = "fuchsia")]
43impl fidl::endpoints::SynchronousProxy for PuppetSynchronousProxy {
44    type Proxy = PuppetProxy;
45    type Protocol = PuppetMarker;
46
47    fn from_channel(inner: fidl::Channel) -> Self {
48        Self::new(inner)
49    }
50
51    fn into_channel(self) -> fidl::Channel {
52        self.client.into_channel()
53    }
54
55    fn as_channel(&self) -> &fidl::Channel {
56        self.client.as_channel()
57    }
58}
59
60#[cfg(target_os = "fuchsia")]
61impl PuppetSynchronousProxy {
62    pub fn new(channel: fidl::Channel) -> Self {
63        let protocol_name = <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
64        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
65    }
66
67    pub fn into_channel(self) -> fidl::Channel {
68        self.client.into_channel()
69    }
70
71    /// Waits until an event arrives and returns it. It is safe for other
72    /// threads to make concurrent requests while waiting for an event.
73    pub fn wait_for_event(
74        &self,
75        deadline: zx::MonotonicInstant,
76    ) -> Result<PuppetEvent, fidl::Error> {
77        PuppetEvent::decode(self.client.wait_for_event(deadline)?)
78    }
79
80    pub fn r#start_profiling(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
81        let _response =
82            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
83                (),
84                0x3fdf927c6e4c8c8d,
85                fidl::encoding::DynamicFlags::empty(),
86                ___deadline,
87            )?;
88        Ok(_response)
89    }
90
91    pub fn r#stop_profiling(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
92        let _response =
93            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
94                (),
95                0x23347e09827a7087,
96                fidl::encoding::DynamicFlags::empty(),
97                ___deadline,
98            )?;
99        Ok(_response)
100    }
101
102    pub fn r#run_profiled_function(
103        &self,
104        ___deadline: zx::MonotonicInstant,
105    ) -> Result<(), fidl::Error> {
106        let _response =
107            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
108                (),
109                0x679bdcc07c2f7065,
110                fidl::encoding::DynamicFlags::empty(),
111                ___deadline,
112            )?;
113        Ok(_response)
114    }
115}
116
117#[cfg(target_os = "fuchsia")]
118impl From<PuppetSynchronousProxy> for zx::Handle {
119    fn from(value: PuppetSynchronousProxy) -> Self {
120        value.into_channel().into()
121    }
122}
123
124#[cfg(target_os = "fuchsia")]
125impl From<fidl::Channel> for PuppetSynchronousProxy {
126    fn from(value: fidl::Channel) -> Self {
127        Self::new(value)
128    }
129}
130
131#[derive(Debug, Clone)]
132pub struct PuppetProxy {
133    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
134}
135
136impl fidl::endpoints::Proxy for PuppetProxy {
137    type Protocol = PuppetMarker;
138
139    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
140        Self::new(inner)
141    }
142
143    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
144        self.client.into_channel().map_err(|client| Self { client })
145    }
146
147    fn as_channel(&self) -> &::fidl::AsyncChannel {
148        self.client.as_channel()
149    }
150}
151
152impl PuppetProxy {
153    /// Create a new Proxy for inspect.selfprofile.test/Puppet.
154    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
155        let protocol_name = <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
156        Self { client: fidl::client::Client::new(channel, protocol_name) }
157    }
158
159    /// Get a Stream of events from the remote end of the protocol.
160    ///
161    /// # Panics
162    ///
163    /// Panics if the event stream was already taken.
164    pub fn take_event_stream(&self) -> PuppetEventStream {
165        PuppetEventStream { event_receiver: self.client.take_event_receiver() }
166    }
167
168    pub fn r#start_profiling(
169        &self,
170    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
171        PuppetProxyInterface::r#start_profiling(self)
172    }
173
174    pub fn r#stop_profiling(
175        &self,
176    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
177        PuppetProxyInterface::r#stop_profiling(self)
178    }
179
180    pub fn r#run_profiled_function(
181        &self,
182    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
183        PuppetProxyInterface::r#run_profiled_function(self)
184    }
185}
186
187impl PuppetProxyInterface for PuppetProxy {
188    type StartProfilingResponseFut =
189        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
190    fn r#start_profiling(&self) -> Self::StartProfilingResponseFut {
191        fn _decode(
192            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
193        ) -> Result<(), fidl::Error> {
194            let _response = fidl::client::decode_transaction_body::<
195                fidl::encoding::EmptyPayload,
196                fidl::encoding::DefaultFuchsiaResourceDialect,
197                0x3fdf927c6e4c8c8d,
198            >(_buf?)?;
199            Ok(_response)
200        }
201        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
202            (),
203            0x3fdf927c6e4c8c8d,
204            fidl::encoding::DynamicFlags::empty(),
205            _decode,
206        )
207    }
208
209    type StopProfilingResponseFut =
210        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
211    fn r#stop_profiling(&self) -> Self::StopProfilingResponseFut {
212        fn _decode(
213            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
214        ) -> Result<(), fidl::Error> {
215            let _response = fidl::client::decode_transaction_body::<
216                fidl::encoding::EmptyPayload,
217                fidl::encoding::DefaultFuchsiaResourceDialect,
218                0x23347e09827a7087,
219            >(_buf?)?;
220            Ok(_response)
221        }
222        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
223            (),
224            0x23347e09827a7087,
225            fidl::encoding::DynamicFlags::empty(),
226            _decode,
227        )
228    }
229
230    type RunProfiledFunctionResponseFut =
231        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
232    fn r#run_profiled_function(&self) -> Self::RunProfiledFunctionResponseFut {
233        fn _decode(
234            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
235        ) -> Result<(), fidl::Error> {
236            let _response = fidl::client::decode_transaction_body::<
237                fidl::encoding::EmptyPayload,
238                fidl::encoding::DefaultFuchsiaResourceDialect,
239                0x679bdcc07c2f7065,
240            >(_buf?)?;
241            Ok(_response)
242        }
243        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
244            (),
245            0x679bdcc07c2f7065,
246            fidl::encoding::DynamicFlags::empty(),
247            _decode,
248        )
249    }
250}
251
252pub struct PuppetEventStream {
253    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
254}
255
256impl std::marker::Unpin for PuppetEventStream {}
257
258impl futures::stream::FusedStream for PuppetEventStream {
259    fn is_terminated(&self) -> bool {
260        self.event_receiver.is_terminated()
261    }
262}
263
264impl futures::Stream for PuppetEventStream {
265    type Item = Result<PuppetEvent, fidl::Error>;
266
267    fn poll_next(
268        mut self: std::pin::Pin<&mut Self>,
269        cx: &mut std::task::Context<'_>,
270    ) -> std::task::Poll<Option<Self::Item>> {
271        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
272            &mut self.event_receiver,
273            cx
274        )?) {
275            Some(buf) => std::task::Poll::Ready(Some(PuppetEvent::decode(buf))),
276            None => std::task::Poll::Ready(None),
277        }
278    }
279}
280
281#[derive(Debug)]
282pub enum PuppetEvent {}
283
284impl PuppetEvent {
285    /// Decodes a message buffer as a [`PuppetEvent`].
286    fn decode(
287        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
288    ) -> Result<PuppetEvent, fidl::Error> {
289        let (bytes, _handles) = buf.split_mut();
290        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
291        debug_assert_eq!(tx_header.tx_id, 0);
292        match tx_header.ordinal {
293            _ => Err(fidl::Error::UnknownOrdinal {
294                ordinal: tx_header.ordinal,
295                protocol_name: <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
296            }),
297        }
298    }
299}
300
301/// A Stream of incoming requests for inspect.selfprofile.test/Puppet.
302pub struct PuppetRequestStream {
303    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
304    is_terminated: bool,
305}
306
307impl std::marker::Unpin for PuppetRequestStream {}
308
309impl futures::stream::FusedStream for PuppetRequestStream {
310    fn is_terminated(&self) -> bool {
311        self.is_terminated
312    }
313}
314
315impl fidl::endpoints::RequestStream for PuppetRequestStream {
316    type Protocol = PuppetMarker;
317    type ControlHandle = PuppetControlHandle;
318
319    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
320        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
321    }
322
323    fn control_handle(&self) -> Self::ControlHandle {
324        PuppetControlHandle { inner: self.inner.clone() }
325    }
326
327    fn into_inner(
328        self,
329    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
330    {
331        (self.inner, self.is_terminated)
332    }
333
334    fn from_inner(
335        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
336        is_terminated: bool,
337    ) -> Self {
338        Self { inner, is_terminated }
339    }
340}
341
342impl futures::Stream for PuppetRequestStream {
343    type Item = Result<PuppetRequest, fidl::Error>;
344
345    fn poll_next(
346        mut self: std::pin::Pin<&mut Self>,
347        cx: &mut std::task::Context<'_>,
348    ) -> std::task::Poll<Option<Self::Item>> {
349        let this = &mut *self;
350        if this.inner.check_shutdown(cx) {
351            this.is_terminated = true;
352            return std::task::Poll::Ready(None);
353        }
354        if this.is_terminated {
355            panic!("polled PuppetRequestStream after completion");
356        }
357        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
358            |bytes, handles| {
359                match this.inner.channel().read_etc(cx, bytes, handles) {
360                    std::task::Poll::Ready(Ok(())) => {}
361                    std::task::Poll::Pending => return std::task::Poll::Pending,
362                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
363                        this.is_terminated = true;
364                        return std::task::Poll::Ready(None);
365                    }
366                    std::task::Poll::Ready(Err(e)) => {
367                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
368                            e.into(),
369                        ))))
370                    }
371                }
372
373                // A message has been received from the channel
374                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
375
376                std::task::Poll::Ready(Some(match header.ordinal {
377                    0x3fdf927c6e4c8c8d => {
378                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
379                        let mut req = fidl::new_empty!(
380                            fidl::encoding::EmptyPayload,
381                            fidl::encoding::DefaultFuchsiaResourceDialect
382                        );
383                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
384                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
385                        Ok(PuppetRequest::StartProfiling {
386                            responder: PuppetStartProfilingResponder {
387                                control_handle: std::mem::ManuallyDrop::new(control_handle),
388                                tx_id: header.tx_id,
389                            },
390                        })
391                    }
392                    0x23347e09827a7087 => {
393                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
394                        let mut req = fidl::new_empty!(
395                            fidl::encoding::EmptyPayload,
396                            fidl::encoding::DefaultFuchsiaResourceDialect
397                        );
398                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
399                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
400                        Ok(PuppetRequest::StopProfiling {
401                            responder: PuppetStopProfilingResponder {
402                                control_handle: std::mem::ManuallyDrop::new(control_handle),
403                                tx_id: header.tx_id,
404                            },
405                        })
406                    }
407                    0x679bdcc07c2f7065 => {
408                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
409                        let mut req = fidl::new_empty!(
410                            fidl::encoding::EmptyPayload,
411                            fidl::encoding::DefaultFuchsiaResourceDialect
412                        );
413                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
414                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
415                        Ok(PuppetRequest::RunProfiledFunction {
416                            responder: PuppetRunProfiledFunctionResponder {
417                                control_handle: std::mem::ManuallyDrop::new(control_handle),
418                                tx_id: header.tx_id,
419                            },
420                        })
421                    }
422                    _ => Err(fidl::Error::UnknownOrdinal {
423                        ordinal: header.ordinal,
424                        protocol_name:
425                            <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
426                    }),
427                }))
428            },
429        )
430    }
431}
432
433#[derive(Debug)]
434pub enum PuppetRequest {
435    StartProfiling { responder: PuppetStartProfilingResponder },
436    StopProfiling { responder: PuppetStopProfilingResponder },
437    RunProfiledFunction { responder: PuppetRunProfiledFunctionResponder },
438}
439
440impl PuppetRequest {
441    #[allow(irrefutable_let_patterns)]
442    pub fn into_start_profiling(self) -> Option<(PuppetStartProfilingResponder)> {
443        if let PuppetRequest::StartProfiling { responder } = self {
444            Some((responder))
445        } else {
446            None
447        }
448    }
449
450    #[allow(irrefutable_let_patterns)]
451    pub fn into_stop_profiling(self) -> Option<(PuppetStopProfilingResponder)> {
452        if let PuppetRequest::StopProfiling { responder } = self {
453            Some((responder))
454        } else {
455            None
456        }
457    }
458
459    #[allow(irrefutable_let_patterns)]
460    pub fn into_run_profiled_function(self) -> Option<(PuppetRunProfiledFunctionResponder)> {
461        if let PuppetRequest::RunProfiledFunction { responder } = self {
462            Some((responder))
463        } else {
464            None
465        }
466    }
467
468    /// Name of the method defined in FIDL
469    pub fn method_name(&self) -> &'static str {
470        match *self {
471            PuppetRequest::StartProfiling { .. } => "start_profiling",
472            PuppetRequest::StopProfiling { .. } => "stop_profiling",
473            PuppetRequest::RunProfiledFunction { .. } => "run_profiled_function",
474        }
475    }
476}
477
478#[derive(Debug, Clone)]
479pub struct PuppetControlHandle {
480    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
481}
482
483impl fidl::endpoints::ControlHandle for PuppetControlHandle {
484    fn shutdown(&self) {
485        self.inner.shutdown()
486    }
487    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
488        self.inner.shutdown_with_epitaph(status)
489    }
490
491    fn is_closed(&self) -> bool {
492        self.inner.channel().is_closed()
493    }
494    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
495        self.inner.channel().on_closed()
496    }
497
498    #[cfg(target_os = "fuchsia")]
499    fn signal_peer(
500        &self,
501        clear_mask: zx::Signals,
502        set_mask: zx::Signals,
503    ) -> Result<(), zx_status::Status> {
504        use fidl::Peered;
505        self.inner.channel().signal_peer(clear_mask, set_mask)
506    }
507}
508
509impl PuppetControlHandle {}
510
511#[must_use = "FIDL methods require a response to be sent"]
512#[derive(Debug)]
513pub struct PuppetStartProfilingResponder {
514    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
515    tx_id: u32,
516}
517
518/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
519/// if the responder is dropped without sending a response, so that the client
520/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
521impl std::ops::Drop for PuppetStartProfilingResponder {
522    fn drop(&mut self) {
523        self.control_handle.shutdown();
524        // Safety: drops once, never accessed again
525        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
526    }
527}
528
529impl fidl::endpoints::Responder for PuppetStartProfilingResponder {
530    type ControlHandle = PuppetControlHandle;
531
532    fn control_handle(&self) -> &PuppetControlHandle {
533        &self.control_handle
534    }
535
536    fn drop_without_shutdown(mut self) {
537        // Safety: drops once, never accessed again due to mem::forget
538        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
539        // Prevent Drop from running (which would shut down the channel)
540        std::mem::forget(self);
541    }
542}
543
544impl PuppetStartProfilingResponder {
545    /// Sends a response to the FIDL transaction.
546    ///
547    /// Sets the channel to shutdown if an error occurs.
548    pub fn send(self) -> Result<(), fidl::Error> {
549        let _result = self.send_raw();
550        if _result.is_err() {
551            self.control_handle.shutdown();
552        }
553        self.drop_without_shutdown();
554        _result
555    }
556
557    /// Similar to "send" but does not shutdown the channel if an error occurs.
558    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
559        let _result = self.send_raw();
560        self.drop_without_shutdown();
561        _result
562    }
563
564    fn send_raw(&self) -> Result<(), fidl::Error> {
565        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
566            (),
567            self.tx_id,
568            0x3fdf927c6e4c8c8d,
569            fidl::encoding::DynamicFlags::empty(),
570        )
571    }
572}
573
574#[must_use = "FIDL methods require a response to be sent"]
575#[derive(Debug)]
576pub struct PuppetStopProfilingResponder {
577    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
578    tx_id: u32,
579}
580
581/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
582/// if the responder is dropped without sending a response, so that the client
583/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
584impl std::ops::Drop for PuppetStopProfilingResponder {
585    fn drop(&mut self) {
586        self.control_handle.shutdown();
587        // Safety: drops once, never accessed again
588        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
589    }
590}
591
592impl fidl::endpoints::Responder for PuppetStopProfilingResponder {
593    type ControlHandle = PuppetControlHandle;
594
595    fn control_handle(&self) -> &PuppetControlHandle {
596        &self.control_handle
597    }
598
599    fn drop_without_shutdown(mut self) {
600        // Safety: drops once, never accessed again due to mem::forget
601        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
602        // Prevent Drop from running (which would shut down the channel)
603        std::mem::forget(self);
604    }
605}
606
607impl PuppetStopProfilingResponder {
608    /// Sends a response to the FIDL transaction.
609    ///
610    /// Sets the channel to shutdown if an error occurs.
611    pub fn send(self) -> Result<(), fidl::Error> {
612        let _result = self.send_raw();
613        if _result.is_err() {
614            self.control_handle.shutdown();
615        }
616        self.drop_without_shutdown();
617        _result
618    }
619
620    /// Similar to "send" but does not shutdown the channel if an error occurs.
621    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
622        let _result = self.send_raw();
623        self.drop_without_shutdown();
624        _result
625    }
626
627    fn send_raw(&self) -> Result<(), fidl::Error> {
628        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
629            (),
630            self.tx_id,
631            0x23347e09827a7087,
632            fidl::encoding::DynamicFlags::empty(),
633        )
634    }
635}
636
637#[must_use = "FIDL methods require a response to be sent"]
638#[derive(Debug)]
639pub struct PuppetRunProfiledFunctionResponder {
640    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
641    tx_id: u32,
642}
643
644/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
645/// if the responder is dropped without sending a response, so that the client
646/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
647impl std::ops::Drop for PuppetRunProfiledFunctionResponder {
648    fn drop(&mut self) {
649        self.control_handle.shutdown();
650        // Safety: drops once, never accessed again
651        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
652    }
653}
654
655impl fidl::endpoints::Responder for PuppetRunProfiledFunctionResponder {
656    type ControlHandle = PuppetControlHandle;
657
658    fn control_handle(&self) -> &PuppetControlHandle {
659        &self.control_handle
660    }
661
662    fn drop_without_shutdown(mut self) {
663        // Safety: drops once, never accessed again due to mem::forget
664        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
665        // Prevent Drop from running (which would shut down the channel)
666        std::mem::forget(self);
667    }
668}
669
670impl PuppetRunProfiledFunctionResponder {
671    /// Sends a response to the FIDL transaction.
672    ///
673    /// Sets the channel to shutdown if an error occurs.
674    pub fn send(self) -> Result<(), fidl::Error> {
675        let _result = self.send_raw();
676        if _result.is_err() {
677            self.control_handle.shutdown();
678        }
679        self.drop_without_shutdown();
680        _result
681    }
682
683    /// Similar to "send" but does not shutdown the channel if an error occurs.
684    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
685        let _result = self.send_raw();
686        self.drop_without_shutdown();
687        _result
688    }
689
690    fn send_raw(&self) -> Result<(), fidl::Error> {
691        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
692            (),
693            self.tx_id,
694            0x679bdcc07c2f7065,
695            fidl::encoding::DynamicFlags::empty(),
696        )
697    }
698}
699
700mod internal {
701    use super::*;
702}
fidl_inspect_selfprofile_test/fidl_inspect_selfprofile_test.rs

fidl_inspect_selfprofile_test/
fidl_inspect_selfprofile_test.rs
