fidl_fuchsia_starnix_psi/
fidl_fuchsia_starnix_psi.rs

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_fuchsia_starnix_psi__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct PsiProviderWatchMemoryStallResponse {
16    pub event: Option<fidl::Event>,
17    #[doc(hidden)]
18    pub __source_breaking: fidl::marker::SourceBreaking,
19}
20
21impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
22    for PsiProviderWatchMemoryStallResponse
23{
24}
25
26#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
27pub struct PsiProviderMarker;
28
29impl fidl::endpoints::ProtocolMarker for PsiProviderMarker {
30    type Proxy = PsiProviderProxy;
31    type RequestStream = PsiProviderRequestStream;
32    #[cfg(target_os = "fuchsia")]
33    type SynchronousProxy = PsiProviderSynchronousProxy;
34
35    const DEBUG_NAME: &'static str = "fuchsia.starnix.psi.PsiProvider";
36}
37impl fidl::endpoints::DiscoverableProtocolMarker for PsiProviderMarker {}
38pub type PsiProviderGetMemoryPressureStatsResult =
39    Result<PsiProviderGetMemoryPressureStatsResponse, i32>;
40pub type PsiProviderWatchMemoryStallResult = Result<PsiProviderWatchMemoryStallResponse, i32>;
41
42pub trait PsiProviderProxyInterface: Send + Sync {
43    type GetMemoryPressureStatsResponseFut: std::future::Future<Output = Result<PsiProviderGetMemoryPressureStatsResult, fidl::Error>>
44        + Send;
45    fn r#get_memory_pressure_stats(&self) -> Self::GetMemoryPressureStatsResponseFut;
46    type WatchMemoryStallResponseFut: std::future::Future<Output = Result<PsiProviderWatchMemoryStallResult, fidl::Error>>
47        + Send;
48    fn r#watch_memory_stall(
49        &self,
50        payload: &PsiProviderWatchMemoryStallRequest,
51    ) -> Self::WatchMemoryStallResponseFut;
52}
53#[derive(Debug)]
54#[cfg(target_os = "fuchsia")]
55pub struct PsiProviderSynchronousProxy {
56    client: fidl::client::sync::Client,
57}
58
59#[cfg(target_os = "fuchsia")]
60impl fidl::endpoints::SynchronousProxy for PsiProviderSynchronousProxy {
61    type Proxy = PsiProviderProxy;
62    type Protocol = PsiProviderMarker;
63
64    fn from_channel(inner: fidl::Channel) -> Self {
65        Self::new(inner)
66    }
67
68    fn into_channel(self) -> fidl::Channel {
69        self.client.into_channel()
70    }
71
72    fn as_channel(&self) -> &fidl::Channel {
73        self.client.as_channel()
74    }
75}
76
77#[cfg(target_os = "fuchsia")]
78impl PsiProviderSynchronousProxy {
79    pub fn new(channel: fidl::Channel) -> Self {
80        let protocol_name = <PsiProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
81        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
82    }
83
84    pub fn into_channel(self) -> fidl::Channel {
85        self.client.into_channel()
86    }
87
88    /// Waits until an event arrives and returns it. It is safe for other
89    /// threads to make concurrent requests while waiting for an event.
90    pub fn wait_for_event(
91        &self,
92        deadline: zx::MonotonicInstant,
93    ) -> Result<PsiProviderEvent, fidl::Error> {
94        PsiProviderEvent::decode(self.client.wait_for_event(deadline)?)
95    }
96
97    pub fn r#get_memory_pressure_stats(
98        &self,
99        ___deadline: zx::MonotonicInstant,
100    ) -> Result<PsiProviderGetMemoryPressureStatsResult, fidl::Error> {
101        let _response = self.client.send_query::<
102            fidl::encoding::EmptyPayload,
103            fidl::encoding::FlexibleResultType<PsiProviderGetMemoryPressureStatsResponse, i32>,
104        >(
105            (),
106            0x2122b26519bc6d20,
107            fidl::encoding::DynamicFlags::FLEXIBLE,
108            ___deadline,
109        )?
110        .into_result::<PsiProviderMarker>("get_memory_pressure_stats")?;
111        Ok(_response.map(|x| x))
112    }
113
114    pub fn r#watch_memory_stall(
115        &self,
116        mut payload: &PsiProviderWatchMemoryStallRequest,
117        ___deadline: zx::MonotonicInstant,
118    ) -> Result<PsiProviderWatchMemoryStallResult, fidl::Error> {
119        let _response = self.client.send_query::<
120            PsiProviderWatchMemoryStallRequest,
121            fidl::encoding::FlexibleResultType<PsiProviderWatchMemoryStallResponse, i32>,
122        >(
123            payload,
124            0x1c45c961cce60400,
125            fidl::encoding::DynamicFlags::FLEXIBLE,
126            ___deadline,
127        )?
128        .into_result::<PsiProviderMarker>("watch_memory_stall")?;
129        Ok(_response.map(|x| x))
130    }
131}
132
133#[cfg(target_os = "fuchsia")]
134impl From<PsiProviderSynchronousProxy> for zx::Handle {
135    fn from(value: PsiProviderSynchronousProxy) -> Self {
136        value.into_channel().into()
137    }
138}
139
140#[cfg(target_os = "fuchsia")]
141impl From<fidl::Channel> for PsiProviderSynchronousProxy {
142    fn from(value: fidl::Channel) -> Self {
143        Self::new(value)
144    }
145}
146
147#[cfg(target_os = "fuchsia")]
148impl fidl::endpoints::FromClient for PsiProviderSynchronousProxy {
149    type Protocol = PsiProviderMarker;
150
151    fn from_client(value: fidl::endpoints::ClientEnd<PsiProviderMarker>) -> Self {
152        Self::new(value.into_channel())
153    }
154}
155
156#[derive(Debug, Clone)]
157pub struct PsiProviderProxy {
158    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
159}
160
161impl fidl::endpoints::Proxy for PsiProviderProxy {
162    type Protocol = PsiProviderMarker;
163
164    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
165        Self::new(inner)
166    }
167
168    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
169        self.client.into_channel().map_err(|client| Self { client })
170    }
171
172    fn as_channel(&self) -> &::fidl::AsyncChannel {
173        self.client.as_channel()
174    }
175}
176
177impl PsiProviderProxy {
178    /// Create a new Proxy for fuchsia.starnix.psi/PsiProvider.
179    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
180        let protocol_name = <PsiProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
181        Self { client: fidl::client::Client::new(channel, protocol_name) }
182    }
183
184    /// Get a Stream of events from the remote end of the protocol.
185    ///
186    /// # Panics
187    ///
188    /// Panics if the event stream was already taken.
189    pub fn take_event_stream(&self) -> PsiProviderEventStream {
190        PsiProviderEventStream { event_receiver: self.client.take_event_receiver() }
191    }
192
193    pub fn r#get_memory_pressure_stats(
194        &self,
195    ) -> fidl::client::QueryResponseFut<
196        PsiProviderGetMemoryPressureStatsResult,
197        fidl::encoding::DefaultFuchsiaResourceDialect,
198    > {
199        PsiProviderProxyInterface::r#get_memory_pressure_stats(self)
200    }
201
202    pub fn r#watch_memory_stall(
203        &self,
204        mut payload: &PsiProviderWatchMemoryStallRequest,
205    ) -> fidl::client::QueryResponseFut<
206        PsiProviderWatchMemoryStallResult,
207        fidl::encoding::DefaultFuchsiaResourceDialect,
208    > {
209        PsiProviderProxyInterface::r#watch_memory_stall(self, payload)
210    }
211}
212
213impl PsiProviderProxyInterface for PsiProviderProxy {
214    type GetMemoryPressureStatsResponseFut = fidl::client::QueryResponseFut<
215        PsiProviderGetMemoryPressureStatsResult,
216        fidl::encoding::DefaultFuchsiaResourceDialect,
217    >;
218    fn r#get_memory_pressure_stats(&self) -> Self::GetMemoryPressureStatsResponseFut {
219        fn _decode(
220            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
221        ) -> Result<PsiProviderGetMemoryPressureStatsResult, fidl::Error> {
222            let _response = fidl::client::decode_transaction_body::<
223                fidl::encoding::FlexibleResultType<PsiProviderGetMemoryPressureStatsResponse, i32>,
224                fidl::encoding::DefaultFuchsiaResourceDialect,
225                0x2122b26519bc6d20,
226            >(_buf?)?
227            .into_result::<PsiProviderMarker>("get_memory_pressure_stats")?;
228            Ok(_response.map(|x| x))
229        }
230        self.client.send_query_and_decode::<
231            fidl::encoding::EmptyPayload,
232            PsiProviderGetMemoryPressureStatsResult,
233        >(
234            (),
235            0x2122b26519bc6d20,
236            fidl::encoding::DynamicFlags::FLEXIBLE,
237            _decode,
238        )
239    }
240
241    type WatchMemoryStallResponseFut = fidl::client::QueryResponseFut<
242        PsiProviderWatchMemoryStallResult,
243        fidl::encoding::DefaultFuchsiaResourceDialect,
244    >;
245    fn r#watch_memory_stall(
246        &self,
247        mut payload: &PsiProviderWatchMemoryStallRequest,
248    ) -> Self::WatchMemoryStallResponseFut {
249        fn _decode(
250            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
251        ) -> Result<PsiProviderWatchMemoryStallResult, fidl::Error> {
252            let _response = fidl::client::decode_transaction_body::<
253                fidl::encoding::FlexibleResultType<PsiProviderWatchMemoryStallResponse, i32>,
254                fidl::encoding::DefaultFuchsiaResourceDialect,
255                0x1c45c961cce60400,
256            >(_buf?)?
257            .into_result::<PsiProviderMarker>("watch_memory_stall")?;
258            Ok(_response.map(|x| x))
259        }
260        self.client.send_query_and_decode::<
261            PsiProviderWatchMemoryStallRequest,
262            PsiProviderWatchMemoryStallResult,
263        >(
264            payload,
265            0x1c45c961cce60400,
266            fidl::encoding::DynamicFlags::FLEXIBLE,
267            _decode,
268        )
269    }
270}
271
272pub struct PsiProviderEventStream {
273    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
274}
275
276impl std::marker::Unpin for PsiProviderEventStream {}
277
278impl futures::stream::FusedStream for PsiProviderEventStream {
279    fn is_terminated(&self) -> bool {
280        self.event_receiver.is_terminated()
281    }
282}
283
284impl futures::Stream for PsiProviderEventStream {
285    type Item = Result<PsiProviderEvent, fidl::Error>;
286
287    fn poll_next(
288        mut self: std::pin::Pin<&mut Self>,
289        cx: &mut std::task::Context<'_>,
290    ) -> std::task::Poll<Option<Self::Item>> {
291        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
292            &mut self.event_receiver,
293            cx
294        )?) {
295            Some(buf) => std::task::Poll::Ready(Some(PsiProviderEvent::decode(buf))),
296            None => std::task::Poll::Ready(None),
297        }
298    }
299}
300
301#[derive(Debug)]
302pub enum PsiProviderEvent {
303    #[non_exhaustive]
304    _UnknownEvent {
305        /// Ordinal of the event that was sent.
306        ordinal: u64,
307    },
308}
309
310impl PsiProviderEvent {
311    /// Decodes a message buffer as a [`PsiProviderEvent`].
312    fn decode(
313        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
314    ) -> Result<PsiProviderEvent, fidl::Error> {
315        let (bytes, _handles) = buf.split_mut();
316        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
317        debug_assert_eq!(tx_header.tx_id, 0);
318        match tx_header.ordinal {
319            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
320                Ok(PsiProviderEvent::_UnknownEvent { ordinal: tx_header.ordinal })
321            }
322            _ => Err(fidl::Error::UnknownOrdinal {
323                ordinal: tx_header.ordinal,
324                protocol_name: <PsiProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
325            }),
326        }
327    }
328}
329
330/// A Stream of incoming requests for fuchsia.starnix.psi/PsiProvider.
331pub struct PsiProviderRequestStream {
332    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
333    is_terminated: bool,
334}
335
336impl std::marker::Unpin for PsiProviderRequestStream {}
337
338impl futures::stream::FusedStream for PsiProviderRequestStream {
339    fn is_terminated(&self) -> bool {
340        self.is_terminated
341    }
342}
343
344impl fidl::endpoints::RequestStream for PsiProviderRequestStream {
345    type Protocol = PsiProviderMarker;
346    type ControlHandle = PsiProviderControlHandle;
347
348    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
349        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
350    }
351
352    fn control_handle(&self) -> Self::ControlHandle {
353        PsiProviderControlHandle { inner: self.inner.clone() }
354    }
355
356    fn into_inner(
357        self,
358    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
359    {
360        (self.inner, self.is_terminated)
361    }
362
363    fn from_inner(
364        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
365        is_terminated: bool,
366    ) -> Self {
367        Self { inner, is_terminated }
368    }
369}
370
371impl futures::Stream for PsiProviderRequestStream {
372    type Item = Result<PsiProviderRequest, fidl::Error>;
373
374    fn poll_next(
375        mut self: std::pin::Pin<&mut Self>,
376        cx: &mut std::task::Context<'_>,
377    ) -> std::task::Poll<Option<Self::Item>> {
378        let this = &mut *self;
379        if this.inner.check_shutdown(cx) {
380            this.is_terminated = true;
381            return std::task::Poll::Ready(None);
382        }
383        if this.is_terminated {
384            panic!("polled PsiProviderRequestStream after completion");
385        }
386        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
387            |bytes, handles| {
388                match this.inner.channel().read_etc(cx, bytes, handles) {
389                    std::task::Poll::Ready(Ok(())) => {}
390                    std::task::Poll::Pending => return std::task::Poll::Pending,
391                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
392                        this.is_terminated = true;
393                        return std::task::Poll::Ready(None);
394                    }
395                    std::task::Poll::Ready(Err(e)) => {
396                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
397                            e.into(),
398                        ))))
399                    }
400                }
401
402                // A message has been received from the channel
403                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
404
405                std::task::Poll::Ready(Some(match header.ordinal {
406                    0x2122b26519bc6d20 => {
407                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
408                        let mut req = fidl::new_empty!(
409                            fidl::encoding::EmptyPayload,
410                            fidl::encoding::DefaultFuchsiaResourceDialect
411                        );
412                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
413                        let control_handle = PsiProviderControlHandle { inner: this.inner.clone() };
414                        Ok(PsiProviderRequest::GetMemoryPressureStats {
415                            responder: PsiProviderGetMemoryPressureStatsResponder {
416                                control_handle: std::mem::ManuallyDrop::new(control_handle),
417                                tx_id: header.tx_id,
418                            },
419                        })
420                    }
421                    0x1c45c961cce60400 => {
422                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
423                        let mut req = fidl::new_empty!(
424                            PsiProviderWatchMemoryStallRequest,
425                            fidl::encoding::DefaultFuchsiaResourceDialect
426                        );
427                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PsiProviderWatchMemoryStallRequest>(&header, _body_bytes, handles, &mut req)?;
428                        let control_handle = PsiProviderControlHandle { inner: this.inner.clone() };
429                        Ok(PsiProviderRequest::WatchMemoryStall {
430                            payload: req,
431                            responder: PsiProviderWatchMemoryStallResponder {
432                                control_handle: std::mem::ManuallyDrop::new(control_handle),
433                                tx_id: header.tx_id,
434                            },
435                        })
436                    }
437                    _ if header.tx_id == 0
438                        && header
439                            .dynamic_flags()
440                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
441                    {
442                        Ok(PsiProviderRequest::_UnknownMethod {
443                            ordinal: header.ordinal,
444                            control_handle: PsiProviderControlHandle { inner: this.inner.clone() },
445                            method_type: fidl::MethodType::OneWay,
446                        })
447                    }
448                    _ if header
449                        .dynamic_flags()
450                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
451                    {
452                        this.inner.send_framework_err(
453                            fidl::encoding::FrameworkErr::UnknownMethod,
454                            header.tx_id,
455                            header.ordinal,
456                            header.dynamic_flags(),
457                            (bytes, handles),
458                        )?;
459                        Ok(PsiProviderRequest::_UnknownMethod {
460                            ordinal: header.ordinal,
461                            control_handle: PsiProviderControlHandle { inner: this.inner.clone() },
462                            method_type: fidl::MethodType::TwoWay,
463                        })
464                    }
465                    _ => Err(fidl::Error::UnknownOrdinal {
466                        ordinal: header.ordinal,
467                        protocol_name:
468                            <PsiProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
469                    }),
470                }))
471            },
472        )
473    }
474}
475
476#[derive(Debug)]
477pub enum PsiProviderRequest {
478    GetMemoryPressureStats {
479        responder: PsiProviderGetMemoryPressureStatsResponder,
480    },
481    WatchMemoryStall {
482        payload: PsiProviderWatchMemoryStallRequest,
483        responder: PsiProviderWatchMemoryStallResponder,
484    },
485    /// An interaction was received which does not match any known method.
486    #[non_exhaustive]
487    _UnknownMethod {
488        /// Ordinal of the method that was called.
489        ordinal: u64,
490        control_handle: PsiProviderControlHandle,
491        method_type: fidl::MethodType,
492    },
493}
494
495impl PsiProviderRequest {
496    #[allow(irrefutable_let_patterns)]
497    pub fn into_get_memory_pressure_stats(
498        self,
499    ) -> Option<(PsiProviderGetMemoryPressureStatsResponder)> {
500        if let PsiProviderRequest::GetMemoryPressureStats { responder } = self {
501            Some((responder))
502        } else {
503            None
504        }
505    }
506
507    #[allow(irrefutable_let_patterns)]
508    pub fn into_watch_memory_stall(
509        self,
510    ) -> Option<(PsiProviderWatchMemoryStallRequest, PsiProviderWatchMemoryStallResponder)> {
511        if let PsiProviderRequest::WatchMemoryStall { payload, responder } = self {
512            Some((payload, responder))
513        } else {
514            None
515        }
516    }
517
518    /// Name of the method defined in FIDL
519    pub fn method_name(&self) -> &'static str {
520        match *self {
521            PsiProviderRequest::GetMemoryPressureStats { .. } => "get_memory_pressure_stats",
522            PsiProviderRequest::WatchMemoryStall { .. } => "watch_memory_stall",
523            PsiProviderRequest::_UnknownMethod {
524                method_type: fidl::MethodType::OneWay, ..
525            } => "unknown one-way method",
526            PsiProviderRequest::_UnknownMethod {
527                method_type: fidl::MethodType::TwoWay, ..
528            } => "unknown two-way method",
529        }
530    }
531}
532
533#[derive(Debug, Clone)]
534pub struct PsiProviderControlHandle {
535    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
536}
537
538impl fidl::endpoints::ControlHandle for PsiProviderControlHandle {
539    fn shutdown(&self) {
540        self.inner.shutdown()
541    }
542    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
543        self.inner.shutdown_with_epitaph(status)
544    }
545
546    fn is_closed(&self) -> bool {
547        self.inner.channel().is_closed()
548    }
549    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
550        self.inner.channel().on_closed()
551    }
552
553    #[cfg(target_os = "fuchsia")]
554    fn signal_peer(
555        &self,
556        clear_mask: zx::Signals,
557        set_mask: zx::Signals,
558    ) -> Result<(), zx_status::Status> {
559        use fidl::Peered;
560        self.inner.channel().signal_peer(clear_mask, set_mask)
561    }
562}
563
564impl PsiProviderControlHandle {}
565
566#[must_use = "FIDL methods require a response to be sent"]
567#[derive(Debug)]
568pub struct PsiProviderGetMemoryPressureStatsResponder {
569    control_handle: std::mem::ManuallyDrop<PsiProviderControlHandle>,
570    tx_id: u32,
571}
572
573/// Set the the channel to be shutdown (see [`PsiProviderControlHandle::shutdown`])
574/// if the responder is dropped without sending a response, so that the client
575/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
576impl std::ops::Drop for PsiProviderGetMemoryPressureStatsResponder {
577    fn drop(&mut self) {
578        self.control_handle.shutdown();
579        // Safety: drops once, never accessed again
580        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
581    }
582}
583
584impl fidl::endpoints::Responder for PsiProviderGetMemoryPressureStatsResponder {
585    type ControlHandle = PsiProviderControlHandle;
586
587    fn control_handle(&self) -> &PsiProviderControlHandle {
588        &self.control_handle
589    }
590
591    fn drop_without_shutdown(mut self) {
592        // Safety: drops once, never accessed again due to mem::forget
593        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
594        // Prevent Drop from running (which would shut down the channel)
595        std::mem::forget(self);
596    }
597}
598
599impl PsiProviderGetMemoryPressureStatsResponder {
600    /// Sends a response to the FIDL transaction.
601    ///
602    /// Sets the channel to shutdown if an error occurs.
603    pub fn send(
604        self,
605        mut result: Result<&PsiProviderGetMemoryPressureStatsResponse, i32>,
606    ) -> Result<(), fidl::Error> {
607        let _result = self.send_raw(result);
608        if _result.is_err() {
609            self.control_handle.shutdown();
610        }
611        self.drop_without_shutdown();
612        _result
613    }
614
615    /// Similar to "send" but does not shutdown the channel if an error occurs.
616    pub fn send_no_shutdown_on_err(
617        self,
618        mut result: Result<&PsiProviderGetMemoryPressureStatsResponse, i32>,
619    ) -> Result<(), fidl::Error> {
620        let _result = self.send_raw(result);
621        self.drop_without_shutdown();
622        _result
623    }
624
625    fn send_raw(
626        &self,
627        mut result: Result<&PsiProviderGetMemoryPressureStatsResponse, i32>,
628    ) -> Result<(), fidl::Error> {
629        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
630            PsiProviderGetMemoryPressureStatsResponse,
631            i32,
632        >>(
633            fidl::encoding::FlexibleResult::new(result),
634            self.tx_id,
635            0x2122b26519bc6d20,
636            fidl::encoding::DynamicFlags::FLEXIBLE,
637        )
638    }
639}
640
641#[must_use = "FIDL methods require a response to be sent"]
642#[derive(Debug)]
643pub struct PsiProviderWatchMemoryStallResponder {
644    control_handle: std::mem::ManuallyDrop<PsiProviderControlHandle>,
645    tx_id: u32,
646}
647
648/// Set the the channel to be shutdown (see [`PsiProviderControlHandle::shutdown`])
649/// if the responder is dropped without sending a response, so that the client
650/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
651impl std::ops::Drop for PsiProviderWatchMemoryStallResponder {
652    fn drop(&mut self) {
653        self.control_handle.shutdown();
654        // Safety: drops once, never accessed again
655        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
656    }
657}
658
659impl fidl::endpoints::Responder for PsiProviderWatchMemoryStallResponder {
660    type ControlHandle = PsiProviderControlHandle;
661
662    fn control_handle(&self) -> &PsiProviderControlHandle {
663        &self.control_handle
664    }
665
666    fn drop_without_shutdown(mut self) {
667        // Safety: drops once, never accessed again due to mem::forget
668        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
669        // Prevent Drop from running (which would shut down the channel)
670        std::mem::forget(self);
671    }
672}
673
674impl PsiProviderWatchMemoryStallResponder {
675    /// Sends a response to the FIDL transaction.
676    ///
677    /// Sets the channel to shutdown if an error occurs.
678    pub fn send(
679        self,
680        mut result: Result<PsiProviderWatchMemoryStallResponse, i32>,
681    ) -> Result<(), fidl::Error> {
682        let _result = self.send_raw(result);
683        if _result.is_err() {
684            self.control_handle.shutdown();
685        }
686        self.drop_without_shutdown();
687        _result
688    }
689
690    /// Similar to "send" but does not shutdown the channel if an error occurs.
691    pub fn send_no_shutdown_on_err(
692        self,
693        mut result: Result<PsiProviderWatchMemoryStallResponse, i32>,
694    ) -> Result<(), fidl::Error> {
695        let _result = self.send_raw(result);
696        self.drop_without_shutdown();
697        _result
698    }
699
700    fn send_raw(
701        &self,
702        mut result: Result<PsiProviderWatchMemoryStallResponse, i32>,
703    ) -> Result<(), fidl::Error> {
704        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
705            PsiProviderWatchMemoryStallResponse,
706            i32,
707        >>(
708            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
709            self.tx_id,
710            0x1c45c961cce60400,
711            fidl::encoding::DynamicFlags::FLEXIBLE,
712        )
713    }
714}
715
716mod internal {
717    use super::*;
718
719    impl PsiProviderWatchMemoryStallResponse {
720        #[inline(always)]
721        fn max_ordinal_present(&self) -> u64 {
722            if let Some(_) = self.event {
723                return 1;
724            }
725            0
726        }
727    }
728
729    impl fidl::encoding::ResourceTypeMarker for PsiProviderWatchMemoryStallResponse {
730        type Borrowed<'a> = &'a mut Self;
731        fn take_or_borrow<'a>(
732            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
733        ) -> Self::Borrowed<'a> {
734            value
735        }
736    }
737
738    unsafe impl fidl::encoding::TypeMarker for PsiProviderWatchMemoryStallResponse {
739        type Owned = Self;
740
741        #[inline(always)]
742        fn inline_align(_context: fidl::encoding::Context) -> usize {
743            8
744        }
745
746        #[inline(always)]
747        fn inline_size(_context: fidl::encoding::Context) -> usize {
748            16
749        }
750    }
751
752    unsafe impl
753        fidl::encoding::Encode<
754            PsiProviderWatchMemoryStallResponse,
755            fidl::encoding::DefaultFuchsiaResourceDialect,
756        > for &mut PsiProviderWatchMemoryStallResponse
757    {
758        unsafe fn encode(
759            self,
760            encoder: &mut fidl::encoding::Encoder<
761                '_,
762                fidl::encoding::DefaultFuchsiaResourceDialect,
763            >,
764            offset: usize,
765            mut depth: fidl::encoding::Depth,
766        ) -> fidl::Result<()> {
767            encoder.debug_check_bounds::<PsiProviderWatchMemoryStallResponse>(offset);
768            // Vector header
769            let max_ordinal: u64 = self.max_ordinal_present();
770            encoder.write_num(max_ordinal, offset);
771            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
772            // Calling encoder.out_of_line_offset(0) is not allowed.
773            if max_ordinal == 0 {
774                return Ok(());
775            }
776            depth.increment()?;
777            let envelope_size = 8;
778            let bytes_len = max_ordinal as usize * envelope_size;
779            #[allow(unused_variables)]
780            let offset = encoder.out_of_line_offset(bytes_len);
781            let mut _prev_end_offset: usize = 0;
782            if 1 > max_ordinal {
783                return Ok(());
784            }
785
786            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
787            // are envelope_size bytes.
788            let cur_offset: usize = (1 - 1) * envelope_size;
789
790            // Zero reserved fields.
791            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
792
793            // Safety:
794            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
795            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
796            //   envelope_size bytes, there is always sufficient room.
797            fidl::encoding::encode_in_envelope_optional::<
798                fidl::encoding::HandleType<
799                    fidl::Event,
800                    { fidl::ObjectType::EVENT.into_raw() },
801                    2147483648,
802                >,
803                fidl::encoding::DefaultFuchsiaResourceDialect,
804            >(
805                self.event.as_mut().map(
806                    <fidl::encoding::HandleType<
807                        fidl::Event,
808                        { fidl::ObjectType::EVENT.into_raw() },
809                        2147483648,
810                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
811                ),
812                encoder,
813                offset + cur_offset,
814                depth,
815            )?;
816
817            _prev_end_offset = cur_offset + envelope_size;
818
819            Ok(())
820        }
821    }
822
823    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
824        for PsiProviderWatchMemoryStallResponse
825    {
826        #[inline(always)]
827        fn new_empty() -> Self {
828            Self::default()
829        }
830
831        unsafe fn decode(
832            &mut self,
833            decoder: &mut fidl::encoding::Decoder<
834                '_,
835                fidl::encoding::DefaultFuchsiaResourceDialect,
836            >,
837            offset: usize,
838            mut depth: fidl::encoding::Depth,
839        ) -> fidl::Result<()> {
840            decoder.debug_check_bounds::<Self>(offset);
841            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
842                None => return Err(fidl::Error::NotNullable),
843                Some(len) => len,
844            };
845            // Calling decoder.out_of_line_offset(0) is not allowed.
846            if len == 0 {
847                return Ok(());
848            };
849            depth.increment()?;
850            let envelope_size = 8;
851            let bytes_len = len * envelope_size;
852            let offset = decoder.out_of_line_offset(bytes_len)?;
853            // Decode the envelope for each type.
854            let mut _next_ordinal_to_read = 0;
855            let mut next_offset = offset;
856            let end_offset = offset + bytes_len;
857            _next_ordinal_to_read += 1;
858            if next_offset >= end_offset {
859                return Ok(());
860            }
861
862            // Decode unknown envelopes for gaps in ordinals.
863            while _next_ordinal_to_read < 1 {
864                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
865                _next_ordinal_to_read += 1;
866                next_offset += envelope_size;
867            }
868
869            let next_out_of_line = decoder.next_out_of_line();
870            let handles_before = decoder.remaining_handles();
871            if let Some((inlined, num_bytes, num_handles)) =
872                fidl::encoding::decode_envelope_header(decoder, next_offset)?
873            {
874                let member_inline_size = <fidl::encoding::HandleType<
875                    fidl::Event,
876                    { fidl::ObjectType::EVENT.into_raw() },
877                    2147483648,
878                > as fidl::encoding::TypeMarker>::inline_size(
879                    decoder.context
880                );
881                if inlined != (member_inline_size <= 4) {
882                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
883                }
884                let inner_offset;
885                let mut inner_depth = depth.clone();
886                if inlined {
887                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
888                    inner_offset = next_offset;
889                } else {
890                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
891                    inner_depth.increment()?;
892                }
893                let val_ref =
894                self.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
895                fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
896                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
897                {
898                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
899                }
900                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
901                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
902                }
903            }
904
905            next_offset += envelope_size;
906
907            // Decode the remaining unknown envelopes.
908            while next_offset < end_offset {
909                _next_ordinal_to_read += 1;
910                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
911                next_offset += envelope_size;
912            }
913
914            Ok(())
915        }
916    }
917}
fidl_fuchsia_starnix_psi/fidl_fuchsia_starnix_psi.rs

fidl_fuchsia_starnix_psi/
fidl_fuchsia_starnix_psi.rs
