fidl_fuchsia_virtualconsole/
fidl_fuchsia_virtualconsole.rs

Help
1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_virtualconsole_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct SessionManagerCreateSessionRequest {
16    pub session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for SessionManagerCreateSessionRequest
21{
22}
23
24#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
25pub struct SessionManagerMarker;
26
27impl fidl::endpoints::ProtocolMarker for SessionManagerMarker {
28    type Proxy = SessionManagerProxy;
29    type RequestStream = SessionManagerRequestStream;
30    #[cfg(target_os = "fuchsia")]
31    type SynchronousProxy = SessionManagerSynchronousProxy;
32
33    const DEBUG_NAME: &'static str = "fuchsia.virtualconsole.SessionManager";
34}
35impl fidl::endpoints::DiscoverableProtocolMarker for SessionManagerMarker {}
36
37pub trait SessionManagerProxyInterface: Send + Sync {
38    fn r#create_session(
39        &self,
40        session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
41    ) -> Result<(), fidl::Error>;
42    type HasPrimaryConnectedResponseFut: std::future::Future<Output = Result<bool, fidl::Error>>
43        + Send;
44    fn r#has_primary_connected(&self) -> Self::HasPrimaryConnectedResponseFut;
45}
46#[derive(Debug)]
47#[cfg(target_os = "fuchsia")]
48pub struct SessionManagerSynchronousProxy {
49    client: fidl::client::sync::Client,
50}
51
52#[cfg(target_os = "fuchsia")]
53impl fidl::endpoints::SynchronousProxy for SessionManagerSynchronousProxy {
54    type Proxy = SessionManagerProxy;
55    type Protocol = SessionManagerMarker;
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 SessionManagerSynchronousProxy {
72    pub fn new(channel: fidl::Channel) -> Self {
73        let protocol_name = <SessionManagerMarker 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<SessionManagerEvent, fidl::Error> {
87        SessionManagerEvent::decode(self.client.wait_for_event(deadline)?)
88    }
89
90    /// Create a new virtual console session.
91    pub fn r#create_session(
92        &self,
93        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
94    ) -> Result<(), fidl::Error> {
95        self.client.send::<SessionManagerCreateSessionRequest>(
96            (session,),
97            0x70a8a74a19cc4b52,
98            fidl::encoding::DynamicFlags::empty(),
99        )
100    }
101
102    /// Returns true if virtcon currently has a display that it can display something on.
103    pub fn r#has_primary_connected(
104        &self,
105        ___deadline: zx::MonotonicInstant,
106    ) -> Result<bool, fidl::Error> {
107        let _response = self
108            .client
109            .send_query::<fidl::encoding::EmptyPayload, SessionManagerHasPrimaryConnectedResponse>(
110                (),
111                0x723fdb4c1469fa36,
112                fidl::encoding::DynamicFlags::empty(),
113                ___deadline,
114            )?;
115        Ok(_response.connected)
116    }
117}
118
119#[cfg(target_os = "fuchsia")]
120impl From<SessionManagerSynchronousProxy> for zx::Handle {
121    fn from(value: SessionManagerSynchronousProxy) -> Self {
122        value.into_channel().into()
123    }
124}
125
126#[cfg(target_os = "fuchsia")]
127impl From<fidl::Channel> for SessionManagerSynchronousProxy {
128    fn from(value: fidl::Channel) -> Self {
129        Self::new(value)
130    }
131}
132
133#[derive(Debug, Clone)]
134pub struct SessionManagerProxy {
135    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
136}
137
138impl fidl::endpoints::Proxy for SessionManagerProxy {
139    type Protocol = SessionManagerMarker;
140
141    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
142        Self::new(inner)
143    }
144
145    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
146        self.client.into_channel().map_err(|client| Self { client })
147    }
148
149    fn as_channel(&self) -> &::fidl::AsyncChannel {
150        self.client.as_channel()
151    }
152}
153
154impl SessionManagerProxy {
155    /// Create a new Proxy for fuchsia.virtualconsole/SessionManager.
156    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
157        let protocol_name = <SessionManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
158        Self { client: fidl::client::Client::new(channel, protocol_name) }
159    }
160
161    /// Get a Stream of events from the remote end of the protocol.
162    ///
163    /// # Panics
164    ///
165    /// Panics if the event stream was already taken.
166    pub fn take_event_stream(&self) -> SessionManagerEventStream {
167        SessionManagerEventStream { event_receiver: self.client.take_event_receiver() }
168    }
169
170    /// Create a new virtual console session.
171    pub fn r#create_session(
172        &self,
173        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
174    ) -> Result<(), fidl::Error> {
175        SessionManagerProxyInterface::r#create_session(self, session)
176    }
177
178    /// Returns true if virtcon currently has a display that it can display something on.
179    pub fn r#has_primary_connected(
180        &self,
181    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
182        SessionManagerProxyInterface::r#has_primary_connected(self)
183    }
184}
185
186impl SessionManagerProxyInterface for SessionManagerProxy {
187    fn r#create_session(
188        &self,
189        mut session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
190    ) -> Result<(), fidl::Error> {
191        self.client.send::<SessionManagerCreateSessionRequest>(
192            (session,),
193            0x70a8a74a19cc4b52,
194            fidl::encoding::DynamicFlags::empty(),
195        )
196    }
197
198    type HasPrimaryConnectedResponseFut =
199        fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
200    fn r#has_primary_connected(&self) -> Self::HasPrimaryConnectedResponseFut {
201        fn _decode(
202            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
203        ) -> Result<bool, fidl::Error> {
204            let _response = fidl::client::decode_transaction_body::<
205                SessionManagerHasPrimaryConnectedResponse,
206                fidl::encoding::DefaultFuchsiaResourceDialect,
207                0x723fdb4c1469fa36,
208            >(_buf?)?;
209            Ok(_response.connected)
210        }
211        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool>(
212            (),
213            0x723fdb4c1469fa36,
214            fidl::encoding::DynamicFlags::empty(),
215            _decode,
216        )
217    }
218}
219
220pub struct SessionManagerEventStream {
221    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
222}
223
224impl std::marker::Unpin for SessionManagerEventStream {}
225
226impl futures::stream::FusedStream for SessionManagerEventStream {
227    fn is_terminated(&self) -> bool {
228        self.event_receiver.is_terminated()
229    }
230}
231
232impl futures::Stream for SessionManagerEventStream {
233    type Item = Result<SessionManagerEvent, fidl::Error>;
234
235    fn poll_next(
236        mut self: std::pin::Pin<&mut Self>,
237        cx: &mut std::task::Context<'_>,
238    ) -> std::task::Poll<Option<Self::Item>> {
239        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
240            &mut self.event_receiver,
241            cx
242        )?) {
243            Some(buf) => std::task::Poll::Ready(Some(SessionManagerEvent::decode(buf))),
244            None => std::task::Poll::Ready(None),
245        }
246    }
247}
248
249#[derive(Debug)]
250pub enum SessionManagerEvent {}
251
252impl SessionManagerEvent {
253    /// Decodes a message buffer as a [`SessionManagerEvent`].
254    fn decode(
255        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
256    ) -> Result<SessionManagerEvent, fidl::Error> {
257        let (bytes, _handles) = buf.split_mut();
258        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
259        debug_assert_eq!(tx_header.tx_id, 0);
260        match tx_header.ordinal {
261            _ => Err(fidl::Error::UnknownOrdinal {
262                ordinal: tx_header.ordinal,
263                protocol_name:
264                    <SessionManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
265            }),
266        }
267    }
268}
269
270/// A Stream of incoming requests for fuchsia.virtualconsole/SessionManager.
271pub struct SessionManagerRequestStream {
272    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
273    is_terminated: bool,
274}
275
276impl std::marker::Unpin for SessionManagerRequestStream {}
277
278impl futures::stream::FusedStream for SessionManagerRequestStream {
279    fn is_terminated(&self) -> bool {
280        self.is_terminated
281    }
282}
283
284impl fidl::endpoints::RequestStream for SessionManagerRequestStream {
285    type Protocol = SessionManagerMarker;
286    type ControlHandle = SessionManagerControlHandle;
287
288    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
289        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
290    }
291
292    fn control_handle(&self) -> Self::ControlHandle {
293        SessionManagerControlHandle { inner: self.inner.clone() }
294    }
295
296    fn into_inner(
297        self,
298    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
299    {
300        (self.inner, self.is_terminated)
301    }
302
303    fn from_inner(
304        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
305        is_terminated: bool,
306    ) -> Self {
307        Self { inner, is_terminated }
308    }
309}
310
311impl futures::Stream for SessionManagerRequestStream {
312    type Item = Result<SessionManagerRequest, fidl::Error>;
313
314    fn poll_next(
315        mut self: std::pin::Pin<&mut Self>,
316        cx: &mut std::task::Context<'_>,
317    ) -> std::task::Poll<Option<Self::Item>> {
318        let this = &mut *self;
319        if this.inner.check_shutdown(cx) {
320            this.is_terminated = true;
321            return std::task::Poll::Ready(None);
322        }
323        if this.is_terminated {
324            panic!("polled SessionManagerRequestStream after completion");
325        }
326        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
327            |bytes, handles| {
328                match this.inner.channel().read_etc(cx, bytes, handles) {
329                    std::task::Poll::Ready(Ok(())) => {}
330                    std::task::Poll::Pending => return std::task::Poll::Pending,
331                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
332                        this.is_terminated = true;
333                        return std::task::Poll::Ready(None);
334                    }
335                    std::task::Poll::Ready(Err(e)) => {
336                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
337                            e.into(),
338                        ))))
339                    }
340                }
341
342                // A message has been received from the channel
343                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
344
345                std::task::Poll::Ready(Some(match header.ordinal {
346                    0x70a8a74a19cc4b52 => {
347                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
348                        let mut req = fidl::new_empty!(
349                            SessionManagerCreateSessionRequest,
350                            fidl::encoding::DefaultFuchsiaResourceDialect
351                        );
352                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionManagerCreateSessionRequest>(&header, _body_bytes, handles, &mut req)?;
353                        let control_handle =
354                            SessionManagerControlHandle { inner: this.inner.clone() };
355                        Ok(SessionManagerRequest::CreateSession {
356                            session: req.session,
357
358                            control_handle,
359                        })
360                    }
361                    0x723fdb4c1469fa36 => {
362                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
363                        let mut req = fidl::new_empty!(
364                            fidl::encoding::EmptyPayload,
365                            fidl::encoding::DefaultFuchsiaResourceDialect
366                        );
367                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
368                        let control_handle =
369                            SessionManagerControlHandle { inner: this.inner.clone() };
370                        Ok(SessionManagerRequest::HasPrimaryConnected {
371                            responder: SessionManagerHasPrimaryConnectedResponder {
372                                control_handle: std::mem::ManuallyDrop::new(control_handle),
373                                tx_id: header.tx_id,
374                            },
375                        })
376                    }
377                    _ => Err(fidl::Error::UnknownOrdinal {
378                        ordinal: header.ordinal,
379                        protocol_name:
380                            <SessionManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
381                    }),
382                }))
383            },
384        )
385    }
386}
387
388/// Manages virtual console sessions.
389#[derive(Debug)]
390pub enum SessionManagerRequest {
391    /// Create a new virtual console session.
392    CreateSession {
393        session: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
394        control_handle: SessionManagerControlHandle,
395    },
396    /// Returns true if virtcon currently has a display that it can display something on.
397    HasPrimaryConnected { responder: SessionManagerHasPrimaryConnectedResponder },
398}
399
400impl SessionManagerRequest {
401    #[allow(irrefutable_let_patterns)]
402    pub fn into_create_session(
403        self,
404    ) -> Option<(
405        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
406        SessionManagerControlHandle,
407    )> {
408        if let SessionManagerRequest::CreateSession { session, control_handle } = self {
409            Some((session, control_handle))
410        } else {
411            None
412        }
413    }
414
415    #[allow(irrefutable_let_patterns)]
416    pub fn into_has_primary_connected(
417        self,
418    ) -> Option<(SessionManagerHasPrimaryConnectedResponder)> {
419        if let SessionManagerRequest::HasPrimaryConnected { responder } = self {
420            Some((responder))
421        } else {
422            None
423        }
424    }
425
426    /// Name of the method defined in FIDL
427    pub fn method_name(&self) -> &'static str {
428        match *self {
429            SessionManagerRequest::CreateSession { .. } => "create_session",
430            SessionManagerRequest::HasPrimaryConnected { .. } => "has_primary_connected",
431        }
432    }
433}
434
435#[derive(Debug, Clone)]
436pub struct SessionManagerControlHandle {
437    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
438}
439
440impl fidl::endpoints::ControlHandle for SessionManagerControlHandle {
441    fn shutdown(&self) {
442        self.inner.shutdown()
443    }
444    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
445        self.inner.shutdown_with_epitaph(status)
446    }
447
448    fn is_closed(&self) -> bool {
449        self.inner.channel().is_closed()
450    }
451    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
452        self.inner.channel().on_closed()
453    }
454
455    #[cfg(target_os = "fuchsia")]
456    fn signal_peer(
457        &self,
458        clear_mask: zx::Signals,
459        set_mask: zx::Signals,
460    ) -> Result<(), zx_status::Status> {
461        use fidl::Peered;
462        self.inner.channel().signal_peer(clear_mask, set_mask)
463    }
464}
465
466impl SessionManagerControlHandle {}
467
468#[must_use = "FIDL methods require a response to be sent"]
469#[derive(Debug)]
470pub struct SessionManagerHasPrimaryConnectedResponder {
471    control_handle: std::mem::ManuallyDrop<SessionManagerControlHandle>,
472    tx_id: u32,
473}
474
475/// Set the the channel to be shutdown (see [`SessionManagerControlHandle::shutdown`])
476/// if the responder is dropped without sending a response, so that the client
477/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
478impl std::ops::Drop for SessionManagerHasPrimaryConnectedResponder {
479    fn drop(&mut self) {
480        self.control_handle.shutdown();
481        // Safety: drops once, never accessed again
482        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
483    }
484}
485
486impl fidl::endpoints::Responder for SessionManagerHasPrimaryConnectedResponder {
487    type ControlHandle = SessionManagerControlHandle;
488
489    fn control_handle(&self) -> &SessionManagerControlHandle {
490        &self.control_handle
491    }
492
493    fn drop_without_shutdown(mut self) {
494        // Safety: drops once, never accessed again due to mem::forget
495        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
496        // Prevent Drop from running (which would shut down the channel)
497        std::mem::forget(self);
498    }
499}
500
501impl SessionManagerHasPrimaryConnectedResponder {
502    /// Sends a response to the FIDL transaction.
503    ///
504    /// Sets the channel to shutdown if an error occurs.
505    pub fn send(self, mut connected: bool) -> Result<(), fidl::Error> {
506        let _result = self.send_raw(connected);
507        if _result.is_err() {
508            self.control_handle.shutdown();
509        }
510        self.drop_without_shutdown();
511        _result
512    }
513
514    /// Similar to "send" but does not shutdown the channel if an error occurs.
515    pub fn send_no_shutdown_on_err(self, mut connected: bool) -> Result<(), fidl::Error> {
516        let _result = self.send_raw(connected);
517        self.drop_without_shutdown();
518        _result
519    }
520
521    fn send_raw(&self, mut connected: bool) -> Result<(), fidl::Error> {
522        self.control_handle.inner.send::<SessionManagerHasPrimaryConnectedResponse>(
523            (connected,),
524            self.tx_id,
525            0x723fdb4c1469fa36,
526            fidl::encoding::DynamicFlags::empty(),
527        )
528    }
529}
530
531mod internal {
532    use super::*;
533
534    impl fidl::encoding::ResourceTypeMarker for SessionManagerCreateSessionRequest {
535        type Borrowed<'a> = &'a mut Self;
536        fn take_or_borrow<'a>(
537            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
538        ) -> Self::Borrowed<'a> {
539            value
540        }
541    }
542
543    unsafe impl fidl::encoding::TypeMarker for SessionManagerCreateSessionRequest {
544        type Owned = Self;
545
546        #[inline(always)]
547        fn inline_align(_context: fidl::encoding::Context) -> usize {
548            4
549        }
550
551        #[inline(always)]
552        fn inline_size(_context: fidl::encoding::Context) -> usize {
553            4
554        }
555    }
556
557    unsafe impl
558        fidl::encoding::Encode<
559            SessionManagerCreateSessionRequest,
560            fidl::encoding::DefaultFuchsiaResourceDialect,
561        > for &mut SessionManagerCreateSessionRequest
562    {
563        #[inline]
564        unsafe fn encode(
565            self,
566            encoder: &mut fidl::encoding::Encoder<
567                '_,
568                fidl::encoding::DefaultFuchsiaResourceDialect,
569            >,
570            offset: usize,
571            _depth: fidl::encoding::Depth,
572        ) -> fidl::Result<()> {
573            encoder.debug_check_bounds::<SessionManagerCreateSessionRequest>(offset);
574            // Delegate to tuple encoding.
575            fidl::encoding::Encode::<
576                SessionManagerCreateSessionRequest,
577                fidl::encoding::DefaultFuchsiaResourceDialect,
578            >::encode(
579                (<fidl::encoding::Endpoint<
580                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
581                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
582                    &mut self.session
583                ),),
584                encoder,
585                offset,
586                _depth,
587            )
588        }
589    }
590    unsafe impl<
591            T0: fidl::encoding::Encode<
592                fidl::encoding::Endpoint<
593                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
594                >,
595                fidl::encoding::DefaultFuchsiaResourceDialect,
596            >,
597        >
598        fidl::encoding::Encode<
599            SessionManagerCreateSessionRequest,
600            fidl::encoding::DefaultFuchsiaResourceDialect,
601        > for (T0,)
602    {
603        #[inline]
604        unsafe fn encode(
605            self,
606            encoder: &mut fidl::encoding::Encoder<
607                '_,
608                fidl::encoding::DefaultFuchsiaResourceDialect,
609            >,
610            offset: usize,
611            depth: fidl::encoding::Depth,
612        ) -> fidl::Result<()> {
613            encoder.debug_check_bounds::<SessionManagerCreateSessionRequest>(offset);
614            // Zero out padding regions. There's no need to apply masks
615            // because the unmasked parts will be overwritten by fields.
616            // Write the fields.
617            self.0.encode(encoder, offset + 0, depth)?;
618            Ok(())
619        }
620    }
621
622    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
623        for SessionManagerCreateSessionRequest
624    {
625        #[inline(always)]
626        fn new_empty() -> Self {
627            Self {
628                session: fidl::new_empty!(
629                    fidl::encoding::Endpoint<
630                        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
631                    >,
632                    fidl::encoding::DefaultFuchsiaResourceDialect
633                ),
634            }
635        }
636
637        #[inline]
638        unsafe fn decode(
639            &mut self,
640            decoder: &mut fidl::encoding::Decoder<
641                '_,
642                fidl::encoding::DefaultFuchsiaResourceDialect,
643            >,
644            offset: usize,
645            _depth: fidl::encoding::Depth,
646        ) -> fidl::Result<()> {
647            decoder.debug_check_bounds::<Self>(offset);
648            // Verify that padding bytes are zero.
649            fidl::decode!(
650                fidl::encoding::Endpoint<
651                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_pty::DeviceMarker>,
652                >,
653                fidl::encoding::DefaultFuchsiaResourceDialect,
654                &mut self.session,
655                decoder,
656                offset + 0,
657                _depth
658            )?;
659            Ok(())
660        }
661    }
662}
fidl_fuchsia_virtualconsole/fidl_fuchsia_virtualconsole.rs

fidl_fuchsia_virtualconsole/
fidl_fuchsia_virtualconsole.rs
