fidl_fuchsia_reloaddriver_test/
fidl_fuchsia_reloaddriver_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_fuchsia_reloaddriver_test_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct WaiterMarker;
16
17impl fidl::endpoints::ProtocolMarker for WaiterMarker {
18    type Proxy = WaiterProxy;
19    type RequestStream = WaiterRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = WaiterSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.reloaddriver.test.Waiter";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for WaiterMarker {}
26
27pub trait WaiterProxyInterface: Send + Sync {
28    fn r#ack(&self, from_node: &str, from_name: &str, status: i32) -> Result<(), fidl::Error>;
29}
30#[derive(Debug)]
31#[cfg(target_os = "fuchsia")]
32pub struct WaiterSynchronousProxy {
33    client: fidl::client::sync::Client,
34}
35
36#[cfg(target_os = "fuchsia")]
37impl fidl::endpoints::SynchronousProxy for WaiterSynchronousProxy {
38    type Proxy = WaiterProxy;
39    type Protocol = WaiterMarker;
40
41    fn from_channel(inner: fidl::Channel) -> Self {
42        Self::new(inner)
43    }
44
45    fn into_channel(self) -> fidl::Channel {
46        self.client.into_channel()
47    }
48
49    fn as_channel(&self) -> &fidl::Channel {
50        self.client.as_channel()
51    }
52}
53
54#[cfg(target_os = "fuchsia")]
55impl WaiterSynchronousProxy {
56    pub fn new(channel: fidl::Channel) -> Self {
57        let protocol_name = <WaiterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
58        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
59    }
60
61    pub fn into_channel(self) -> fidl::Channel {
62        self.client.into_channel()
63    }
64
65    /// Waits until an event arrives and returns it. It is safe for other
66    /// threads to make concurrent requests while waiting for an event.
67    pub fn wait_for_event(
68        &self,
69        deadline: zx::MonotonicInstant,
70    ) -> Result<WaiterEvent, fidl::Error> {
71        WaiterEvent::decode(self.client.wait_for_event(deadline)?)
72    }
73
74    pub fn r#ack(
75        &self,
76        mut from_node: &str,
77        mut from_name: &str,
78        mut status: i32,
79    ) -> Result<(), fidl::Error> {
80        self.client.send::<WaiterAckRequest>(
81            (from_node, from_name, status),
82            0x7e80870431180046,
83            fidl::encoding::DynamicFlags::empty(),
84        )
85    }
86}
87
88#[derive(Debug, Clone)]
89pub struct WaiterProxy {
90    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
91}
92
93impl fidl::endpoints::Proxy for WaiterProxy {
94    type Protocol = WaiterMarker;
95
96    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
97        Self::new(inner)
98    }
99
100    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
101        self.client.into_channel().map_err(|client| Self { client })
102    }
103
104    fn as_channel(&self) -> &::fidl::AsyncChannel {
105        self.client.as_channel()
106    }
107}
108
109impl WaiterProxy {
110    /// Create a new Proxy for fuchsia.reloaddriver.test/Waiter.
111    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
112        let protocol_name = <WaiterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
113        Self { client: fidl::client::Client::new(channel, protocol_name) }
114    }
115
116    /// Get a Stream of events from the remote end of the protocol.
117    ///
118    /// # Panics
119    ///
120    /// Panics if the event stream was already taken.
121    pub fn take_event_stream(&self) -> WaiterEventStream {
122        WaiterEventStream { event_receiver: self.client.take_event_receiver() }
123    }
124
125    pub fn r#ack(
126        &self,
127        mut from_node: &str,
128        mut from_name: &str,
129        mut status: i32,
130    ) -> Result<(), fidl::Error> {
131        WaiterProxyInterface::r#ack(self, from_node, from_name, status)
132    }
133}
134
135impl WaiterProxyInterface for WaiterProxy {
136    fn r#ack(
137        &self,
138        mut from_node: &str,
139        mut from_name: &str,
140        mut status: i32,
141    ) -> Result<(), fidl::Error> {
142        self.client.send::<WaiterAckRequest>(
143            (from_node, from_name, status),
144            0x7e80870431180046,
145            fidl::encoding::DynamicFlags::empty(),
146        )
147    }
148}
149
150pub struct WaiterEventStream {
151    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
152}
153
154impl std::marker::Unpin for WaiterEventStream {}
155
156impl futures::stream::FusedStream for WaiterEventStream {
157    fn is_terminated(&self) -> bool {
158        self.event_receiver.is_terminated()
159    }
160}
161
162impl futures::Stream for WaiterEventStream {
163    type Item = Result<WaiterEvent, fidl::Error>;
164
165    fn poll_next(
166        mut self: std::pin::Pin<&mut Self>,
167        cx: &mut std::task::Context<'_>,
168    ) -> std::task::Poll<Option<Self::Item>> {
169        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
170            &mut self.event_receiver,
171            cx
172        )?) {
173            Some(buf) => std::task::Poll::Ready(Some(WaiterEvent::decode(buf))),
174            None => std::task::Poll::Ready(None),
175        }
176    }
177}
178
179#[derive(Debug)]
180pub enum WaiterEvent {}
181
182impl WaiterEvent {
183    /// Decodes a message buffer as a [`WaiterEvent`].
184    fn decode(
185        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
186    ) -> Result<WaiterEvent, fidl::Error> {
187        let (bytes, _handles) = buf.split_mut();
188        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
189        debug_assert_eq!(tx_header.tx_id, 0);
190        match tx_header.ordinal {
191            _ => Err(fidl::Error::UnknownOrdinal {
192                ordinal: tx_header.ordinal,
193                protocol_name: <WaiterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
194            }),
195        }
196    }
197}
198
199/// A Stream of incoming requests for fuchsia.reloaddriver.test/Waiter.
200pub struct WaiterRequestStream {
201    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
202    is_terminated: bool,
203}
204
205impl std::marker::Unpin for WaiterRequestStream {}
206
207impl futures::stream::FusedStream for WaiterRequestStream {
208    fn is_terminated(&self) -> bool {
209        self.is_terminated
210    }
211}
212
213impl fidl::endpoints::RequestStream for WaiterRequestStream {
214    type Protocol = WaiterMarker;
215    type ControlHandle = WaiterControlHandle;
216
217    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
218        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
219    }
220
221    fn control_handle(&self) -> Self::ControlHandle {
222        WaiterControlHandle { inner: self.inner.clone() }
223    }
224
225    fn into_inner(
226        self,
227    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
228    {
229        (self.inner, self.is_terminated)
230    }
231
232    fn from_inner(
233        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
234        is_terminated: bool,
235    ) -> Self {
236        Self { inner, is_terminated }
237    }
238}
239
240impl futures::Stream for WaiterRequestStream {
241    type Item = Result<WaiterRequest, fidl::Error>;
242
243    fn poll_next(
244        mut self: std::pin::Pin<&mut Self>,
245        cx: &mut std::task::Context<'_>,
246    ) -> std::task::Poll<Option<Self::Item>> {
247        let this = &mut *self;
248        if this.inner.check_shutdown(cx) {
249            this.is_terminated = true;
250            return std::task::Poll::Ready(None);
251        }
252        if this.is_terminated {
253            panic!("polled WaiterRequestStream after completion");
254        }
255        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
256            |bytes, handles| {
257                match this.inner.channel().read_etc(cx, bytes, handles) {
258                    std::task::Poll::Ready(Ok(())) => {}
259                    std::task::Poll::Pending => return std::task::Poll::Pending,
260                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
261                        this.is_terminated = true;
262                        return std::task::Poll::Ready(None);
263                    }
264                    std::task::Poll::Ready(Err(e)) => {
265                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
266                            e.into(),
267                        ))))
268                    }
269                }
270
271                // A message has been received from the channel
272                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
273
274                std::task::Poll::Ready(Some(match header.ordinal {
275                    0x7e80870431180046 => {
276                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
277                        let mut req = fidl::new_empty!(
278                            WaiterAckRequest,
279                            fidl::encoding::DefaultFuchsiaResourceDialect
280                        );
281                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WaiterAckRequest>(&header, _body_bytes, handles, &mut req)?;
282                        let control_handle = WaiterControlHandle { inner: this.inner.clone() };
283                        Ok(WaiterRequest::Ack {
284                            from_node: req.from_node,
285                            from_name: req.from_name,
286                            status: req.status,
287
288                            control_handle,
289                        })
290                    }
291                    _ => Err(fidl::Error::UnknownOrdinal {
292                        ordinal: header.ordinal,
293                        protocol_name:
294                            <WaiterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
295                    }),
296                }))
297            },
298        )
299    }
300}
301
302#[derive(Debug)]
303pub enum WaiterRequest {
304    Ack { from_node: String, from_name: String, status: i32, control_handle: WaiterControlHandle },
305}
306
307impl WaiterRequest {
308    #[allow(irrefutable_let_patterns)]
309    pub fn into_ack(self) -> Option<(String, String, i32, WaiterControlHandle)> {
310        if let WaiterRequest::Ack { from_node, from_name, status, control_handle } = self {
311            Some((from_node, from_name, status, control_handle))
312        } else {
313            None
314        }
315    }
316
317    /// Name of the method defined in FIDL
318    pub fn method_name(&self) -> &'static str {
319        match *self {
320            WaiterRequest::Ack { .. } => "ack",
321        }
322    }
323}
324
325#[derive(Debug, Clone)]
326pub struct WaiterControlHandle {
327    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
328}
329
330impl fidl::endpoints::ControlHandle for WaiterControlHandle {
331    fn shutdown(&self) {
332        self.inner.shutdown()
333    }
334    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
335        self.inner.shutdown_with_epitaph(status)
336    }
337
338    fn is_closed(&self) -> bool {
339        self.inner.channel().is_closed()
340    }
341    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
342        self.inner.channel().on_closed()
343    }
344
345    #[cfg(target_os = "fuchsia")]
346    fn signal_peer(
347        &self,
348        clear_mask: zx::Signals,
349        set_mask: zx::Signals,
350    ) -> Result<(), zx_status::Status> {
351        use fidl::Peered;
352        self.inner.channel().signal_peer(clear_mask, set_mask)
353    }
354}
355
356impl WaiterControlHandle {}
357
358mod internal {
359    use super::*;
360}
fidl_fuchsia_reloaddriver_test/fidl_fuchsia_reloaddriver_test.rs

fidl_fuchsia_reloaddriver_test/
fidl_fuchsia_reloaddriver_test.rs
