fidl_fuchsia_hwinfo_mock/
fidl_fuchsia_hwinfo_mock.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_hwinfo_mock_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct SetterMarker;
16
17impl fidl::endpoints::ProtocolMarker for SetterMarker {
18    type Proxy = SetterProxy;
19    type RequestStream = SetterRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = SetterSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.hwinfo.mock.Setter";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for SetterMarker {}
26
27pub trait SetterProxyInterface: Send + Sync {
28    type SetResponsesResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
29    fn r#set_responses(
30        &self,
31        device: &fidl_fuchsia_hwinfo::DeviceInfo,
32        product: &fidl_fuchsia_hwinfo::ProductInfo,
33        board: &fidl_fuchsia_hwinfo::BoardInfo,
34    ) -> Self::SetResponsesResponseFut;
35}
36#[derive(Debug)]
37#[cfg(target_os = "fuchsia")]
38pub struct SetterSynchronousProxy {
39    client: fidl::client::sync::Client,
40}
41
42#[cfg(target_os = "fuchsia")]
43impl fidl::endpoints::SynchronousProxy for SetterSynchronousProxy {
44    type Proxy = SetterProxy;
45    type Protocol = SetterMarker;
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 SetterSynchronousProxy {
62    pub fn new(channel: fidl::Channel) -> Self {
63        let protocol_name = <SetterMarker 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<SetterEvent, fidl::Error> {
77        SetterEvent::decode(self.client.wait_for_event(deadline)?)
78    }
79
80    /// Sets the responses from the mock.
81    ///
82    /// When this method returns future calls to the mocked hwinfo service
83    /// will return the given values until a subsequent request to
84    /// SetResponses.
85    pub fn r#set_responses(
86        &self,
87        mut device: &fidl_fuchsia_hwinfo::DeviceInfo,
88        mut product: &fidl_fuchsia_hwinfo::ProductInfo,
89        mut board: &fidl_fuchsia_hwinfo::BoardInfo,
90        ___deadline: zx::MonotonicInstant,
91    ) -> Result<(), fidl::Error> {
92        let _response =
93            self.client.send_query::<SetterSetResponsesRequest, fidl::encoding::EmptyPayload>(
94                (device, product, board),
95                0x491d2c44c662f96d,
96                fidl::encoding::DynamicFlags::empty(),
97                ___deadline,
98            )?;
99        Ok(_response)
100    }
101}
102
103#[cfg(target_os = "fuchsia")]
104impl From<SetterSynchronousProxy> for zx::Handle {
105    fn from(value: SetterSynchronousProxy) -> Self {
106        value.into_channel().into()
107    }
108}
109
110#[cfg(target_os = "fuchsia")]
111impl From<fidl::Channel> for SetterSynchronousProxy {
112    fn from(value: fidl::Channel) -> Self {
113        Self::new(value)
114    }
115}
116
117#[derive(Debug, Clone)]
118pub struct SetterProxy {
119    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
120}
121
122impl fidl::endpoints::Proxy for SetterProxy {
123    type Protocol = SetterMarker;
124
125    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
126        Self::new(inner)
127    }
128
129    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
130        self.client.into_channel().map_err(|client| Self { client })
131    }
132
133    fn as_channel(&self) -> &::fidl::AsyncChannel {
134        self.client.as_channel()
135    }
136}
137
138impl SetterProxy {
139    /// Create a new Proxy for fuchsia.hwinfo.mock/Setter.
140    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
141        let protocol_name = <SetterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
142        Self { client: fidl::client::Client::new(channel, protocol_name) }
143    }
144
145    /// Get a Stream of events from the remote end of the protocol.
146    ///
147    /// # Panics
148    ///
149    /// Panics if the event stream was already taken.
150    pub fn take_event_stream(&self) -> SetterEventStream {
151        SetterEventStream { event_receiver: self.client.take_event_receiver() }
152    }
153
154    /// Sets the responses from the mock.
155    ///
156    /// When this method returns future calls to the mocked hwinfo service
157    /// will return the given values until a subsequent request to
158    /// SetResponses.
159    pub fn r#set_responses(
160        &self,
161        mut device: &fidl_fuchsia_hwinfo::DeviceInfo,
162        mut product: &fidl_fuchsia_hwinfo::ProductInfo,
163        mut board: &fidl_fuchsia_hwinfo::BoardInfo,
164    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
165        SetterProxyInterface::r#set_responses(self, device, product, board)
166    }
167}
168
169impl SetterProxyInterface for SetterProxy {
170    type SetResponsesResponseFut =
171        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
172    fn r#set_responses(
173        &self,
174        mut device: &fidl_fuchsia_hwinfo::DeviceInfo,
175        mut product: &fidl_fuchsia_hwinfo::ProductInfo,
176        mut board: &fidl_fuchsia_hwinfo::BoardInfo,
177    ) -> Self::SetResponsesResponseFut {
178        fn _decode(
179            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
180        ) -> Result<(), fidl::Error> {
181            let _response = fidl::client::decode_transaction_body::<
182                fidl::encoding::EmptyPayload,
183                fidl::encoding::DefaultFuchsiaResourceDialect,
184                0x491d2c44c662f96d,
185            >(_buf?)?;
186            Ok(_response)
187        }
188        self.client.send_query_and_decode::<SetterSetResponsesRequest, ()>(
189            (device, product, board),
190            0x491d2c44c662f96d,
191            fidl::encoding::DynamicFlags::empty(),
192            _decode,
193        )
194    }
195}
196
197pub struct SetterEventStream {
198    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
199}
200
201impl std::marker::Unpin for SetterEventStream {}
202
203impl futures::stream::FusedStream for SetterEventStream {
204    fn is_terminated(&self) -> bool {
205        self.event_receiver.is_terminated()
206    }
207}
208
209impl futures::Stream for SetterEventStream {
210    type Item = Result<SetterEvent, fidl::Error>;
211
212    fn poll_next(
213        mut self: std::pin::Pin<&mut Self>,
214        cx: &mut std::task::Context<'_>,
215    ) -> std::task::Poll<Option<Self::Item>> {
216        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
217            &mut self.event_receiver,
218            cx
219        )?) {
220            Some(buf) => std::task::Poll::Ready(Some(SetterEvent::decode(buf))),
221            None => std::task::Poll::Ready(None),
222        }
223    }
224}
225
226#[derive(Debug)]
227pub enum SetterEvent {}
228
229impl SetterEvent {
230    /// Decodes a message buffer as a [`SetterEvent`].
231    fn decode(
232        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
233    ) -> Result<SetterEvent, fidl::Error> {
234        let (bytes, _handles) = buf.split_mut();
235        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
236        debug_assert_eq!(tx_header.tx_id, 0);
237        match tx_header.ordinal {
238            _ => Err(fidl::Error::UnknownOrdinal {
239                ordinal: tx_header.ordinal,
240                protocol_name: <SetterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
241            }),
242        }
243    }
244}
245
246/// A Stream of incoming requests for fuchsia.hwinfo.mock/Setter.
247pub struct SetterRequestStream {
248    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
249    is_terminated: bool,
250}
251
252impl std::marker::Unpin for SetterRequestStream {}
253
254impl futures::stream::FusedStream for SetterRequestStream {
255    fn is_terminated(&self) -> bool {
256        self.is_terminated
257    }
258}
259
260impl fidl::endpoints::RequestStream for SetterRequestStream {
261    type Protocol = SetterMarker;
262    type ControlHandle = SetterControlHandle;
263
264    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
265        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
266    }
267
268    fn control_handle(&self) -> Self::ControlHandle {
269        SetterControlHandle { inner: self.inner.clone() }
270    }
271
272    fn into_inner(
273        self,
274    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
275    {
276        (self.inner, self.is_terminated)
277    }
278
279    fn from_inner(
280        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
281        is_terminated: bool,
282    ) -> Self {
283        Self { inner, is_terminated }
284    }
285}
286
287impl futures::Stream for SetterRequestStream {
288    type Item = Result<SetterRequest, fidl::Error>;
289
290    fn poll_next(
291        mut self: std::pin::Pin<&mut Self>,
292        cx: &mut std::task::Context<'_>,
293    ) -> std::task::Poll<Option<Self::Item>> {
294        let this = &mut *self;
295        if this.inner.check_shutdown(cx) {
296            this.is_terminated = true;
297            return std::task::Poll::Ready(None);
298        }
299        if this.is_terminated {
300            panic!("polled SetterRequestStream after completion");
301        }
302        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
303            |bytes, handles| {
304                match this.inner.channel().read_etc(cx, bytes, handles) {
305                    std::task::Poll::Ready(Ok(())) => {}
306                    std::task::Poll::Pending => return std::task::Poll::Pending,
307                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
308                        this.is_terminated = true;
309                        return std::task::Poll::Ready(None);
310                    }
311                    std::task::Poll::Ready(Err(e)) => {
312                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
313                            e.into(),
314                        ))))
315                    }
316                }
317
318                // A message has been received from the channel
319                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
320
321                std::task::Poll::Ready(Some(match header.ordinal {
322                    0x491d2c44c662f96d => {
323                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
324                        let mut req = fidl::new_empty!(
325                            SetterSetResponsesRequest,
326                            fidl::encoding::DefaultFuchsiaResourceDialect
327                        );
328                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SetterSetResponsesRequest>(&header, _body_bytes, handles, &mut req)?;
329                        let control_handle = SetterControlHandle { inner: this.inner.clone() };
330                        Ok(SetterRequest::SetResponses {
331                            device: req.device,
332                            product: req.product,
333                            board: req.board,
334
335                            responder: SetterSetResponsesResponder {
336                                control_handle: std::mem::ManuallyDrop::new(control_handle),
337                                tx_id: header.tx_id,
338                            },
339                        })
340                    }
341                    _ => Err(fidl::Error::UnknownOrdinal {
342                        ordinal: header.ordinal,
343                        protocol_name:
344                            <SetterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
345                    }),
346                }))
347            },
348        )
349    }
350}
351
352/// This Setter protocol is used to set the return values for a hwinfo mock.
353#[derive(Debug)]
354pub enum SetterRequest {
355    /// Sets the responses from the mock.
356    ///
357    /// When this method returns future calls to the mocked hwinfo service
358    /// will return the given values until a subsequent request to
359    /// SetResponses.
360    SetResponses {
361        device: fidl_fuchsia_hwinfo::DeviceInfo,
362        product: fidl_fuchsia_hwinfo::ProductInfo,
363        board: fidl_fuchsia_hwinfo::BoardInfo,
364        responder: SetterSetResponsesResponder,
365    },
366}
367
368impl SetterRequest {
369    #[allow(irrefutable_let_patterns)]
370    pub fn into_set_responses(
371        self,
372    ) -> Option<(
373        fidl_fuchsia_hwinfo::DeviceInfo,
374        fidl_fuchsia_hwinfo::ProductInfo,
375        fidl_fuchsia_hwinfo::BoardInfo,
376        SetterSetResponsesResponder,
377    )> {
378        if let SetterRequest::SetResponses { device, product, board, responder } = self {
379            Some((device, product, board, responder))
380        } else {
381            None
382        }
383    }
384
385    /// Name of the method defined in FIDL
386    pub fn method_name(&self) -> &'static str {
387        match *self {
388            SetterRequest::SetResponses { .. } => "set_responses",
389        }
390    }
391}
392
393#[derive(Debug, Clone)]
394pub struct SetterControlHandle {
395    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
396}
397
398impl fidl::endpoints::ControlHandle for SetterControlHandle {
399    fn shutdown(&self) {
400        self.inner.shutdown()
401    }
402    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
403        self.inner.shutdown_with_epitaph(status)
404    }
405
406    fn is_closed(&self) -> bool {
407        self.inner.channel().is_closed()
408    }
409    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
410        self.inner.channel().on_closed()
411    }
412
413    #[cfg(target_os = "fuchsia")]
414    fn signal_peer(
415        &self,
416        clear_mask: zx::Signals,
417        set_mask: zx::Signals,
418    ) -> Result<(), zx_status::Status> {
419        use fidl::Peered;
420        self.inner.channel().signal_peer(clear_mask, set_mask)
421    }
422}
423
424impl SetterControlHandle {}
425
426#[must_use = "FIDL methods require a response to be sent"]
427#[derive(Debug)]
428pub struct SetterSetResponsesResponder {
429    control_handle: std::mem::ManuallyDrop<SetterControlHandle>,
430    tx_id: u32,
431}
432
433/// Set the the channel to be shutdown (see [`SetterControlHandle::shutdown`])
434/// if the responder is dropped without sending a response, so that the client
435/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
436impl std::ops::Drop for SetterSetResponsesResponder {
437    fn drop(&mut self) {
438        self.control_handle.shutdown();
439        // Safety: drops once, never accessed again
440        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
441    }
442}
443
444impl fidl::endpoints::Responder for SetterSetResponsesResponder {
445    type ControlHandle = SetterControlHandle;
446
447    fn control_handle(&self) -> &SetterControlHandle {
448        &self.control_handle
449    }
450
451    fn drop_without_shutdown(mut self) {
452        // Safety: drops once, never accessed again due to mem::forget
453        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
454        // Prevent Drop from running (which would shut down the channel)
455        std::mem::forget(self);
456    }
457}
458
459impl SetterSetResponsesResponder {
460    /// Sends a response to the FIDL transaction.
461    ///
462    /// Sets the channel to shutdown if an error occurs.
463    pub fn send(self) -> Result<(), fidl::Error> {
464        let _result = self.send_raw();
465        if _result.is_err() {
466            self.control_handle.shutdown();
467        }
468        self.drop_without_shutdown();
469        _result
470    }
471
472    /// Similar to "send" but does not shutdown the channel if an error occurs.
473    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
474        let _result = self.send_raw();
475        self.drop_without_shutdown();
476        _result
477    }
478
479    fn send_raw(&self) -> Result<(), fidl::Error> {
480        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
481            (),
482            self.tx_id,
483            0x491d2c44c662f96d,
484            fidl::encoding::DynamicFlags::empty(),
485        )
486    }
487}
488
489mod internal {
490    use super::*;
491}
fidl_fuchsia_hwinfo_mock/fidl_fuchsia_hwinfo_mock.rs

fidl_fuchsia_hwinfo_mock/
fidl_fuchsia_hwinfo_mock.rs
