fidl_fuchsia_hardware_adcimpl/
fidl_fuchsia_hardware_adcimpl.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_hardware_adcimpl__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[cfg(feature = "driver")]
15#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
16pub struct DeviceMarker;
17
18#[cfg(feature = "driver")]
19impl fidl_driver::endpoints::DriverProtocolMarker for DeviceMarker {
20    const DEBUG_NAME: &'static str = "(anonymous) Device";
21}
22pub type DeviceGetResolutionResult = Result<u8, i32>;
23pub type DeviceGetSampleResult = Result<u32, i32>;
24
25#[cfg(feature = "driver")]
26#[derive(Debug)]
27pub enum DeviceRequest {
28    /// Get adc resolution in number of bits.
29    GetResolution { responder: DeviceGetResolutionResponder },
30    /// Get sample - raw count from adc - of the ADC channel indicated by
31    /// channel_id.
32    GetSample { channel_id: u32, responder: DeviceGetSampleResponder },
33}
34
35#[cfg(feature = "driver")]
36impl DeviceRequest {
37    #[allow(irrefutable_let_patterns)]
38    pub fn into_get_resolution(self) -> Option<(DeviceGetResolutionResponder)> {
39        if let DeviceRequest::GetResolution { responder } = self { Some((responder)) } else { None }
40    }
41
42    #[allow(irrefutable_let_patterns)]
43    pub fn into_get_sample(self) -> Option<(u32, DeviceGetSampleResponder)> {
44        if let DeviceRequest::GetSample { channel_id, responder } = self {
45            Some((channel_id, responder))
46        } else {
47            None
48        }
49    }
50
51    pub fn new_get_resolution(self, tx_id: u32) -> Self {
52        Self::GetResolution { responder: DeviceGetResolutionResponder { tx_id } }
53    }
54
55    pub fn new_get_sample(self, channel_id: u32, tx_id: u32) -> Self {
56        Self::GetSample { channel_id, responder: DeviceGetSampleResponder { tx_id } }
57    }
58
59    pub fn r#get_resolution_as_message(
60        arena: fdf::Arena,
61        tx_id: u32,
62    ) -> Result<fdf::Message<[u8]>, fidl::Error> {
63        let ordinal = 0x3829cb3201b4a463;
64        let dynamic_flags = fidl::encoding::DynamicFlags::empty();
65        let body = ();
66        let msg = fidl::encoding::TransactionMessage {
67            header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
68            body,
69        };
70        fidl::encoding::with_tls_encoded::<
71            fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
72            fidl::encoding::DefaultFuchsiaResourceDialect,
73            fdf::Message<[u8]>,
74        >(msg, |bytes, mut handles| {
75            let handles = arena.insert_from_iter(
76                std::mem::take(handles)
77                    .into_iter()
78                    .map(fidl_driver::encoding::mixed_from_handle_disposition),
79            );
80            Ok(fdf::Message::new(&arena, Some(arena.insert_slice(bytes)), Some(handles)))
81        })
82    }
83
84    pub fn r#get_sample_as_message(
85        arena: fdf::Arena,
86        mut channel_id: u32,
87        tx_id: u32,
88    ) -> Result<fdf::Message<[u8]>, fidl::Error> {
89        let ordinal = 0x2e22cd7261f5b6e6;
90        let dynamic_flags = fidl::encoding::DynamicFlags::empty();
91        let body = (channel_id,);
92        let msg = fidl::encoding::TransactionMessage {
93            header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
94            body,
95        };
96        fidl::encoding::with_tls_encoded::<
97            fidl::encoding::TransactionMessageType<DeviceGetSampleRequest>,
98            fidl::encoding::DefaultFuchsiaResourceDialect,
99            fdf::Message<[u8]>,
100        >(msg, |bytes, mut handles| {
101            let handles = arena.insert_from_iter(
102                std::mem::take(handles)
103                    .into_iter()
104                    .map(fidl_driver::encoding::mixed_from_handle_disposition),
105            );
106            Ok(fdf::Message::new(&arena, Some(arena.insert_slice(bytes)), Some(handles)))
107        })
108    }
109
110    #[allow(irrefutable_let_patterns)]
111    pub fn read_from(bytes: &[u8], _handles: &mut [zx::HandleInfo]) -> Result<Self, fidl::Error> {
112        let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
113
114        match header.ordinal {
115            0x3829cb3201b4a463 => {
116                header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
117                let mut req = fidl::new_empty!(
118                    fidl::encoding::EmptyPayload,
119                    fidl::encoding::DefaultFuchsiaResourceDialect
120                );
121                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
122                Ok(DeviceRequest::GetResolution {
123                    responder: DeviceGetResolutionResponder { tx_id: header.tx_id },
124                })
125            }
126            0x2e22cd7261f5b6e6 => {
127                header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
128                let mut req = fidl::new_empty!(
129                    DeviceGetSampleRequest,
130                    fidl::encoding::DefaultFuchsiaResourceDialect
131                );
132                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceGetSampleRequest>(&header, _body_bytes, _handles, &mut req)?;
133                Ok(DeviceRequest::GetSample {
134                    channel_id: req.channel_id,
135
136                    responder: DeviceGetSampleResponder { tx_id: header.tx_id },
137                })
138            }
139            _ => Err(fidl::Error::UnknownOrdinal {
140                ordinal: header.ordinal,
141                protocol_name:
142                    <DeviceMarker as fidl_driver::endpoints::DriverProtocolMarker>::DEBUG_NAME,
143            }),
144        }
145    }
146
147    pub fn read_from_message(
148        mut message: fdf::Message<[u8]>,
149    ) -> Result<(fdf::Arena, Self), fidl::Error> {
150        let (arena, Some(body), handles) = message.take_arena_boxes() else {
151            return Err(fidl::Error::Invalid);
152        };
153        let mut handles =
154            handles
155                .map(|handles| {
156                    arena.try_insert_from_iter(handles.into_iter().map(|handle| unsafe {
157                        fidl_driver::encoding::mixed_into_handle_info(handle)
158                    }))
159                })
160                .transpose();
161        let res = match handles {
162            Ok(ref mut handles) => {
163                Self::read_from(&*body, handles.as_deref_mut().unwrap_or(&mut []))?
164            }
165            Err(_) => return Err(fidl::Error::Invalid),
166        };
167        std::mem::drop((body, handles));
168        Ok((message.take_arena(), res))
169    }
170
171    /// Name of the method defined in FIDL
172    pub fn method_name(&self) -> &'static str {
173        match *self {
174            DeviceRequest::GetResolution { .. } => "get_resolution",
175            DeviceRequest::GetSample { .. } => "get_sample",
176        }
177    }
178}
179
180/// Like [`DeviceRequest::read_from_message`] except it drops the [`Arena`].
181#[cfg(feature = "driver")]
182impl std::convert::TryFrom<fdf::Message<[u8]>> for DeviceRequest {
183    type Error = fidl::Error;
184    fn try_from(msg: fdf::Message<[u8]>) -> Result<DeviceRequest, fidl::Error> {
185        Ok(DeviceRequest::read_from_message(msg)?.1)
186    }
187}
188
189#[must_use = "FIDL methods require a response to be sent"]
190#[cfg(feature = "driver")]
191#[derive(Debug)]
192pub struct DeviceGetResolutionResponder {
193    tx_id: u32,
194}
195
196#[cfg(feature = "driver")]
197impl DeviceGetResolutionResponder {
198    pub fn send_response(
199        &self,
200        server_handle: &fdf::Channel<[u8]>,
201        mut result: Result<u8, i32>,
202    ) -> Result<(), fidl::Error> {
203        let msg = fidl::encoding::TransactionMessage {
204            header: fidl::encoding::TransactionHeader::new(
205                self.tx_id,
206                0x3829cb3201b4a463,
207                fidl::encoding::DynamicFlags::empty(),
208            ),
209            body: result.map(|resolution| (resolution,)),
210        };
211        fidl::encoding::with_tls_encoded::<
212            fidl::encoding::TransactionMessageType<
213                fidl::encoding::ResultType<DeviceGetResolutionResponse, i32>,
214            >,
215            fidl::encoding::DefaultFuchsiaResourceDialect,
216            (),
217        >(msg, |body, _handles| {
218            server_handle
219                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
220                .unwrap();
221            Ok(())
222        })
223    }
224}
225
226#[must_use = "FIDL methods require a response to be sent"]
227#[cfg(feature = "driver")]
228#[derive(Debug)]
229pub struct DeviceGetSampleResponder {
230    tx_id: u32,
231}
232
233#[cfg(feature = "driver")]
234impl DeviceGetSampleResponder {
235    pub fn send_response(
236        &self,
237        server_handle: &fdf::Channel<[u8]>,
238        mut result: Result<u32, i32>,
239    ) -> Result<(), fidl::Error> {
240        let msg = fidl::encoding::TransactionMessage {
241            header: fidl::encoding::TransactionHeader::new(
242                self.tx_id,
243                0x2e22cd7261f5b6e6,
244                fidl::encoding::DynamicFlags::empty(),
245            ),
246            body: result.map(|value| (value,)),
247        };
248        fidl::encoding::with_tls_encoded::<
249            fidl::encoding::TransactionMessageType<
250                fidl::encoding::ResultType<DeviceGetSampleResponse, i32>,
251            >,
252            fidl::encoding::DefaultFuchsiaResourceDialect,
253            (),
254        >(msg, |body, _handles| {
255            server_handle
256                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
257                .unwrap();
258            Ok(())
259        })
260    }
261}
262
263#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
264pub struct ServiceMarker;
265
266#[cfg(target_os = "fuchsia")]
267impl fidl::endpoints::ServiceMarker for ServiceMarker {
268    type Proxy = ServiceProxy;
269    type Request = ServiceRequest;
270    const SERVICE_NAME: &'static str = "fuchsia.hardware.adcimpl.Service";
271}
272
273/// A request for one of the member protocols of Service.
274///
275#[cfg(target_os = "fuchsia")]
276pub enum ServiceRequest {}
277
278#[cfg(target_os = "fuchsia")]
279impl fidl::endpoints::ServiceRequest for ServiceRequest {
280    type Service = ServiceMarker;
281
282    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
283        match name {
284            _ => panic!("no such member protocol name for service Service"),
285        }
286    }
287
288    fn member_names() -> &'static [&'static str] {
289        &[]
290    }
291}
292#[cfg(target_os = "fuchsia")]
293pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
294
295#[cfg(target_os = "fuchsia")]
296impl fidl::endpoints::ServiceProxy for ServiceProxy {
297    type Service = ServiceMarker;
298
299    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
300        Self(opener)
301    }
302}
303
304#[cfg(target_os = "fuchsia")]
305impl ServiceProxy {
306    pub fn instance_name(&self) -> &str {
307        self.0.instance_name()
308    }
309}
310
311mod internal {
312    use super::*;
313}
fidl_fuchsia_hardware_adcimpl/fidl_fuchsia_hardware_adcimpl.rs

fidl_fuchsia_hardware_adcimpl/
fidl_fuchsia_hardware_adcimpl.rs
