fidl_fuchsia_diagnostics_host/
fidl_fuchsia_diagnostics_host.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_diagnostics_host_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ArchiveAccessorStreamDiagnosticsRequest {
16    pub parameters: fidl_fuchsia_diagnostics::StreamParameters,
17    pub stream: fidl::Socket,
18}
19
20impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
21    for ArchiveAccessorStreamDiagnosticsRequest
22{
23}
24
25#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
26pub struct ArchiveAccessorMarker;
27
28impl fidl::endpoints::ProtocolMarker for ArchiveAccessorMarker {
29    type Proxy = ArchiveAccessorProxy;
30    type RequestStream = ArchiveAccessorRequestStream;
31    #[cfg(target_os = "fuchsia")]
32    type SynchronousProxy = ArchiveAccessorSynchronousProxy;
33
34    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.host.ArchiveAccessor";
35}
36impl fidl::endpoints::DiscoverableProtocolMarker for ArchiveAccessorMarker {}
37
38pub trait ArchiveAccessorProxyInterface: Send + Sync {
39    type StreamDiagnosticsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
40    fn r#stream_diagnostics(
41        &self,
42        parameters: &fidl_fuchsia_diagnostics::StreamParameters,
43        stream: fidl::Socket,
44    ) -> Self::StreamDiagnosticsResponseFut;
45}
46#[derive(Debug)]
47#[cfg(target_os = "fuchsia")]
48pub struct ArchiveAccessorSynchronousProxy {
49    client: fidl::client::sync::Client,
50}
51
52#[cfg(target_os = "fuchsia")]
53impl fidl::endpoints::SynchronousProxy for ArchiveAccessorSynchronousProxy {
54    type Proxy = ArchiveAccessorProxy;
55    type Protocol = ArchiveAccessorMarker;
56
57    fn from_channel(inner: fidl::Channel) -> Self {
58        Self::new(inner)
59    }
60
61    fn into_channel(self) -> fidl::Channel {
62        self.client.into_channel()
63    }
64
65    fn as_channel(&self) -> &fidl::Channel {
66        self.client.as_channel()
67    }
68}
69
70#[cfg(target_os = "fuchsia")]
71impl ArchiveAccessorSynchronousProxy {
72    pub fn new(channel: fidl::Channel) -> Self {
73        let protocol_name = <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
74        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
75    }
76
77    pub fn into_channel(self) -> fidl::Channel {
78        self.client.into_channel()
79    }
80
81    /// Waits until an event arrives and returns it. It is safe for other
82    /// threads to make concurrent requests while waiting for an event.
83    pub fn wait_for_event(
84        &self,
85        deadline: zx::MonotonicInstant,
86    ) -> Result<ArchiveAccessorEvent, fidl::Error> {
87        ArchiveAccessorEvent::decode(self.client.wait_for_event(deadline)?)
88    }
89
90    /// Creates an iterator over diagnostics data on the system.
91    ///   * The iterator may be finite by streaming in SNAPSHOT mode, serving only the
92    ///     current state of diagnostics data on the system.
93    ///   * The iterator may be infinite by streaming in either SNAPSHOT_THEN_SUBSCRIBE
94    ///     or SUBSCRIBE mode; the prior first provides iteration over the current state of
95    ///     the sytem, and then both provide ongoing iteration over newly arriving diagnostics
96    ///     data.
97    ///
98    /// `stream` is a socket that diagnostic records are exposed to the client over.
99    ///
100    /// `parameters` is a [fuchsia.diagnostics/StreamParameter] which
101    ///   specifies how to configure the stream.
102    ///
103    /// The stream will carry data using the format documented in
104    /// [Diagnostics schema][https://fuchsia.dev/fuchsia-src/reference/platform-spec/diagnostics/schema]
105    pub fn r#stream_diagnostics(
106        &self,
107        mut parameters: &fidl_fuchsia_diagnostics::StreamParameters,
108        mut stream: fidl::Socket,
109        ___deadline: zx::MonotonicInstant,
110    ) -> Result<(), fidl::Error> {
111        let _response = self.client.send_query::<
112            ArchiveAccessorStreamDiagnosticsRequest,
113            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
114        >(
115            (parameters, stream,),
116            0x29635237a23c495b,
117            fidl::encoding::DynamicFlags::FLEXIBLE,
118            ___deadline,
119        )?
120        .into_result::<ArchiveAccessorMarker>("stream_diagnostics")?;
121        Ok(_response)
122    }
123}
124
125#[cfg(target_os = "fuchsia")]
126impl From<ArchiveAccessorSynchronousProxy> for zx::Handle {
127    fn from(value: ArchiveAccessorSynchronousProxy) -> Self {
128        value.into_channel().into()
129    }
130}
131
132#[cfg(target_os = "fuchsia")]
133impl From<fidl::Channel> for ArchiveAccessorSynchronousProxy {
134    fn from(value: fidl::Channel) -> Self {
135        Self::new(value)
136    }
137}
138
139#[derive(Debug, Clone)]
140pub struct ArchiveAccessorProxy {
141    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
142}
143
144impl fidl::endpoints::Proxy for ArchiveAccessorProxy {
145    type Protocol = ArchiveAccessorMarker;
146
147    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
148        Self::new(inner)
149    }
150
151    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
152        self.client.into_channel().map_err(|client| Self { client })
153    }
154
155    fn as_channel(&self) -> &::fidl::AsyncChannel {
156        self.client.as_channel()
157    }
158}
159
160impl ArchiveAccessorProxy {
161    /// Create a new Proxy for fuchsia.diagnostics.host/ArchiveAccessor.
162    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
163        let protocol_name = <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
164        Self { client: fidl::client::Client::new(channel, protocol_name) }
165    }
166
167    /// Get a Stream of events from the remote end of the protocol.
168    ///
169    /// # Panics
170    ///
171    /// Panics if the event stream was already taken.
172    pub fn take_event_stream(&self) -> ArchiveAccessorEventStream {
173        ArchiveAccessorEventStream { event_receiver: self.client.take_event_receiver() }
174    }
175
176    /// Creates an iterator over diagnostics data on the system.
177    ///   * The iterator may be finite by streaming in SNAPSHOT mode, serving only the
178    ///     current state of diagnostics data on the system.
179    ///   * The iterator may be infinite by streaming in either SNAPSHOT_THEN_SUBSCRIBE
180    ///     or SUBSCRIBE mode; the prior first provides iteration over the current state of
181    ///     the sytem, and then both provide ongoing iteration over newly arriving diagnostics
182    ///     data.
183    ///
184    /// `stream` is a socket that diagnostic records are exposed to the client over.
185    ///
186    /// `parameters` is a [fuchsia.diagnostics/StreamParameter] which
187    ///   specifies how to configure the stream.
188    ///
189    /// The stream will carry data using the format documented in
190    /// [Diagnostics schema][https://fuchsia.dev/fuchsia-src/reference/platform-spec/diagnostics/schema]
191    pub fn r#stream_diagnostics(
192        &self,
193        mut parameters: &fidl_fuchsia_diagnostics::StreamParameters,
194        mut stream: fidl::Socket,
195    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
196        ArchiveAccessorProxyInterface::r#stream_diagnostics(self, parameters, stream)
197    }
198}
199
200impl ArchiveAccessorProxyInterface for ArchiveAccessorProxy {
201    type StreamDiagnosticsResponseFut =
202        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
203    fn r#stream_diagnostics(
204        &self,
205        mut parameters: &fidl_fuchsia_diagnostics::StreamParameters,
206        mut stream: fidl::Socket,
207    ) -> Self::StreamDiagnosticsResponseFut {
208        fn _decode(
209            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
210        ) -> Result<(), fidl::Error> {
211            let _response = fidl::client::decode_transaction_body::<
212                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
213                fidl::encoding::DefaultFuchsiaResourceDialect,
214                0x29635237a23c495b,
215            >(_buf?)?
216            .into_result::<ArchiveAccessorMarker>("stream_diagnostics")?;
217            Ok(_response)
218        }
219        self.client.send_query_and_decode::<ArchiveAccessorStreamDiagnosticsRequest, ()>(
220            (parameters, stream),
221            0x29635237a23c495b,
222            fidl::encoding::DynamicFlags::FLEXIBLE,
223            _decode,
224        )
225    }
226}
227
228pub struct ArchiveAccessorEventStream {
229    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
230}
231
232impl std::marker::Unpin for ArchiveAccessorEventStream {}
233
234impl futures::stream::FusedStream for ArchiveAccessorEventStream {
235    fn is_terminated(&self) -> bool {
236        self.event_receiver.is_terminated()
237    }
238}
239
240impl futures::Stream for ArchiveAccessorEventStream {
241    type Item = Result<ArchiveAccessorEvent, fidl::Error>;
242
243    fn poll_next(
244        mut self: std::pin::Pin<&mut Self>,
245        cx: &mut std::task::Context<'_>,
246    ) -> std::task::Poll<Option<Self::Item>> {
247        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
248            &mut self.event_receiver,
249            cx
250        )?) {
251            Some(buf) => std::task::Poll::Ready(Some(ArchiveAccessorEvent::decode(buf))),
252            None => std::task::Poll::Ready(None),
253        }
254    }
255}
256
257#[derive(Debug)]
258pub enum ArchiveAccessorEvent {
259    #[non_exhaustive]
260    _UnknownEvent {
261        /// Ordinal of the event that was sent.
262        ordinal: u64,
263    },
264}
265
266impl ArchiveAccessorEvent {
267    /// Decodes a message buffer as a [`ArchiveAccessorEvent`].
268    fn decode(
269        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
270    ) -> Result<ArchiveAccessorEvent, fidl::Error> {
271        let (bytes, _handles) = buf.split_mut();
272        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
273        debug_assert_eq!(tx_header.tx_id, 0);
274        match tx_header.ordinal {
275            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
276                Ok(ArchiveAccessorEvent::_UnknownEvent { ordinal: tx_header.ordinal })
277            }
278            _ => Err(fidl::Error::UnknownOrdinal {
279                ordinal: tx_header.ordinal,
280                protocol_name:
281                    <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
282            }),
283        }
284    }
285}
286
287/// A Stream of incoming requests for fuchsia.diagnostics.host/ArchiveAccessor.
288pub struct ArchiveAccessorRequestStream {
289    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
290    is_terminated: bool,
291}
292
293impl std::marker::Unpin for ArchiveAccessorRequestStream {}
294
295impl futures::stream::FusedStream for ArchiveAccessorRequestStream {
296    fn is_terminated(&self) -> bool {
297        self.is_terminated
298    }
299}
300
301impl fidl::endpoints::RequestStream for ArchiveAccessorRequestStream {
302    type Protocol = ArchiveAccessorMarker;
303    type ControlHandle = ArchiveAccessorControlHandle;
304
305    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
306        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
307    }
308
309    fn control_handle(&self) -> Self::ControlHandle {
310        ArchiveAccessorControlHandle { inner: self.inner.clone() }
311    }
312
313    fn into_inner(
314        self,
315    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
316    {
317        (self.inner, self.is_terminated)
318    }
319
320    fn from_inner(
321        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
322        is_terminated: bool,
323    ) -> Self {
324        Self { inner, is_terminated }
325    }
326}
327
328impl futures::Stream for ArchiveAccessorRequestStream {
329    type Item = Result<ArchiveAccessorRequest, fidl::Error>;
330
331    fn poll_next(
332        mut self: std::pin::Pin<&mut Self>,
333        cx: &mut std::task::Context<'_>,
334    ) -> std::task::Poll<Option<Self::Item>> {
335        let this = &mut *self;
336        if this.inner.check_shutdown(cx) {
337            this.is_terminated = true;
338            return std::task::Poll::Ready(None);
339        }
340        if this.is_terminated {
341            panic!("polled ArchiveAccessorRequestStream after completion");
342        }
343        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
344            |bytes, handles| {
345                match this.inner.channel().read_etc(cx, bytes, handles) {
346                    std::task::Poll::Ready(Ok(())) => {}
347                    std::task::Poll::Pending => return std::task::Poll::Pending,
348                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
349                        this.is_terminated = true;
350                        return std::task::Poll::Ready(None);
351                    }
352                    std::task::Poll::Ready(Err(e)) => {
353                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
354                            e.into(),
355                        ))))
356                    }
357                }
358
359                // A message has been received from the channel
360                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
361
362                std::task::Poll::Ready(Some(match header.ordinal {
363                    0x29635237a23c495b => {
364                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
365                        let mut req = fidl::new_empty!(
366                            ArchiveAccessorStreamDiagnosticsRequest,
367                            fidl::encoding::DefaultFuchsiaResourceDialect
368                        );
369                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ArchiveAccessorStreamDiagnosticsRequest>(&header, _body_bytes, handles, &mut req)?;
370                        let control_handle =
371                            ArchiveAccessorControlHandle { inner: this.inner.clone() };
372                        Ok(ArchiveAccessorRequest::StreamDiagnostics {
373                            parameters: req.parameters,
374                            stream: req.stream,
375
376                            responder: ArchiveAccessorStreamDiagnosticsResponder {
377                                control_handle: std::mem::ManuallyDrop::new(control_handle),
378                                tx_id: header.tx_id,
379                            },
380                        })
381                    }
382                    _ if header.tx_id == 0
383                        && header
384                            .dynamic_flags()
385                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
386                    {
387                        Ok(ArchiveAccessorRequest::_UnknownMethod {
388                            ordinal: header.ordinal,
389                            control_handle: ArchiveAccessorControlHandle {
390                                inner: this.inner.clone(),
391                            },
392                            method_type: fidl::MethodType::OneWay,
393                        })
394                    }
395                    _ if header
396                        .dynamic_flags()
397                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
398                    {
399                        this.inner.send_framework_err(
400                            fidl::encoding::FrameworkErr::UnknownMethod,
401                            header.tx_id,
402                            header.ordinal,
403                            header.dynamic_flags(),
404                            (bytes, handles),
405                        )?;
406                        Ok(ArchiveAccessorRequest::_UnknownMethod {
407                            ordinal: header.ordinal,
408                            control_handle: ArchiveAccessorControlHandle {
409                                inner: this.inner.clone(),
410                            },
411                            method_type: fidl::MethodType::TwoWay,
412                        })
413                    }
414                    _ => Err(fidl::Error::UnknownOrdinal {
415                        ordinal: header.ordinal,
416                        protocol_name:
417                            <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
418                    }),
419                }))
420            },
421        )
422    }
423}
424
425#[derive(Debug)]
426pub enum ArchiveAccessorRequest {
427    /// Creates an iterator over diagnostics data on the system.
428    ///   * The iterator may be finite by streaming in SNAPSHOT mode, serving only the
429    ///     current state of diagnostics data on the system.
430    ///   * The iterator may be infinite by streaming in either SNAPSHOT_THEN_SUBSCRIBE
431    ///     or SUBSCRIBE mode; the prior first provides iteration over the current state of
432    ///     the sytem, and then both provide ongoing iteration over newly arriving diagnostics
433    ///     data.
434    ///
435    /// `stream` is a socket that diagnostic records are exposed to the client over.
436    ///
437    /// `parameters` is a [fuchsia.diagnostics/StreamParameter] which
438    ///   specifies how to configure the stream.
439    ///
440    /// The stream will carry data using the format documented in
441    /// [Diagnostics schema][https://fuchsia.dev/fuchsia-src/reference/platform-spec/diagnostics/schema]
442    StreamDiagnostics {
443        parameters: fidl_fuchsia_diagnostics::StreamParameters,
444        stream: fidl::Socket,
445        responder: ArchiveAccessorStreamDiagnosticsResponder,
446    },
447    /// An interaction was received which does not match any known method.
448    #[non_exhaustive]
449    _UnknownMethod {
450        /// Ordinal of the method that was called.
451        ordinal: u64,
452        control_handle: ArchiveAccessorControlHandle,
453        method_type: fidl::MethodType,
454    },
455}
456
457impl ArchiveAccessorRequest {
458    #[allow(irrefutable_let_patterns)]
459    pub fn into_stream_diagnostics(
460        self,
461    ) -> Option<(
462        fidl_fuchsia_diagnostics::StreamParameters,
463        fidl::Socket,
464        ArchiveAccessorStreamDiagnosticsResponder,
465    )> {
466        if let ArchiveAccessorRequest::StreamDiagnostics { parameters, stream, responder } = self {
467            Some((parameters, stream, responder))
468        } else {
469            None
470        }
471    }
472
473    /// Name of the method defined in FIDL
474    pub fn method_name(&self) -> &'static str {
475        match *self {
476            ArchiveAccessorRequest::StreamDiagnostics { .. } => "stream_diagnostics",
477            ArchiveAccessorRequest::_UnknownMethod {
478                method_type: fidl::MethodType::OneWay,
479                ..
480            } => "unknown one-way method",
481            ArchiveAccessorRequest::_UnknownMethod {
482                method_type: fidl::MethodType::TwoWay,
483                ..
484            } => "unknown two-way method",
485        }
486    }
487}
488
489#[derive(Debug, Clone)]
490pub struct ArchiveAccessorControlHandle {
491    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
492}
493
494impl fidl::endpoints::ControlHandle for ArchiveAccessorControlHandle {
495    fn shutdown(&self) {
496        self.inner.shutdown()
497    }
498    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
499        self.inner.shutdown_with_epitaph(status)
500    }
501
502    fn is_closed(&self) -> bool {
503        self.inner.channel().is_closed()
504    }
505    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
506        self.inner.channel().on_closed()
507    }
508
509    #[cfg(target_os = "fuchsia")]
510    fn signal_peer(
511        &self,
512        clear_mask: zx::Signals,
513        set_mask: zx::Signals,
514    ) -> Result<(), zx_status::Status> {
515        use fidl::Peered;
516        self.inner.channel().signal_peer(clear_mask, set_mask)
517    }
518}
519
520impl ArchiveAccessorControlHandle {}
521
522#[must_use = "FIDL methods require a response to be sent"]
523#[derive(Debug)]
524pub struct ArchiveAccessorStreamDiagnosticsResponder {
525    control_handle: std::mem::ManuallyDrop<ArchiveAccessorControlHandle>,
526    tx_id: u32,
527}
528
529/// Set the the channel to be shutdown (see [`ArchiveAccessorControlHandle::shutdown`])
530/// if the responder is dropped without sending a response, so that the client
531/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
532impl std::ops::Drop for ArchiveAccessorStreamDiagnosticsResponder {
533    fn drop(&mut self) {
534        self.control_handle.shutdown();
535        // Safety: drops once, never accessed again
536        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
537    }
538}
539
540impl fidl::endpoints::Responder for ArchiveAccessorStreamDiagnosticsResponder {
541    type ControlHandle = ArchiveAccessorControlHandle;
542
543    fn control_handle(&self) -> &ArchiveAccessorControlHandle {
544        &self.control_handle
545    }
546
547    fn drop_without_shutdown(mut self) {
548        // Safety: drops once, never accessed again due to mem::forget
549        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
550        // Prevent Drop from running (which would shut down the channel)
551        std::mem::forget(self);
552    }
553}
554
555impl ArchiveAccessorStreamDiagnosticsResponder {
556    /// Sends a response to the FIDL transaction.
557    ///
558    /// Sets the channel to shutdown if an error occurs.
559    pub fn send(self) -> Result<(), fidl::Error> {
560        let _result = self.send_raw();
561        if _result.is_err() {
562            self.control_handle.shutdown();
563        }
564        self.drop_without_shutdown();
565        _result
566    }
567
568    /// Similar to "send" but does not shutdown the channel if an error occurs.
569    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
570        let _result = self.send_raw();
571        self.drop_without_shutdown();
572        _result
573    }
574
575    fn send_raw(&self) -> Result<(), fidl::Error> {
576        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
577            fidl::encoding::Flexible::new(()),
578            self.tx_id,
579            0x29635237a23c495b,
580            fidl::encoding::DynamicFlags::FLEXIBLE,
581        )
582    }
583}
584
585mod internal {
586    use super::*;
587
588    impl fidl::encoding::ResourceTypeMarker for ArchiveAccessorStreamDiagnosticsRequest {
589        type Borrowed<'a> = &'a mut Self;
590        fn take_or_borrow<'a>(
591            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
592        ) -> Self::Borrowed<'a> {
593            value
594        }
595    }
596
597    unsafe impl fidl::encoding::TypeMarker for ArchiveAccessorStreamDiagnosticsRequest {
598        type Owned = Self;
599
600        #[inline(always)]
601        fn inline_align(_context: fidl::encoding::Context) -> usize {
602            8
603        }
604
605        #[inline(always)]
606        fn inline_size(_context: fidl::encoding::Context) -> usize {
607            24
608        }
609    }
610
611    unsafe impl
612        fidl::encoding::Encode<
613            ArchiveAccessorStreamDiagnosticsRequest,
614            fidl::encoding::DefaultFuchsiaResourceDialect,
615        > for &mut ArchiveAccessorStreamDiagnosticsRequest
616    {
617        #[inline]
618        unsafe fn encode(
619            self,
620            encoder: &mut fidl::encoding::Encoder<
621                '_,
622                fidl::encoding::DefaultFuchsiaResourceDialect,
623            >,
624            offset: usize,
625            _depth: fidl::encoding::Depth,
626        ) -> fidl::Result<()> {
627            encoder.debug_check_bounds::<ArchiveAccessorStreamDiagnosticsRequest>(offset);
628            // Delegate to tuple encoding.
629            fidl::encoding::Encode::<ArchiveAccessorStreamDiagnosticsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
630                (
631                    <fidl_fuchsia_diagnostics::StreamParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
632                    <fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.stream),
633                ),
634                encoder, offset, _depth
635            )
636        }
637    }
638    unsafe impl<
639            T0: fidl::encoding::Encode<
640                fidl_fuchsia_diagnostics::StreamParameters,
641                fidl::encoding::DefaultFuchsiaResourceDialect,
642            >,
643            T1: fidl::encoding::Encode<
644                fidl::encoding::HandleType<
645                    fidl::Socket,
646                    { fidl::ObjectType::SOCKET.into_raw() },
647                    16392,
648                >,
649                fidl::encoding::DefaultFuchsiaResourceDialect,
650            >,
651        >
652        fidl::encoding::Encode<
653            ArchiveAccessorStreamDiagnosticsRequest,
654            fidl::encoding::DefaultFuchsiaResourceDialect,
655        > for (T0, T1)
656    {
657        #[inline]
658        unsafe fn encode(
659            self,
660            encoder: &mut fidl::encoding::Encoder<
661                '_,
662                fidl::encoding::DefaultFuchsiaResourceDialect,
663            >,
664            offset: usize,
665            depth: fidl::encoding::Depth,
666        ) -> fidl::Result<()> {
667            encoder.debug_check_bounds::<ArchiveAccessorStreamDiagnosticsRequest>(offset);
668            // Zero out padding regions. There's no need to apply masks
669            // because the unmasked parts will be overwritten by fields.
670            unsafe {
671                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
672                (ptr as *mut u64).write_unaligned(0);
673            }
674            // Write the fields.
675            self.0.encode(encoder, offset + 0, depth)?;
676            self.1.encode(encoder, offset + 16, depth)?;
677            Ok(())
678        }
679    }
680
681    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
682        for ArchiveAccessorStreamDiagnosticsRequest
683    {
684        #[inline(always)]
685        fn new_empty() -> Self {
686            Self {
687                parameters: fidl::new_empty!(
688                    fidl_fuchsia_diagnostics::StreamParameters,
689                    fidl::encoding::DefaultFuchsiaResourceDialect
690                ),
691                stream: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect),
692            }
693        }
694
695        #[inline]
696        unsafe fn decode(
697            &mut self,
698            decoder: &mut fidl::encoding::Decoder<
699                '_,
700                fidl::encoding::DefaultFuchsiaResourceDialect,
701            >,
702            offset: usize,
703            _depth: fidl::encoding::Depth,
704        ) -> fidl::Result<()> {
705            decoder.debug_check_bounds::<Self>(offset);
706            // Verify that padding bytes are zero.
707            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
708            let padval = unsafe { (ptr as *const u64).read_unaligned() };
709            let mask = 0xffffffff00000000u64;
710            let maskedval = padval & mask;
711            if maskedval != 0 {
712                return Err(fidl::Error::NonZeroPadding {
713                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
714                });
715            }
716            fidl::decode!(
717                fidl_fuchsia_diagnostics::StreamParameters,
718                fidl::encoding::DefaultFuchsiaResourceDialect,
719                &mut self.parameters,
720                decoder,
721                offset + 0,
722                _depth
723            )?;
724            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.stream, decoder, offset + 16, _depth)?;
725            Ok(())
726        }
727    }
728}
fidl_fuchsia_diagnostics_host/fidl_fuchsia_diagnostics_host.rs

fidl_fuchsia_diagnostics_host/
fidl_fuchsia_diagnostics_host.rs
