fidl_fuchsia_hardware_block_partition/
fidl_fuchsia_hardware_block_partition.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_block_partition_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct PartitionMarker;
16
17impl fidl::endpoints::ProtocolMarker for PartitionMarker {
18    type Proxy = PartitionProxy;
19    type RequestStream = PartitionRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = PartitionSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "(anonymous) Partition";
24}
25pub type PartitionGetMetadataResult = Result<PartitionGetMetadataResponse, i32>;
26
27pub trait PartitionProxyInterface: Send + Sync {
28    type GetInfoResponseFut: std::future::Future<
29            Output = Result<fidl_fuchsia_hardware_block::BlockGetInfoResult, fidl::Error>,
30        > + Send;
31    fn r#get_info(&self) -> Self::GetInfoResponseFut;
32    type GetStatsResponseFut: std::future::Future<
33            Output = Result<fidl_fuchsia_hardware_block::BlockGetStatsResult, fidl::Error>,
34        > + Send;
35    fn r#get_stats(&self, clear: bool) -> Self::GetStatsResponseFut;
36    fn r#open_session(
37        &self,
38        session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
39    ) -> Result<(), fidl::Error>;
40    fn r#open_session_with_offset_map(
41        &self,
42        session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
43        offset_map: Option<
44            fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_block::OffsetMapMarker>,
45        >,
46        initial_mappings: Option<&[fidl_fuchsia_hardware_block::BlockOffsetMapping]>,
47    ) -> Result<(), fidl::Error>;
48    type GetTypeGuidResponseFut: std::future::Future<Output = Result<(i32, Option<Box<Guid>>), fidl::Error>>
49        + Send;
50    fn r#get_type_guid(&self) -> Self::GetTypeGuidResponseFut;
51    type GetInstanceGuidResponseFut: std::future::Future<Output = Result<(i32, Option<Box<Guid>>), fidl::Error>>
52        + Send;
53    fn r#get_instance_guid(&self) -> Self::GetInstanceGuidResponseFut;
54    type GetNameResponseFut: std::future::Future<Output = Result<(i32, Option<String>), fidl::Error>>
55        + Send;
56    fn r#get_name(&self) -> Self::GetNameResponseFut;
57    type GetMetadataResponseFut: std::future::Future<Output = Result<PartitionGetMetadataResult, fidl::Error>>
58        + Send;
59    fn r#get_metadata(&self) -> Self::GetMetadataResponseFut;
60}
61#[derive(Debug)]
62#[cfg(target_os = "fuchsia")]
63pub struct PartitionSynchronousProxy {
64    client: fidl::client::sync::Client,
65}
66
67#[cfg(target_os = "fuchsia")]
68impl fidl::endpoints::SynchronousProxy for PartitionSynchronousProxy {
69    type Proxy = PartitionProxy;
70    type Protocol = PartitionMarker;
71
72    fn from_channel(inner: fidl::Channel) -> Self {
73        Self::new(inner)
74    }
75
76    fn into_channel(self) -> fidl::Channel {
77        self.client.into_channel()
78    }
79
80    fn as_channel(&self) -> &fidl::Channel {
81        self.client.as_channel()
82    }
83}
84
85#[cfg(target_os = "fuchsia")]
86impl PartitionSynchronousProxy {
87    pub fn new(channel: fidl::Channel) -> Self {
88        let protocol_name = <PartitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
89        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
90    }
91
92    pub fn into_channel(self) -> fidl::Channel {
93        self.client.into_channel()
94    }
95
96    /// Waits until an event arrives and returns it. It is safe for other
97    /// threads to make concurrent requests while waiting for an event.
98    pub fn wait_for_event(
99        &self,
100        deadline: zx::MonotonicInstant,
101    ) -> Result<PartitionEvent, fidl::Error> {
102        PartitionEvent::decode(self.client.wait_for_event(deadline)?)
103    }
104
105    /// Get information about the underlying block device.
106    pub fn r#get_info(
107        &self,
108        ___deadline: zx::MonotonicInstant,
109    ) -> Result<fidl_fuchsia_hardware_block::BlockGetInfoResult, fidl::Error> {
110        let _response =
111            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
112                fidl_fuchsia_hardware_block::BlockGetInfoResponse,
113                i32,
114            >>(
115                (),
116                0x79df1a5cdb6cc6a3,
117                fidl::encoding::DynamicFlags::empty(),
118                ___deadline,
119            )?;
120        Ok(_response.map(|x| x.info))
121    }
122
123    /// Returns stats about block device operations. Setting `clear` will reset stats counters.
124    pub fn r#get_stats(
125        &self,
126        mut clear: bool,
127        ___deadline: zx::MonotonicInstant,
128    ) -> Result<fidl_fuchsia_hardware_block::BlockGetStatsResult, fidl::Error> {
129        let _response = self.client.send_query::<
130            fidl_fuchsia_hardware_block::BlockGetStatsRequest,
131            fidl::encoding::ResultType<fidl_fuchsia_hardware_block::BlockGetStatsResponse, i32>,
132        >(
133            (clear,),
134            0x53d9542a778385ae,
135            fidl::encoding::DynamicFlags::empty(),
136            ___deadline,
137        )?;
138        Ok(_response.map(|x| x.stats))
139    }
140
141    /// Opens a new FIFO-based session on the block device.
142    pub fn r#open_session(
143        &self,
144        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
145    ) -> Result<(), fidl::Error> {
146        self.client.send::<fidl_fuchsia_hardware_block::BlockOpenSessionRequest>(
147            (session,),
148            0x7241c68d17614a31,
149            fidl::encoding::DynamicFlags::empty(),
150        )
151    }
152
153    /// Opens a new FIFO-based session on the block device, providing an offset lookup map which
154    /// transparently translates device offsets in block FIFO requests.
155    ///
156    /// `initial_mappings` is a static set of mappings which the server can immediately use.  If
157    /// `offset_map` is not provided, this must be non-empty, and requests that fall outside of the
158    /// mapped range will fail.
159    ///
160    /// If `offset_map` is provided, whenever the server receives a request with a dev_offset that
161    /// falls outside of the known range, it will consult `offset_map` to attempt to resolve the
162    /// offset.  Because these offset mappings must be stable for the duration of the session, the
163    /// server may cache any mappings.
164    ///
165    /// This interface is intended to be used internally between nested Block implementations, in
166    /// order to provide passthrough I/O.  For example, a fixed partition map (e.g. GPT) will serve
167    /// a Block protocol for each partition, and will respond to OpenSession requests by calling
168    /// OpenSessionWithOffsetMap on the underlying block device, establishing itself as the source
169    /// for translating client block offsets (relative to the partition start) to absolute offsets.
170    /// The client can then communicate directly with the underlying block device, and the partition
171    /// offsets can be transparently applied to requests.
172    pub fn r#open_session_with_offset_map(
173        &self,
174        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
175        mut offset_map: Option<
176            fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_block::OffsetMapMarker>,
177        >,
178        mut initial_mappings: Option<&[fidl_fuchsia_hardware_block::BlockOffsetMapping]>,
179    ) -> Result<(), fidl::Error> {
180        self.client.send::<fidl_fuchsia_hardware_block::BlockOpenSessionWithOffsetMapRequest>(
181            (session, offset_map, initial_mappings),
182            0x7a8d3ba3d8bfa10f,
183            fidl::encoding::DynamicFlags::empty(),
184        )
185    }
186
187    /// Gets the type GUID of the partition (if one exists).
188    /// If the partition has no type GUID, ZX_ERR_NOT_SUPPORTED is returned.
189    pub fn r#get_type_guid(
190        &self,
191        ___deadline: zx::MonotonicInstant,
192    ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
193        let _response =
194            self.client.send_query::<fidl::encoding::EmptyPayload, PartitionGetTypeGuidResponse>(
195                (),
196                0x111843d737a9b847,
197                fidl::encoding::DynamicFlags::empty(),
198                ___deadline,
199            )?;
200        Ok((_response.status, _response.guid))
201    }
202
203    /// Gets the instance GUID of the partition (if one exists).
204    /// If the partition has no instance GUID, ZX_ERR_NOT_SUPPORTED is returned.
205    pub fn r#get_instance_guid(
206        &self,
207        ___deadline: zx::MonotonicInstant,
208    ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
209        let _response = self
210            .client
211            .send_query::<fidl::encoding::EmptyPayload, PartitionGetInstanceGuidResponse>(
212                (),
213                0x14a5a573b275d435,
214                fidl::encoding::DynamicFlags::empty(),
215                ___deadline,
216            )?;
217        Ok((_response.status, _response.guid))
218    }
219
220    /// Gets the name of the partition (if one exists).
221    /// If the partition has no name, ZX_ERR_NOT_SUPPORTED is returned.
222    pub fn r#get_name(
223        &self,
224        ___deadline: zx::MonotonicInstant,
225    ) -> Result<(i32, Option<String>), fidl::Error> {
226        let _response =
227            self.client.send_query::<fidl::encoding::EmptyPayload, PartitionGetNameResponse>(
228                (),
229                0x7e3c6f0b0937fc02,
230                fidl::encoding::DynamicFlags::empty(),
231                ___deadline,
232            )?;
233        Ok((_response.status, _response.name))
234    }
235
236    /// Gets the metadata for the partition.
237    ///
238    /// Fields may be absent if the partition doesn't have the given metadata.
239    pub fn r#get_metadata(
240        &self,
241        ___deadline: zx::MonotonicInstant,
242    ) -> Result<PartitionGetMetadataResult, fidl::Error> {
243        let _response = self.client.send_query::<
244            fidl::encoding::EmptyPayload,
245            fidl::encoding::ResultType<PartitionGetMetadataResponse, i32>,
246        >(
247            (),
248            0x42d1464c96c3f3ff,
249            fidl::encoding::DynamicFlags::empty(),
250            ___deadline,
251        )?;
252        Ok(_response.map(|x| x))
253    }
254}
255
256#[cfg(target_os = "fuchsia")]
257impl From<PartitionSynchronousProxy> for zx::Handle {
258    fn from(value: PartitionSynchronousProxy) -> Self {
259        value.into_channel().into()
260    }
261}
262
263#[cfg(target_os = "fuchsia")]
264impl From<fidl::Channel> for PartitionSynchronousProxy {
265    fn from(value: fidl::Channel) -> Self {
266        Self::new(value)
267    }
268}
269
270#[derive(Debug, Clone)]
271pub struct PartitionProxy {
272    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
273}
274
275impl fidl::endpoints::Proxy for PartitionProxy {
276    type Protocol = PartitionMarker;
277
278    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
279        Self::new(inner)
280    }
281
282    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
283        self.client.into_channel().map_err(|client| Self { client })
284    }
285
286    fn as_channel(&self) -> &::fidl::AsyncChannel {
287        self.client.as_channel()
288    }
289}
290
291impl PartitionProxy {
292    /// Create a new Proxy for fuchsia.hardware.block.partition/Partition.
293    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
294        let protocol_name = <PartitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
295        Self { client: fidl::client::Client::new(channel, protocol_name) }
296    }
297
298    /// Get a Stream of events from the remote end of the protocol.
299    ///
300    /// # Panics
301    ///
302    /// Panics if the event stream was already taken.
303    pub fn take_event_stream(&self) -> PartitionEventStream {
304        PartitionEventStream { event_receiver: self.client.take_event_receiver() }
305    }
306
307    /// Get information about the underlying block device.
308    pub fn r#get_info(
309        &self,
310    ) -> fidl::client::QueryResponseFut<
311        fidl_fuchsia_hardware_block::BlockGetInfoResult,
312        fidl::encoding::DefaultFuchsiaResourceDialect,
313    > {
314        PartitionProxyInterface::r#get_info(self)
315    }
316
317    /// Returns stats about block device operations. Setting `clear` will reset stats counters.
318    pub fn r#get_stats(
319        &self,
320        mut clear: bool,
321    ) -> fidl::client::QueryResponseFut<
322        fidl_fuchsia_hardware_block::BlockGetStatsResult,
323        fidl::encoding::DefaultFuchsiaResourceDialect,
324    > {
325        PartitionProxyInterface::r#get_stats(self, clear)
326    }
327
328    /// Opens a new FIFO-based session on the block device.
329    pub fn r#open_session(
330        &self,
331        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
332    ) -> Result<(), fidl::Error> {
333        PartitionProxyInterface::r#open_session(self, session)
334    }
335
336    /// Opens a new FIFO-based session on the block device, providing an offset lookup map which
337    /// transparently translates device offsets in block FIFO requests.
338    ///
339    /// `initial_mappings` is a static set of mappings which the server can immediately use.  If
340    /// `offset_map` is not provided, this must be non-empty, and requests that fall outside of the
341    /// mapped range will fail.
342    ///
343    /// If `offset_map` is provided, whenever the server receives a request with a dev_offset that
344    /// falls outside of the known range, it will consult `offset_map` to attempt to resolve the
345    /// offset.  Because these offset mappings must be stable for the duration of the session, the
346    /// server may cache any mappings.
347    ///
348    /// This interface is intended to be used internally between nested Block implementations, in
349    /// order to provide passthrough I/O.  For example, a fixed partition map (e.g. GPT) will serve
350    /// a Block protocol for each partition, and will respond to OpenSession requests by calling
351    /// OpenSessionWithOffsetMap on the underlying block device, establishing itself as the source
352    /// for translating client block offsets (relative to the partition start) to absolute offsets.
353    /// The client can then communicate directly with the underlying block device, and the partition
354    /// offsets can be transparently applied to requests.
355    pub fn r#open_session_with_offset_map(
356        &self,
357        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
358        mut offset_map: Option<
359            fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_block::OffsetMapMarker>,
360        >,
361        mut initial_mappings: Option<&[fidl_fuchsia_hardware_block::BlockOffsetMapping]>,
362    ) -> Result<(), fidl::Error> {
363        PartitionProxyInterface::r#open_session_with_offset_map(
364            self,
365            session,
366            offset_map,
367            initial_mappings,
368        )
369    }
370
371    /// Gets the type GUID of the partition (if one exists).
372    /// If the partition has no type GUID, ZX_ERR_NOT_SUPPORTED is returned.
373    pub fn r#get_type_guid(
374        &self,
375    ) -> fidl::client::QueryResponseFut<
376        (i32, Option<Box<Guid>>),
377        fidl::encoding::DefaultFuchsiaResourceDialect,
378    > {
379        PartitionProxyInterface::r#get_type_guid(self)
380    }
381
382    /// Gets the instance GUID of the partition (if one exists).
383    /// If the partition has no instance GUID, ZX_ERR_NOT_SUPPORTED is returned.
384    pub fn r#get_instance_guid(
385        &self,
386    ) -> fidl::client::QueryResponseFut<
387        (i32, Option<Box<Guid>>),
388        fidl::encoding::DefaultFuchsiaResourceDialect,
389    > {
390        PartitionProxyInterface::r#get_instance_guid(self)
391    }
392
393    /// Gets the name of the partition (if one exists).
394    /// If the partition has no name, ZX_ERR_NOT_SUPPORTED is returned.
395    pub fn r#get_name(
396        &self,
397    ) -> fidl::client::QueryResponseFut<
398        (i32, Option<String>),
399        fidl::encoding::DefaultFuchsiaResourceDialect,
400    > {
401        PartitionProxyInterface::r#get_name(self)
402    }
403
404    /// Gets the metadata for the partition.
405    ///
406    /// Fields may be absent if the partition doesn't have the given metadata.
407    pub fn r#get_metadata(
408        &self,
409    ) -> fidl::client::QueryResponseFut<
410        PartitionGetMetadataResult,
411        fidl::encoding::DefaultFuchsiaResourceDialect,
412    > {
413        PartitionProxyInterface::r#get_metadata(self)
414    }
415}
416
417impl PartitionProxyInterface for PartitionProxy {
418    type GetInfoResponseFut = fidl::client::QueryResponseFut<
419        fidl_fuchsia_hardware_block::BlockGetInfoResult,
420        fidl::encoding::DefaultFuchsiaResourceDialect,
421    >;
422    fn r#get_info(&self) -> Self::GetInfoResponseFut {
423        fn _decode(
424            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
425        ) -> Result<fidl_fuchsia_hardware_block::BlockGetInfoResult, fidl::Error> {
426            let _response = fidl::client::decode_transaction_body::<
427                fidl::encoding::ResultType<fidl_fuchsia_hardware_block::BlockGetInfoResponse, i32>,
428                fidl::encoding::DefaultFuchsiaResourceDialect,
429                0x79df1a5cdb6cc6a3,
430            >(_buf?)?;
431            Ok(_response.map(|x| x.info))
432        }
433        self.client.send_query_and_decode::<
434            fidl::encoding::EmptyPayload,
435            fidl_fuchsia_hardware_block::BlockGetInfoResult,
436        >(
437            (),
438            0x79df1a5cdb6cc6a3,
439            fidl::encoding::DynamicFlags::empty(),
440            _decode,
441        )
442    }
443
444    type GetStatsResponseFut = fidl::client::QueryResponseFut<
445        fidl_fuchsia_hardware_block::BlockGetStatsResult,
446        fidl::encoding::DefaultFuchsiaResourceDialect,
447    >;
448    fn r#get_stats(&self, mut clear: bool) -> Self::GetStatsResponseFut {
449        fn _decode(
450            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
451        ) -> Result<fidl_fuchsia_hardware_block::BlockGetStatsResult, fidl::Error> {
452            let _response = fidl::client::decode_transaction_body::<
453                fidl::encoding::ResultType<fidl_fuchsia_hardware_block::BlockGetStatsResponse, i32>,
454                fidl::encoding::DefaultFuchsiaResourceDialect,
455                0x53d9542a778385ae,
456            >(_buf?)?;
457            Ok(_response.map(|x| x.stats))
458        }
459        self.client.send_query_and_decode::<
460            fidl_fuchsia_hardware_block::BlockGetStatsRequest,
461            fidl_fuchsia_hardware_block::BlockGetStatsResult,
462        >(
463            (clear,),
464            0x53d9542a778385ae,
465            fidl::encoding::DynamicFlags::empty(),
466            _decode,
467        )
468    }
469
470    fn r#open_session(
471        &self,
472        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
473    ) -> Result<(), fidl::Error> {
474        self.client.send::<fidl_fuchsia_hardware_block::BlockOpenSessionRequest>(
475            (session,),
476            0x7241c68d17614a31,
477            fidl::encoding::DynamicFlags::empty(),
478        )
479    }
480
481    fn r#open_session_with_offset_map(
482        &self,
483        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
484        mut offset_map: Option<
485            fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_block::OffsetMapMarker>,
486        >,
487        mut initial_mappings: Option<&[fidl_fuchsia_hardware_block::BlockOffsetMapping]>,
488    ) -> Result<(), fidl::Error> {
489        self.client.send::<fidl_fuchsia_hardware_block::BlockOpenSessionWithOffsetMapRequest>(
490            (session, offset_map, initial_mappings),
491            0x7a8d3ba3d8bfa10f,
492            fidl::encoding::DynamicFlags::empty(),
493        )
494    }
495
496    type GetTypeGuidResponseFut = fidl::client::QueryResponseFut<
497        (i32, Option<Box<Guid>>),
498        fidl::encoding::DefaultFuchsiaResourceDialect,
499    >;
500    fn r#get_type_guid(&self) -> Self::GetTypeGuidResponseFut {
501        fn _decode(
502            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
503        ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
504            let _response = fidl::client::decode_transaction_body::<
505                PartitionGetTypeGuidResponse,
506                fidl::encoding::DefaultFuchsiaResourceDialect,
507                0x111843d737a9b847,
508            >(_buf?)?;
509            Ok((_response.status, _response.guid))
510        }
511        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<Box<Guid>>)>(
512            (),
513            0x111843d737a9b847,
514            fidl::encoding::DynamicFlags::empty(),
515            _decode,
516        )
517    }
518
519    type GetInstanceGuidResponseFut = fidl::client::QueryResponseFut<
520        (i32, Option<Box<Guid>>),
521        fidl::encoding::DefaultFuchsiaResourceDialect,
522    >;
523    fn r#get_instance_guid(&self) -> Self::GetInstanceGuidResponseFut {
524        fn _decode(
525            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
526        ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
527            let _response = fidl::client::decode_transaction_body::<
528                PartitionGetInstanceGuidResponse,
529                fidl::encoding::DefaultFuchsiaResourceDialect,
530                0x14a5a573b275d435,
531            >(_buf?)?;
532            Ok((_response.status, _response.guid))
533        }
534        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<Box<Guid>>)>(
535            (),
536            0x14a5a573b275d435,
537            fidl::encoding::DynamicFlags::empty(),
538            _decode,
539        )
540    }
541
542    type GetNameResponseFut = fidl::client::QueryResponseFut<
543        (i32, Option<String>),
544        fidl::encoding::DefaultFuchsiaResourceDialect,
545    >;
546    fn r#get_name(&self) -> Self::GetNameResponseFut {
547        fn _decode(
548            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
549        ) -> Result<(i32, Option<String>), fidl::Error> {
550            let _response = fidl::client::decode_transaction_body::<
551                PartitionGetNameResponse,
552                fidl::encoding::DefaultFuchsiaResourceDialect,
553                0x7e3c6f0b0937fc02,
554            >(_buf?)?;
555            Ok((_response.status, _response.name))
556        }
557        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<String>)>(
558            (),
559            0x7e3c6f0b0937fc02,
560            fidl::encoding::DynamicFlags::empty(),
561            _decode,
562        )
563    }
564
565    type GetMetadataResponseFut = fidl::client::QueryResponseFut<
566        PartitionGetMetadataResult,
567        fidl::encoding::DefaultFuchsiaResourceDialect,
568    >;
569    fn r#get_metadata(&self) -> Self::GetMetadataResponseFut {
570        fn _decode(
571            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
572        ) -> Result<PartitionGetMetadataResult, fidl::Error> {
573            let _response = fidl::client::decode_transaction_body::<
574                fidl::encoding::ResultType<PartitionGetMetadataResponse, i32>,
575                fidl::encoding::DefaultFuchsiaResourceDialect,
576                0x42d1464c96c3f3ff,
577            >(_buf?)?;
578            Ok(_response.map(|x| x))
579        }
580        self.client
581            .send_query_and_decode::<fidl::encoding::EmptyPayload, PartitionGetMetadataResult>(
582                (),
583                0x42d1464c96c3f3ff,
584                fidl::encoding::DynamicFlags::empty(),
585                _decode,
586            )
587    }
588}
589
590pub struct PartitionEventStream {
591    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
592}
593
594impl std::marker::Unpin for PartitionEventStream {}
595
596impl futures::stream::FusedStream for PartitionEventStream {
597    fn is_terminated(&self) -> bool {
598        self.event_receiver.is_terminated()
599    }
600}
601
602impl futures::Stream for PartitionEventStream {
603    type Item = Result<PartitionEvent, fidl::Error>;
604
605    fn poll_next(
606        mut self: std::pin::Pin<&mut Self>,
607        cx: &mut std::task::Context<'_>,
608    ) -> std::task::Poll<Option<Self::Item>> {
609        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
610            &mut self.event_receiver,
611            cx
612        )?) {
613            Some(buf) => std::task::Poll::Ready(Some(PartitionEvent::decode(buf))),
614            None => std::task::Poll::Ready(None),
615        }
616    }
617}
618
619#[derive(Debug)]
620pub enum PartitionEvent {}
621
622impl PartitionEvent {
623    /// Decodes a message buffer as a [`PartitionEvent`].
624    fn decode(
625        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
626    ) -> Result<PartitionEvent, fidl::Error> {
627        let (bytes, _handles) = buf.split_mut();
628        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
629        debug_assert_eq!(tx_header.tx_id, 0);
630        match tx_header.ordinal {
631            _ => Err(fidl::Error::UnknownOrdinal {
632                ordinal: tx_header.ordinal,
633                protocol_name: <PartitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
634            }),
635        }
636    }
637}
638
639/// A Stream of incoming requests for fuchsia.hardware.block.partition/Partition.
640pub struct PartitionRequestStream {
641    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
642    is_terminated: bool,
643}
644
645impl std::marker::Unpin for PartitionRequestStream {}
646
647impl futures::stream::FusedStream for PartitionRequestStream {
648    fn is_terminated(&self) -> bool {
649        self.is_terminated
650    }
651}
652
653impl fidl::endpoints::RequestStream for PartitionRequestStream {
654    type Protocol = PartitionMarker;
655    type ControlHandle = PartitionControlHandle;
656
657    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
658        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
659    }
660
661    fn control_handle(&self) -> Self::ControlHandle {
662        PartitionControlHandle { inner: self.inner.clone() }
663    }
664
665    fn into_inner(
666        self,
667    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
668    {
669        (self.inner, self.is_terminated)
670    }
671
672    fn from_inner(
673        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
674        is_terminated: bool,
675    ) -> Self {
676        Self { inner, is_terminated }
677    }
678}
679
680impl futures::Stream for PartitionRequestStream {
681    type Item = Result<PartitionRequest, fidl::Error>;
682
683    fn poll_next(
684        mut self: std::pin::Pin<&mut Self>,
685        cx: &mut std::task::Context<'_>,
686    ) -> std::task::Poll<Option<Self::Item>> {
687        let this = &mut *self;
688        if this.inner.check_shutdown(cx) {
689            this.is_terminated = true;
690            return std::task::Poll::Ready(None);
691        }
692        if this.is_terminated {
693            panic!("polled PartitionRequestStream after completion");
694        }
695        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
696            |bytes, handles| {
697                match this.inner.channel().read_etc(cx, bytes, handles) {
698                    std::task::Poll::Ready(Ok(())) => {}
699                    std::task::Poll::Pending => return std::task::Poll::Pending,
700                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
701                        this.is_terminated = true;
702                        return std::task::Poll::Ready(None);
703                    }
704                    std::task::Poll::Ready(Err(e)) => {
705                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
706                            e.into(),
707                        ))))
708                    }
709                }
710
711                // A message has been received from the channel
712                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
713
714                std::task::Poll::Ready(Some(match header.ordinal {
715                    0x79df1a5cdb6cc6a3 => {
716                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
717                        let mut req = fidl::new_empty!(
718                            fidl::encoding::EmptyPayload,
719                            fidl::encoding::DefaultFuchsiaResourceDialect
720                        );
721                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
722                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
723                        Ok(PartitionRequest::GetInfo {
724                            responder: PartitionGetInfoResponder {
725                                control_handle: std::mem::ManuallyDrop::new(control_handle),
726                                tx_id: header.tx_id,
727                            },
728                        })
729                    }
730                    0x53d9542a778385ae => {
731                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
732                        let mut req = fidl::new_empty!(
733                            fidl_fuchsia_hardware_block::BlockGetStatsRequest,
734                            fidl::encoding::DefaultFuchsiaResourceDialect
735                        );
736                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_block::BlockGetStatsRequest>(&header, _body_bytes, handles, &mut req)?;
737                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
738                        Ok(PartitionRequest::GetStats {
739                            clear: req.clear,
740
741                            responder: PartitionGetStatsResponder {
742                                control_handle: std::mem::ManuallyDrop::new(control_handle),
743                                tx_id: header.tx_id,
744                            },
745                        })
746                    }
747                    0x7241c68d17614a31 => {
748                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
749                        let mut req = fidl::new_empty!(
750                            fidl_fuchsia_hardware_block::BlockOpenSessionRequest,
751                            fidl::encoding::DefaultFuchsiaResourceDialect
752                        );
753                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_block::BlockOpenSessionRequest>(&header, _body_bytes, handles, &mut req)?;
754                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
755                        Ok(PartitionRequest::OpenSession { session: req.session, control_handle })
756                    }
757                    0x7a8d3ba3d8bfa10f => {
758                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
759                        let mut req = fidl::new_empty!(
760                            fidl_fuchsia_hardware_block::BlockOpenSessionWithOffsetMapRequest,
761                            fidl::encoding::DefaultFuchsiaResourceDialect
762                        );
763                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_block::BlockOpenSessionWithOffsetMapRequest>(&header, _body_bytes, handles, &mut req)?;
764                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
765                        Ok(PartitionRequest::OpenSessionWithOffsetMap {
766                            session: req.session,
767                            offset_map: req.offset_map,
768                            initial_mappings: req.initial_mappings,
769
770                            control_handle,
771                        })
772                    }
773                    0x111843d737a9b847 => {
774                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
775                        let mut req = fidl::new_empty!(
776                            fidl::encoding::EmptyPayload,
777                            fidl::encoding::DefaultFuchsiaResourceDialect
778                        );
779                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
780                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
781                        Ok(PartitionRequest::GetTypeGuid {
782                            responder: PartitionGetTypeGuidResponder {
783                                control_handle: std::mem::ManuallyDrop::new(control_handle),
784                                tx_id: header.tx_id,
785                            },
786                        })
787                    }
788                    0x14a5a573b275d435 => {
789                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
790                        let mut req = fidl::new_empty!(
791                            fidl::encoding::EmptyPayload,
792                            fidl::encoding::DefaultFuchsiaResourceDialect
793                        );
794                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
795                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
796                        Ok(PartitionRequest::GetInstanceGuid {
797                            responder: PartitionGetInstanceGuidResponder {
798                                control_handle: std::mem::ManuallyDrop::new(control_handle),
799                                tx_id: header.tx_id,
800                            },
801                        })
802                    }
803                    0x7e3c6f0b0937fc02 => {
804                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
805                        let mut req = fidl::new_empty!(
806                            fidl::encoding::EmptyPayload,
807                            fidl::encoding::DefaultFuchsiaResourceDialect
808                        );
809                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
810                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
811                        Ok(PartitionRequest::GetName {
812                            responder: PartitionGetNameResponder {
813                                control_handle: std::mem::ManuallyDrop::new(control_handle),
814                                tx_id: header.tx_id,
815                            },
816                        })
817                    }
818                    0x42d1464c96c3f3ff => {
819                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
820                        let mut req = fidl::new_empty!(
821                            fidl::encoding::EmptyPayload,
822                            fidl::encoding::DefaultFuchsiaResourceDialect
823                        );
824                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
825                        let control_handle = PartitionControlHandle { inner: this.inner.clone() };
826                        Ok(PartitionRequest::GetMetadata {
827                            responder: PartitionGetMetadataResponder {
828                                control_handle: std::mem::ManuallyDrop::new(control_handle),
829                                tx_id: header.tx_id,
830                            },
831                        })
832                    }
833                    _ => Err(fidl::Error::UnknownOrdinal {
834                        ordinal: header.ordinal,
835                        protocol_name:
836                            <PartitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
837                    }),
838                }))
839            },
840        )
841    }
842}
843
844/// Partition describes a region of one or more block devices, labelled
845/// with distinguishing identifiers.
846#[derive(Debug)]
847pub enum PartitionRequest {
848    /// Get information about the underlying block device.
849    GetInfo { responder: PartitionGetInfoResponder },
850    /// Returns stats about block device operations. Setting `clear` will reset stats counters.
851    GetStats { clear: bool, responder: PartitionGetStatsResponder },
852    /// Opens a new FIFO-based session on the block device.
853    OpenSession {
854        session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
855        control_handle: PartitionControlHandle,
856    },
857    /// Opens a new FIFO-based session on the block device, providing an offset lookup map which
858    /// transparently translates device offsets in block FIFO requests.
859    ///
860    /// `initial_mappings` is a static set of mappings which the server can immediately use.  If
861    /// `offset_map` is not provided, this must be non-empty, and requests that fall outside of the
862    /// mapped range will fail.
863    ///
864    /// If `offset_map` is provided, whenever the server receives a request with a dev_offset that
865    /// falls outside of the known range, it will consult `offset_map` to attempt to resolve the
866    /// offset.  Because these offset mappings must be stable for the duration of the session, the
867    /// server may cache any mappings.
868    ///
869    /// This interface is intended to be used internally between nested Block implementations, in
870    /// order to provide passthrough I/O.  For example, a fixed partition map (e.g. GPT) will serve
871    /// a Block protocol for each partition, and will respond to OpenSession requests by calling
872    /// OpenSessionWithOffsetMap on the underlying block device, establishing itself as the source
873    /// for translating client block offsets (relative to the partition start) to absolute offsets.
874    /// The client can then communicate directly with the underlying block device, and the partition
875    /// offsets can be transparently applied to requests.
876    OpenSessionWithOffsetMap {
877        session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
878        offset_map:
879            Option<fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_block::OffsetMapMarker>>,
880        initial_mappings: Option<Vec<fidl_fuchsia_hardware_block::BlockOffsetMapping>>,
881        control_handle: PartitionControlHandle,
882    },
883    /// Gets the type GUID of the partition (if one exists).
884    /// If the partition has no type GUID, ZX_ERR_NOT_SUPPORTED is returned.
885    GetTypeGuid { responder: PartitionGetTypeGuidResponder },
886    /// Gets the instance GUID of the partition (if one exists).
887    /// If the partition has no instance GUID, ZX_ERR_NOT_SUPPORTED is returned.
888    GetInstanceGuid { responder: PartitionGetInstanceGuidResponder },
889    /// Gets the name of the partition (if one exists).
890    /// If the partition has no name, ZX_ERR_NOT_SUPPORTED is returned.
891    GetName { responder: PartitionGetNameResponder },
892    /// Gets the metadata for the partition.
893    ///
894    /// Fields may be absent if the partition doesn't have the given metadata.
895    GetMetadata { responder: PartitionGetMetadataResponder },
896}
897
898impl PartitionRequest {
899    #[allow(irrefutable_let_patterns)]
900    pub fn into_get_info(self) -> Option<(PartitionGetInfoResponder)> {
901        if let PartitionRequest::GetInfo { responder } = self {
902            Some((responder))
903        } else {
904            None
905        }
906    }
907
908    #[allow(irrefutable_let_patterns)]
909    pub fn into_get_stats(self) -> Option<(bool, PartitionGetStatsResponder)> {
910        if let PartitionRequest::GetStats { clear, responder } = self {
911            Some((clear, responder))
912        } else {
913            None
914        }
915    }
916
917    #[allow(irrefutable_let_patterns)]
918    pub fn into_open_session(
919        self,
920    ) -> Option<(
921        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
922        PartitionControlHandle,
923    )> {
924        if let PartitionRequest::OpenSession { session, control_handle } = self {
925            Some((session, control_handle))
926        } else {
927            None
928        }
929    }
930
931    #[allow(irrefutable_let_patterns)]
932    pub fn into_open_session_with_offset_map(
933        self,
934    ) -> Option<(
935        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block::SessionMarker>,
936        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_block::OffsetMapMarker>>,
937        Option<Vec<fidl_fuchsia_hardware_block::BlockOffsetMapping>>,
938        PartitionControlHandle,
939    )> {
940        if let PartitionRequest::OpenSessionWithOffsetMap {
941            session,
942            offset_map,
943            initial_mappings,
944            control_handle,
945        } = self
946        {
947            Some((session, offset_map, initial_mappings, control_handle))
948        } else {
949            None
950        }
951    }
952
953    #[allow(irrefutable_let_patterns)]
954    pub fn into_get_type_guid(self) -> Option<(PartitionGetTypeGuidResponder)> {
955        if let PartitionRequest::GetTypeGuid { responder } = self {
956            Some((responder))
957        } else {
958            None
959        }
960    }
961
962    #[allow(irrefutable_let_patterns)]
963    pub fn into_get_instance_guid(self) -> Option<(PartitionGetInstanceGuidResponder)> {
964        if let PartitionRequest::GetInstanceGuid { responder } = self {
965            Some((responder))
966        } else {
967            None
968        }
969    }
970
971    #[allow(irrefutable_let_patterns)]
972    pub fn into_get_name(self) -> Option<(PartitionGetNameResponder)> {
973        if let PartitionRequest::GetName { responder } = self {
974            Some((responder))
975        } else {
976            None
977        }
978    }
979
980    #[allow(irrefutable_let_patterns)]
981    pub fn into_get_metadata(self) -> Option<(PartitionGetMetadataResponder)> {
982        if let PartitionRequest::GetMetadata { responder } = self {
983            Some((responder))
984        } else {
985            None
986        }
987    }
988
989    /// Name of the method defined in FIDL
990    pub fn method_name(&self) -> &'static str {
991        match *self {
992            PartitionRequest::GetInfo { .. } => "get_info",
993            PartitionRequest::GetStats { .. } => "get_stats",
994            PartitionRequest::OpenSession { .. } => "open_session",
995            PartitionRequest::OpenSessionWithOffsetMap { .. } => "open_session_with_offset_map",
996            PartitionRequest::GetTypeGuid { .. } => "get_type_guid",
997            PartitionRequest::GetInstanceGuid { .. } => "get_instance_guid",
998            PartitionRequest::GetName { .. } => "get_name",
999            PartitionRequest::GetMetadata { .. } => "get_metadata",
1000        }
1001    }
1002}
1003
1004#[derive(Debug, Clone)]
1005pub struct PartitionControlHandle {
1006    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1007}
1008
1009impl fidl::endpoints::ControlHandle for PartitionControlHandle {
1010    fn shutdown(&self) {
1011        self.inner.shutdown()
1012    }
1013    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1014        self.inner.shutdown_with_epitaph(status)
1015    }
1016
1017    fn is_closed(&self) -> bool {
1018        self.inner.channel().is_closed()
1019    }
1020    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1021        self.inner.channel().on_closed()
1022    }
1023
1024    #[cfg(target_os = "fuchsia")]
1025    fn signal_peer(
1026        &self,
1027        clear_mask: zx::Signals,
1028        set_mask: zx::Signals,
1029    ) -> Result<(), zx_status::Status> {
1030        use fidl::Peered;
1031        self.inner.channel().signal_peer(clear_mask, set_mask)
1032    }
1033}
1034
1035impl PartitionControlHandle {}
1036
1037#[must_use = "FIDL methods require a response to be sent"]
1038#[derive(Debug)]
1039pub struct PartitionGetInfoResponder {
1040    control_handle: std::mem::ManuallyDrop<PartitionControlHandle>,
1041    tx_id: u32,
1042}
1043
1044/// Set the the channel to be shutdown (see [`PartitionControlHandle::shutdown`])
1045/// if the responder is dropped without sending a response, so that the client
1046/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1047impl std::ops::Drop for PartitionGetInfoResponder {
1048    fn drop(&mut self) {
1049        self.control_handle.shutdown();
1050        // Safety: drops once, never accessed again
1051        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1052    }
1053}
1054
1055impl fidl::endpoints::Responder for PartitionGetInfoResponder {
1056    type ControlHandle = PartitionControlHandle;
1057
1058    fn control_handle(&self) -> &PartitionControlHandle {
1059        &self.control_handle
1060    }
1061
1062    fn drop_without_shutdown(mut self) {
1063        // Safety: drops once, never accessed again due to mem::forget
1064        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1065        // Prevent Drop from running (which would shut down the channel)
1066        std::mem::forget(self);
1067    }
1068}
1069
1070impl PartitionGetInfoResponder {
1071    /// Sends a response to the FIDL transaction.
1072    ///
1073    /// Sets the channel to shutdown if an error occurs.
1074    pub fn send(
1075        self,
1076        mut result: Result<&fidl_fuchsia_hardware_block::BlockInfo, i32>,
1077    ) -> Result<(), fidl::Error> {
1078        let _result = self.send_raw(result);
1079        if _result.is_err() {
1080            self.control_handle.shutdown();
1081        }
1082        self.drop_without_shutdown();
1083        _result
1084    }
1085
1086    /// Similar to "send" but does not shutdown the channel if an error occurs.
1087    pub fn send_no_shutdown_on_err(
1088        self,
1089        mut result: Result<&fidl_fuchsia_hardware_block::BlockInfo, i32>,
1090    ) -> Result<(), fidl::Error> {
1091        let _result = self.send_raw(result);
1092        self.drop_without_shutdown();
1093        _result
1094    }
1095
1096    fn send_raw(
1097        &self,
1098        mut result: Result<&fidl_fuchsia_hardware_block::BlockInfo, i32>,
1099    ) -> Result<(), fidl::Error> {
1100        self.control_handle.inner.send::<fidl::encoding::ResultType<
1101            fidl_fuchsia_hardware_block::BlockGetInfoResponse,
1102            i32,
1103        >>(
1104            result.map(|info| (info,)),
1105            self.tx_id,
1106            0x79df1a5cdb6cc6a3,
1107            fidl::encoding::DynamicFlags::empty(),
1108        )
1109    }
1110}
1111
1112#[must_use = "FIDL methods require a response to be sent"]
1113#[derive(Debug)]
1114pub struct PartitionGetStatsResponder {
1115    control_handle: std::mem::ManuallyDrop<PartitionControlHandle>,
1116    tx_id: u32,
1117}
1118
1119/// Set the the channel to be shutdown (see [`PartitionControlHandle::shutdown`])
1120/// if the responder is dropped without sending a response, so that the client
1121/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1122impl std::ops::Drop for PartitionGetStatsResponder {
1123    fn drop(&mut self) {
1124        self.control_handle.shutdown();
1125        // Safety: drops once, never accessed again
1126        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1127    }
1128}
1129
1130impl fidl::endpoints::Responder for PartitionGetStatsResponder {
1131    type ControlHandle = PartitionControlHandle;
1132
1133    fn control_handle(&self) -> &PartitionControlHandle {
1134        &self.control_handle
1135    }
1136
1137    fn drop_without_shutdown(mut self) {
1138        // Safety: drops once, never accessed again due to mem::forget
1139        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1140        // Prevent Drop from running (which would shut down the channel)
1141        std::mem::forget(self);
1142    }
1143}
1144
1145impl PartitionGetStatsResponder {
1146    /// Sends a response to the FIDL transaction.
1147    ///
1148    /// Sets the channel to shutdown if an error occurs.
1149    pub fn send(
1150        self,
1151        mut result: Result<&fidl_fuchsia_hardware_block::BlockStats, i32>,
1152    ) -> Result<(), fidl::Error> {
1153        let _result = self.send_raw(result);
1154        if _result.is_err() {
1155            self.control_handle.shutdown();
1156        }
1157        self.drop_without_shutdown();
1158        _result
1159    }
1160
1161    /// Similar to "send" but does not shutdown the channel if an error occurs.
1162    pub fn send_no_shutdown_on_err(
1163        self,
1164        mut result: Result<&fidl_fuchsia_hardware_block::BlockStats, i32>,
1165    ) -> Result<(), fidl::Error> {
1166        let _result = self.send_raw(result);
1167        self.drop_without_shutdown();
1168        _result
1169    }
1170
1171    fn send_raw(
1172        &self,
1173        mut result: Result<&fidl_fuchsia_hardware_block::BlockStats, i32>,
1174    ) -> Result<(), fidl::Error> {
1175        self.control_handle.inner.send::<fidl::encoding::ResultType<
1176            fidl_fuchsia_hardware_block::BlockGetStatsResponse,
1177            i32,
1178        >>(
1179            result.map(|stats| (stats,)),
1180            self.tx_id,
1181            0x53d9542a778385ae,
1182            fidl::encoding::DynamicFlags::empty(),
1183        )
1184    }
1185}
1186
1187#[must_use = "FIDL methods require a response to be sent"]
1188#[derive(Debug)]
1189pub struct PartitionGetTypeGuidResponder {
1190    control_handle: std::mem::ManuallyDrop<PartitionControlHandle>,
1191    tx_id: u32,
1192}
1193
1194/// Set the the channel to be shutdown (see [`PartitionControlHandle::shutdown`])
1195/// if the responder is dropped without sending a response, so that the client
1196/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1197impl std::ops::Drop for PartitionGetTypeGuidResponder {
1198    fn drop(&mut self) {
1199        self.control_handle.shutdown();
1200        // Safety: drops once, never accessed again
1201        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1202    }
1203}
1204
1205impl fidl::endpoints::Responder for PartitionGetTypeGuidResponder {
1206    type ControlHandle = PartitionControlHandle;
1207
1208    fn control_handle(&self) -> &PartitionControlHandle {
1209        &self.control_handle
1210    }
1211
1212    fn drop_without_shutdown(mut self) {
1213        // Safety: drops once, never accessed again due to mem::forget
1214        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1215        // Prevent Drop from running (which would shut down the channel)
1216        std::mem::forget(self);
1217    }
1218}
1219
1220impl PartitionGetTypeGuidResponder {
1221    /// Sends a response to the FIDL transaction.
1222    ///
1223    /// Sets the channel to shutdown if an error occurs.
1224    pub fn send(self, mut status: i32, mut guid: Option<&Guid>) -> Result<(), fidl::Error> {
1225        let _result = self.send_raw(status, guid);
1226        if _result.is_err() {
1227            self.control_handle.shutdown();
1228        }
1229        self.drop_without_shutdown();
1230        _result
1231    }
1232
1233    /// Similar to "send" but does not shutdown the channel if an error occurs.
1234    pub fn send_no_shutdown_on_err(
1235        self,
1236        mut status: i32,
1237        mut guid: Option<&Guid>,
1238    ) -> Result<(), fidl::Error> {
1239        let _result = self.send_raw(status, guid);
1240        self.drop_without_shutdown();
1241        _result
1242    }
1243
1244    fn send_raw(&self, mut status: i32, mut guid: Option<&Guid>) -> Result<(), fidl::Error> {
1245        self.control_handle.inner.send::<PartitionGetTypeGuidResponse>(
1246            (status, guid),
1247            self.tx_id,
1248            0x111843d737a9b847,
1249            fidl::encoding::DynamicFlags::empty(),
1250        )
1251    }
1252}
1253
1254#[must_use = "FIDL methods require a response to be sent"]
1255#[derive(Debug)]
1256pub struct PartitionGetInstanceGuidResponder {
1257    control_handle: std::mem::ManuallyDrop<PartitionControlHandle>,
1258    tx_id: u32,
1259}
1260
1261/// Set the the channel to be shutdown (see [`PartitionControlHandle::shutdown`])
1262/// if the responder is dropped without sending a response, so that the client
1263/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1264impl std::ops::Drop for PartitionGetInstanceGuidResponder {
1265    fn drop(&mut self) {
1266        self.control_handle.shutdown();
1267        // Safety: drops once, never accessed again
1268        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1269    }
1270}
1271
1272impl fidl::endpoints::Responder for PartitionGetInstanceGuidResponder {
1273    type ControlHandle = PartitionControlHandle;
1274
1275    fn control_handle(&self) -> &PartitionControlHandle {
1276        &self.control_handle
1277    }
1278
1279    fn drop_without_shutdown(mut self) {
1280        // Safety: drops once, never accessed again due to mem::forget
1281        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1282        // Prevent Drop from running (which would shut down the channel)
1283        std::mem::forget(self);
1284    }
1285}
1286
1287impl PartitionGetInstanceGuidResponder {
1288    /// Sends a response to the FIDL transaction.
1289    ///
1290    /// Sets the channel to shutdown if an error occurs.
1291    pub fn send(self, mut status: i32, mut guid: Option<&Guid>) -> Result<(), fidl::Error> {
1292        let _result = self.send_raw(status, guid);
1293        if _result.is_err() {
1294            self.control_handle.shutdown();
1295        }
1296        self.drop_without_shutdown();
1297        _result
1298    }
1299
1300    /// Similar to "send" but does not shutdown the channel if an error occurs.
1301    pub fn send_no_shutdown_on_err(
1302        self,
1303        mut status: i32,
1304        mut guid: Option<&Guid>,
1305    ) -> Result<(), fidl::Error> {
1306        let _result = self.send_raw(status, guid);
1307        self.drop_without_shutdown();
1308        _result
1309    }
1310
1311    fn send_raw(&self, mut status: i32, mut guid: Option<&Guid>) -> Result<(), fidl::Error> {
1312        self.control_handle.inner.send::<PartitionGetInstanceGuidResponse>(
1313            (status, guid),
1314            self.tx_id,
1315            0x14a5a573b275d435,
1316            fidl::encoding::DynamicFlags::empty(),
1317        )
1318    }
1319}
1320
1321#[must_use = "FIDL methods require a response to be sent"]
1322#[derive(Debug)]
1323pub struct PartitionGetNameResponder {
1324    control_handle: std::mem::ManuallyDrop<PartitionControlHandle>,
1325    tx_id: u32,
1326}
1327
1328/// Set the the channel to be shutdown (see [`PartitionControlHandle::shutdown`])
1329/// if the responder is dropped without sending a response, so that the client
1330/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1331impl std::ops::Drop for PartitionGetNameResponder {
1332    fn drop(&mut self) {
1333        self.control_handle.shutdown();
1334        // Safety: drops once, never accessed again
1335        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1336    }
1337}
1338
1339impl fidl::endpoints::Responder for PartitionGetNameResponder {
1340    type ControlHandle = PartitionControlHandle;
1341
1342    fn control_handle(&self) -> &PartitionControlHandle {
1343        &self.control_handle
1344    }
1345
1346    fn drop_without_shutdown(mut self) {
1347        // Safety: drops once, never accessed again due to mem::forget
1348        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1349        // Prevent Drop from running (which would shut down the channel)
1350        std::mem::forget(self);
1351    }
1352}
1353
1354impl PartitionGetNameResponder {
1355    /// Sends a response to the FIDL transaction.
1356    ///
1357    /// Sets the channel to shutdown if an error occurs.
1358    pub fn send(self, mut status: i32, mut name: Option<&str>) -> Result<(), fidl::Error> {
1359        let _result = self.send_raw(status, name);
1360        if _result.is_err() {
1361            self.control_handle.shutdown();
1362        }
1363        self.drop_without_shutdown();
1364        _result
1365    }
1366
1367    /// Similar to "send" but does not shutdown the channel if an error occurs.
1368    pub fn send_no_shutdown_on_err(
1369        self,
1370        mut status: i32,
1371        mut name: Option<&str>,
1372    ) -> Result<(), fidl::Error> {
1373        let _result = self.send_raw(status, name);
1374        self.drop_without_shutdown();
1375        _result
1376    }
1377
1378    fn send_raw(&self, mut status: i32, mut name: Option<&str>) -> Result<(), fidl::Error> {
1379        self.control_handle.inner.send::<PartitionGetNameResponse>(
1380            (status, name),
1381            self.tx_id,
1382            0x7e3c6f0b0937fc02,
1383            fidl::encoding::DynamicFlags::empty(),
1384        )
1385    }
1386}
1387
1388#[must_use = "FIDL methods require a response to be sent"]
1389#[derive(Debug)]
1390pub struct PartitionGetMetadataResponder {
1391    control_handle: std::mem::ManuallyDrop<PartitionControlHandle>,
1392    tx_id: u32,
1393}
1394
1395/// Set the the channel to be shutdown (see [`PartitionControlHandle::shutdown`])
1396/// if the responder is dropped without sending a response, so that the client
1397/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1398impl std::ops::Drop for PartitionGetMetadataResponder {
1399    fn drop(&mut self) {
1400        self.control_handle.shutdown();
1401        // Safety: drops once, never accessed again
1402        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1403    }
1404}
1405
1406impl fidl::endpoints::Responder for PartitionGetMetadataResponder {
1407    type ControlHandle = PartitionControlHandle;
1408
1409    fn control_handle(&self) -> &PartitionControlHandle {
1410        &self.control_handle
1411    }
1412
1413    fn drop_without_shutdown(mut self) {
1414        // Safety: drops once, never accessed again due to mem::forget
1415        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1416        // Prevent Drop from running (which would shut down the channel)
1417        std::mem::forget(self);
1418    }
1419}
1420
1421impl PartitionGetMetadataResponder {
1422    /// Sends a response to the FIDL transaction.
1423    ///
1424    /// Sets the channel to shutdown if an error occurs.
1425    pub fn send(
1426        self,
1427        mut result: Result<&PartitionGetMetadataResponse, i32>,
1428    ) -> Result<(), fidl::Error> {
1429        let _result = self.send_raw(result);
1430        if _result.is_err() {
1431            self.control_handle.shutdown();
1432        }
1433        self.drop_without_shutdown();
1434        _result
1435    }
1436
1437    /// Similar to "send" but does not shutdown the channel if an error occurs.
1438    pub fn send_no_shutdown_on_err(
1439        self,
1440        mut result: Result<&PartitionGetMetadataResponse, i32>,
1441    ) -> Result<(), fidl::Error> {
1442        let _result = self.send_raw(result);
1443        self.drop_without_shutdown();
1444        _result
1445    }
1446
1447    fn send_raw(
1448        &self,
1449        mut result: Result<&PartitionGetMetadataResponse, i32>,
1450    ) -> Result<(), fidl::Error> {
1451        self.control_handle
1452            .inner
1453            .send::<fidl::encoding::ResultType<PartitionGetMetadataResponse, i32>>(
1454                result,
1455                self.tx_id,
1456                0x42d1464c96c3f3ff,
1457                fidl::encoding::DynamicFlags::empty(),
1458            )
1459    }
1460}
1461
1462mod internal {
1463    use super::*;
1464}
fidl_fuchsia_hardware_block_partition/fidl_fuchsia_hardware_block_partition.rs

fidl_fuchsia_hardware_block_partition/
fidl_fuchsia_hardware_block_partition.rs
