fidl_fuchsia_hardware_sockettunnel/
fidl_fuchsia_hardware_sockettunnel.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 _};
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13#[derive(Debug, Default, PartialEq)]
14pub struct DeviceRegisterSocketRequest {
15    pub server_socket: Option<fidl::Socket>,
16    pub socket_label: Option<String>,
17    #[doc(hidden)]
18    pub __source_breaking: fidl::marker::SourceBreaking,
19}
20
21impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
22    for DeviceRegisterSocketRequest
23{
24}
25
26#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
27pub struct DeviceMarker;
28
29impl fidl::endpoints::ProtocolMarker for DeviceMarker {
30    type Proxy = DeviceProxy;
31    type RequestStream = DeviceRequestStream;
32    #[cfg(target_os = "fuchsia")]
33    type SynchronousProxy = DeviceSynchronousProxy;
34
35    const DEBUG_NAME: &'static str = "fuchsia.hardware.sockettunnel.Device";
36}
37impl fidl::endpoints::DiscoverableProtocolMarker for DeviceMarker {}
38pub type DeviceRegisterSocketResult = Result<(), i32>;
39
40pub trait DeviceProxyInterface: Send + Sync {
41    type RegisterSocketResponseFut: std::future::Future<Output = Result<DeviceRegisterSocketResult, fidl::Error>>
42        + Send;
43    fn r#register_socket(
44        &self,
45        payload: DeviceRegisterSocketRequest,
46    ) -> Self::RegisterSocketResponseFut;
47}
48#[derive(Debug)]
49#[cfg(target_os = "fuchsia")]
50pub struct DeviceSynchronousProxy {
51    client: fidl::client::sync::Client,
52}
53
54#[cfg(target_os = "fuchsia")]
55impl fidl::endpoints::SynchronousProxy for DeviceSynchronousProxy {
56    type Proxy = DeviceProxy;
57    type Protocol = DeviceMarker;
58
59    fn from_channel(inner: fidl::Channel) -> Self {
60        Self::new(inner)
61    }
62
63    fn into_channel(self) -> fidl::Channel {
64        self.client.into_channel()
65    }
66
67    fn as_channel(&self) -> &fidl::Channel {
68        self.client.as_channel()
69    }
70}
71
72#[cfg(target_os = "fuchsia")]
73impl DeviceSynchronousProxy {
74    pub fn new(channel: fidl::Channel) -> Self {
75        let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
76        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
77    }
78
79    pub fn into_channel(self) -> fidl::Channel {
80        self.client.into_channel()
81    }
82
83    /// Waits until an event arrives and returns it. It is safe for other
84    /// threads to make concurrent requests while waiting for an event.
85    pub fn wait_for_event(
86        &self,
87        deadline: zx::MonotonicInstant,
88    ) -> Result<DeviceEvent, fidl::Error> {
89        DeviceEvent::decode(self.client.wait_for_event(deadline)?)
90    }
91
92    pub fn r#register_socket(
93        &self,
94        mut payload: DeviceRegisterSocketRequest,
95        ___deadline: zx::MonotonicInstant,
96    ) -> Result<DeviceRegisterSocketResult, fidl::Error> {
97        let _response = self.client.send_query::<
98            DeviceRegisterSocketRequest,
99            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
100        >(
101            &mut payload,
102            0x4b2c4d82dae82c6d,
103            fidl::encoding::DynamicFlags::FLEXIBLE,
104            ___deadline,
105        )?
106        .into_result::<DeviceMarker>("register_socket")?;
107        Ok(_response.map(|x| x))
108    }
109}
110
111#[derive(Debug, Clone)]
112pub struct DeviceProxy {
113    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
114}
115
116impl fidl::endpoints::Proxy for DeviceProxy {
117    type Protocol = DeviceMarker;
118
119    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
120        Self::new(inner)
121    }
122
123    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
124        self.client.into_channel().map_err(|client| Self { client })
125    }
126
127    fn as_channel(&self) -> &::fidl::AsyncChannel {
128        self.client.as_channel()
129    }
130}
131
132impl DeviceProxy {
133    /// Create a new Proxy for fuchsia.hardware.sockettunnel/Device.
134    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
135        let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
136        Self { client: fidl::client::Client::new(channel, protocol_name) }
137    }
138
139    /// Get a Stream of events from the remote end of the protocol.
140    ///
141    /// # Panics
142    ///
143    /// Panics if the event stream was already taken.
144    pub fn take_event_stream(&self) -> DeviceEventStream {
145        DeviceEventStream { event_receiver: self.client.take_event_receiver() }
146    }
147
148    pub fn r#register_socket(
149        &self,
150        mut payload: DeviceRegisterSocketRequest,
151    ) -> fidl::client::QueryResponseFut<
152        DeviceRegisterSocketResult,
153        fidl::encoding::DefaultFuchsiaResourceDialect,
154    > {
155        DeviceProxyInterface::r#register_socket(self, payload)
156    }
157}
158
159impl DeviceProxyInterface for DeviceProxy {
160    type RegisterSocketResponseFut = fidl::client::QueryResponseFut<
161        DeviceRegisterSocketResult,
162        fidl::encoding::DefaultFuchsiaResourceDialect,
163    >;
164    fn r#register_socket(
165        &self,
166        mut payload: DeviceRegisterSocketRequest,
167    ) -> Self::RegisterSocketResponseFut {
168        fn _decode(
169            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
170        ) -> Result<DeviceRegisterSocketResult, fidl::Error> {
171            let _response = fidl::client::decode_transaction_body::<
172                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
173                fidl::encoding::DefaultFuchsiaResourceDialect,
174                0x4b2c4d82dae82c6d,
175            >(_buf?)?
176            .into_result::<DeviceMarker>("register_socket")?;
177            Ok(_response.map(|x| x))
178        }
179        self.client
180            .send_query_and_decode::<DeviceRegisterSocketRequest, DeviceRegisterSocketResult>(
181                &mut payload,
182                0x4b2c4d82dae82c6d,
183                fidl::encoding::DynamicFlags::FLEXIBLE,
184                _decode,
185            )
186    }
187}
188
189pub struct DeviceEventStream {
190    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
191}
192
193impl std::marker::Unpin for DeviceEventStream {}
194
195impl futures::stream::FusedStream for DeviceEventStream {
196    fn is_terminated(&self) -> bool {
197        self.event_receiver.is_terminated()
198    }
199}
200
201impl futures::Stream for DeviceEventStream {
202    type Item = Result<DeviceEvent, fidl::Error>;
203
204    fn poll_next(
205        mut self: std::pin::Pin<&mut Self>,
206        cx: &mut std::task::Context<'_>,
207    ) -> std::task::Poll<Option<Self::Item>> {
208        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
209            &mut self.event_receiver,
210            cx
211        )?) {
212            Some(buf) => std::task::Poll::Ready(Some(DeviceEvent::decode(buf))),
213            None => std::task::Poll::Ready(None),
214        }
215    }
216}
217
218#[derive(Debug)]
219pub enum DeviceEvent {
220    #[non_exhaustive]
221    _UnknownEvent {
222        /// Ordinal of the event that was sent.
223        ordinal: u64,
224    },
225}
226
227impl DeviceEvent {
228    /// Decodes a message buffer as a [`DeviceEvent`].
229    fn decode(
230        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
231    ) -> Result<DeviceEvent, fidl::Error> {
232        let (bytes, _handles) = buf.split_mut();
233        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
234        debug_assert_eq!(tx_header.tx_id, 0);
235        match tx_header.ordinal {
236            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
237                Ok(DeviceEvent::_UnknownEvent { ordinal: tx_header.ordinal })
238            }
239            _ => Err(fidl::Error::UnknownOrdinal {
240                ordinal: tx_header.ordinal,
241                protocol_name: <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
242            }),
243        }
244    }
245}
246
247/// A Stream of incoming requests for fuchsia.hardware.sockettunnel/Device.
248pub struct DeviceRequestStream {
249    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
250    is_terminated: bool,
251}
252
253impl std::marker::Unpin for DeviceRequestStream {}
254
255impl futures::stream::FusedStream for DeviceRequestStream {
256    fn is_terminated(&self) -> bool {
257        self.is_terminated
258    }
259}
260
261impl fidl::endpoints::RequestStream for DeviceRequestStream {
262    type Protocol = DeviceMarker;
263    type ControlHandle = DeviceControlHandle;
264
265    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
266        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
267    }
268
269    fn control_handle(&self) -> Self::ControlHandle {
270        DeviceControlHandle { inner: self.inner.clone() }
271    }
272
273    fn into_inner(
274        self,
275    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
276    {
277        (self.inner, self.is_terminated)
278    }
279
280    fn from_inner(
281        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
282        is_terminated: bool,
283    ) -> Self {
284        Self { inner, is_terminated }
285    }
286}
287
288impl futures::Stream for DeviceRequestStream {
289    type Item = Result<DeviceRequest, fidl::Error>;
290
291    fn poll_next(
292        mut self: std::pin::Pin<&mut Self>,
293        cx: &mut std::task::Context<'_>,
294    ) -> std::task::Poll<Option<Self::Item>> {
295        let this = &mut *self;
296        if this.inner.check_shutdown(cx) {
297            this.is_terminated = true;
298            return std::task::Poll::Ready(None);
299        }
300        if this.is_terminated {
301            panic!("polled DeviceRequestStream after completion");
302        }
303        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
304            |bytes, handles| {
305                match this.inner.channel().read_etc(cx, bytes, handles) {
306                    std::task::Poll::Ready(Ok(())) => {}
307                    std::task::Poll::Pending => return std::task::Poll::Pending,
308                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
309                        this.is_terminated = true;
310                        return std::task::Poll::Ready(None);
311                    }
312                    std::task::Poll::Ready(Err(e)) => {
313                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
314                            e.into(),
315                        ))))
316                    }
317                }
318
319                // A message has been received from the channel
320                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
321
322                std::task::Poll::Ready(Some(match header.ordinal {
323                    0x4b2c4d82dae82c6d => {
324                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
325                        let mut req = fidl::new_empty!(
326                            DeviceRegisterSocketRequest,
327                            fidl::encoding::DefaultFuchsiaResourceDialect
328                        );
329                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceRegisterSocketRequest>(&header, _body_bytes, handles, &mut req)?;
330                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
331                        Ok(DeviceRequest::RegisterSocket {
332                            payload: req,
333                            responder: DeviceRegisterSocketResponder {
334                                control_handle: std::mem::ManuallyDrop::new(control_handle),
335                                tx_id: header.tx_id,
336                            },
337                        })
338                    }
339                    _ if header.tx_id == 0
340                        && header
341                            .dynamic_flags()
342                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
343                    {
344                        Ok(DeviceRequest::_UnknownMethod {
345                            ordinal: header.ordinal,
346                            control_handle: DeviceControlHandle { inner: this.inner.clone() },
347                            method_type: fidl::MethodType::OneWay,
348                        })
349                    }
350                    _ if header
351                        .dynamic_flags()
352                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
353                    {
354                        this.inner.send_framework_err(
355                            fidl::encoding::FrameworkErr::UnknownMethod,
356                            header.tx_id,
357                            header.ordinal,
358                            header.dynamic_flags(),
359                            (bytes, handles),
360                        )?;
361                        Ok(DeviceRequest::_UnknownMethod {
362                            ordinal: header.ordinal,
363                            control_handle: DeviceControlHandle { inner: this.inner.clone() },
364                            method_type: fidl::MethodType::TwoWay,
365                        })
366                    }
367                    _ => Err(fidl::Error::UnknownOrdinal {
368                        ordinal: header.ordinal,
369                        protocol_name:
370                            <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
371                    }),
372                }))
373            },
374        )
375    }
376}
377
378/// Client is expected to open a socket and pass
379/// the server-side handle to the Server.
380#[derive(Debug)]
381pub enum DeviceRequest {
382    RegisterSocket {
383        payload: DeviceRegisterSocketRequest,
384        responder: DeviceRegisterSocketResponder,
385    },
386    /// An interaction was received which does not match any known method.
387    #[non_exhaustive]
388    _UnknownMethod {
389        /// Ordinal of the method that was called.
390        ordinal: u64,
391        control_handle: DeviceControlHandle,
392        method_type: fidl::MethodType,
393    },
394}
395
396impl DeviceRequest {
397    #[allow(irrefutable_let_patterns)]
398    pub fn into_register_socket(
399        self,
400    ) -> Option<(DeviceRegisterSocketRequest, DeviceRegisterSocketResponder)> {
401        if let DeviceRequest::RegisterSocket { payload, responder } = self {
402            Some((payload, responder))
403        } else {
404            None
405        }
406    }
407
408    /// Name of the method defined in FIDL
409    pub fn method_name(&self) -> &'static str {
410        match *self {
411            DeviceRequest::RegisterSocket { .. } => "register_socket",
412            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
413                "unknown one-way method"
414            }
415            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
416                "unknown two-way method"
417            }
418        }
419    }
420}
421
422#[derive(Debug, Clone)]
423pub struct DeviceControlHandle {
424    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
425}
426
427impl fidl::endpoints::ControlHandle for DeviceControlHandle {
428    fn shutdown(&self) {
429        self.inner.shutdown()
430    }
431    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
432        self.inner.shutdown_with_epitaph(status)
433    }
434
435    fn is_closed(&self) -> bool {
436        self.inner.channel().is_closed()
437    }
438    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
439        self.inner.channel().on_closed()
440    }
441
442    #[cfg(target_os = "fuchsia")]
443    fn signal_peer(
444        &self,
445        clear_mask: zx::Signals,
446        set_mask: zx::Signals,
447    ) -> Result<(), zx_status::Status> {
448        use fidl::Peered;
449        self.inner.channel().signal_peer(clear_mask, set_mask)
450    }
451}
452
453impl DeviceControlHandle {}
454
455#[must_use = "FIDL methods require a response to be sent"]
456#[derive(Debug)]
457pub struct DeviceRegisterSocketResponder {
458    control_handle: std::mem::ManuallyDrop<DeviceControlHandle>,
459    tx_id: u32,
460}
461
462/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
463/// if the responder is dropped without sending a response, so that the client
464/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
465impl std::ops::Drop for DeviceRegisterSocketResponder {
466    fn drop(&mut self) {
467        self.control_handle.shutdown();
468        // Safety: drops once, never accessed again
469        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
470    }
471}
472
473impl fidl::endpoints::Responder for DeviceRegisterSocketResponder {
474    type ControlHandle = DeviceControlHandle;
475
476    fn control_handle(&self) -> &DeviceControlHandle {
477        &self.control_handle
478    }
479
480    fn drop_without_shutdown(mut self) {
481        // Safety: drops once, never accessed again due to mem::forget
482        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
483        // Prevent Drop from running (which would shut down the channel)
484        std::mem::forget(self);
485    }
486}
487
488impl DeviceRegisterSocketResponder {
489    /// Sends a response to the FIDL transaction.
490    ///
491    /// Sets the channel to shutdown if an error occurs.
492    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
493        let _result = self.send_raw(result);
494        if _result.is_err() {
495            self.control_handle.shutdown();
496        }
497        self.drop_without_shutdown();
498        _result
499    }
500
501    /// Similar to "send" but does not shutdown the channel if an error occurs.
502    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
503        let _result = self.send_raw(result);
504        self.drop_without_shutdown();
505        _result
506    }
507
508    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
509        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
510            fidl::encoding::EmptyStruct,
511            i32,
512        >>(
513            fidl::encoding::FlexibleResult::new(result),
514            self.tx_id,
515            0x4b2c4d82dae82c6d,
516            fidl::encoding::DynamicFlags::FLEXIBLE,
517        )
518    }
519}
520
521#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
522pub struct ServiceMarker;
523
524#[cfg(target_os = "fuchsia")]
525impl fidl::endpoints::ServiceMarker for ServiceMarker {
526    type Proxy = ServiceProxy;
527    type Request = ServiceRequest;
528    const SERVICE_NAME: &'static str = "fuchsia.hardware.sockettunnel.Service";
529}
530
531/// A request for one of the member protocols of Service.
532///
533#[cfg(target_os = "fuchsia")]
534pub enum ServiceRequest {
535    SocketTunnel(DeviceRequestStream),
536}
537
538#[cfg(target_os = "fuchsia")]
539impl fidl::endpoints::ServiceRequest for ServiceRequest {
540    type Service = ServiceMarker;
541
542    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
543        match name {
544            "socket_tunnel" => Self::SocketTunnel(
545                <DeviceRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
546            ),
547            _ => panic!("no such member protocol name for service Service"),
548        }
549    }
550
551    fn member_names() -> &'static [&'static str] {
552        &["socket_tunnel"]
553    }
554}
555#[cfg(target_os = "fuchsia")]
556pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
557
558#[cfg(target_os = "fuchsia")]
559impl fidl::endpoints::ServiceProxy for ServiceProxy {
560    type Service = ServiceMarker;
561
562    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
563        Self(opener)
564    }
565}
566
567#[cfg(target_os = "fuchsia")]
568impl ServiceProxy {
569    pub fn connect_to_socket_tunnel(&self) -> Result<DeviceProxy, fidl::Error> {
570        let (proxy, server_end) = fidl::endpoints::create_proxy::<DeviceMarker>();
571        self.connect_channel_to_socket_tunnel(server_end)?;
572        Ok(proxy)
573    }
574
575    /// Like `connect_to_socket_tunnel`, but returns a sync proxy.
576    /// See [`Self::connect_to_socket_tunnel`] for more details.
577    pub fn connect_to_socket_tunnel_sync(&self) -> Result<DeviceSynchronousProxy, fidl::Error> {
578        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DeviceMarker>();
579        self.connect_channel_to_socket_tunnel(server_end)?;
580        Ok(proxy)
581    }
582
583    /// Like `connect_to_socket_tunnel`, but accepts a server end.
584    /// See [`Self::connect_to_socket_tunnel`] for more details.
585    pub fn connect_channel_to_socket_tunnel(
586        &self,
587        server_end: fidl::endpoints::ServerEnd<DeviceMarker>,
588    ) -> Result<(), fidl::Error> {
589        self.0.open_member("socket_tunnel", server_end.into_channel())
590    }
591
592    pub fn instance_name(&self) -> &str {
593        self.0.instance_name()
594    }
595}
596
597mod internal {
598    use super::*;
599
600    impl DeviceRegisterSocketRequest {
601        #[inline(always)]
602        fn max_ordinal_present(&self) -> u64 {
603            if let Some(_) = self.socket_label {
604                return 2;
605            }
606            if let Some(_) = self.server_socket {
607                return 1;
608            }
609            0
610        }
611    }
612
613    impl fidl::encoding::ResourceTypeMarker for DeviceRegisterSocketRequest {
614        type Borrowed<'a> = &'a mut Self;
615        fn take_or_borrow<'a>(
616            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
617        ) -> Self::Borrowed<'a> {
618            value
619        }
620    }
621
622    unsafe impl fidl::encoding::TypeMarker for DeviceRegisterSocketRequest {
623        type Owned = Self;
624
625        #[inline(always)]
626        fn inline_align(_context: fidl::encoding::Context) -> usize {
627            8
628        }
629
630        #[inline(always)]
631        fn inline_size(_context: fidl::encoding::Context) -> usize {
632            16
633        }
634    }
635
636    unsafe impl
637        fidl::encoding::Encode<
638            DeviceRegisterSocketRequest,
639            fidl::encoding::DefaultFuchsiaResourceDialect,
640        > for &mut DeviceRegisterSocketRequest
641    {
642        unsafe fn encode(
643            self,
644            encoder: &mut fidl::encoding::Encoder<
645                '_,
646                fidl::encoding::DefaultFuchsiaResourceDialect,
647            >,
648            offset: usize,
649            mut depth: fidl::encoding::Depth,
650        ) -> fidl::Result<()> {
651            encoder.debug_check_bounds::<DeviceRegisterSocketRequest>(offset);
652            // Vector header
653            let max_ordinal: u64 = self.max_ordinal_present();
654            encoder.write_num(max_ordinal, offset);
655            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
656            // Calling encoder.out_of_line_offset(0) is not allowed.
657            if max_ordinal == 0 {
658                return Ok(());
659            }
660            depth.increment()?;
661            let envelope_size = 8;
662            let bytes_len = max_ordinal as usize * envelope_size;
663            #[allow(unused_variables)]
664            let offset = encoder.out_of_line_offset(bytes_len);
665            let mut _prev_end_offset: usize = 0;
666            if 1 > max_ordinal {
667                return Ok(());
668            }
669
670            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
671            // are envelope_size bytes.
672            let cur_offset: usize = (1 - 1) * envelope_size;
673
674            // Zero reserved fields.
675            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
676
677            // Safety:
678            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
679            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
680            //   envelope_size bytes, there is always sufficient room.
681            fidl::encoding::encode_in_envelope_optional::<
682                fidl::encoding::HandleType<
683                    fidl::Socket,
684                    { fidl::ObjectType::SOCKET.into_raw() },
685                    2147483648,
686                >,
687                fidl::encoding::DefaultFuchsiaResourceDialect,
688            >(
689                self.server_socket.as_mut().map(
690                    <fidl::encoding::HandleType<
691                        fidl::Socket,
692                        { fidl::ObjectType::SOCKET.into_raw() },
693                        2147483648,
694                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
695                ),
696                encoder,
697                offset + cur_offset,
698                depth,
699            )?;
700
701            _prev_end_offset = cur_offset + envelope_size;
702            if 2 > max_ordinal {
703                return Ok(());
704            }
705
706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
707            // are envelope_size bytes.
708            let cur_offset: usize = (2 - 1) * envelope_size;
709
710            // Zero reserved fields.
711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
712
713            // Safety:
714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
716            //   envelope_size bytes, there is always sufficient room.
717            fidl::encoding::encode_in_envelope_optional::<
718                fidl::encoding::UnboundedString,
719                fidl::encoding::DefaultFuchsiaResourceDialect,
720            >(
721                self.socket_label.as_ref().map(
722                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
723                ),
724                encoder,
725                offset + cur_offset,
726                depth,
727            )?;
728
729            _prev_end_offset = cur_offset + envelope_size;
730
731            Ok(())
732        }
733    }
734
735    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
736        for DeviceRegisterSocketRequest
737    {
738        #[inline(always)]
739        fn new_empty() -> Self {
740            Self::default()
741        }
742
743        unsafe fn decode(
744            &mut self,
745            decoder: &mut fidl::encoding::Decoder<
746                '_,
747                fidl::encoding::DefaultFuchsiaResourceDialect,
748            >,
749            offset: usize,
750            mut depth: fidl::encoding::Depth,
751        ) -> fidl::Result<()> {
752            decoder.debug_check_bounds::<Self>(offset);
753            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
754                None => return Err(fidl::Error::NotNullable),
755                Some(len) => len,
756            };
757            // Calling decoder.out_of_line_offset(0) is not allowed.
758            if len == 0 {
759                return Ok(());
760            };
761            depth.increment()?;
762            let envelope_size = 8;
763            let bytes_len = len * envelope_size;
764            let offset = decoder.out_of_line_offset(bytes_len)?;
765            // Decode the envelope for each type.
766            let mut _next_ordinal_to_read = 0;
767            let mut next_offset = offset;
768            let end_offset = offset + bytes_len;
769            _next_ordinal_to_read += 1;
770            if next_offset >= end_offset {
771                return Ok(());
772            }
773
774            // Decode unknown envelopes for gaps in ordinals.
775            while _next_ordinal_to_read < 1 {
776                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
777                _next_ordinal_to_read += 1;
778                next_offset += envelope_size;
779            }
780
781            let next_out_of_line = decoder.next_out_of_line();
782            let handles_before = decoder.remaining_handles();
783            if let Some((inlined, num_bytes, num_handles)) =
784                fidl::encoding::decode_envelope_header(decoder, next_offset)?
785            {
786                let member_inline_size = <fidl::encoding::HandleType<
787                    fidl::Socket,
788                    { fidl::ObjectType::SOCKET.into_raw() },
789                    2147483648,
790                > as fidl::encoding::TypeMarker>::inline_size(
791                    decoder.context
792                );
793                if inlined != (member_inline_size <= 4) {
794                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
795                }
796                let inner_offset;
797                let mut inner_depth = depth.clone();
798                if inlined {
799                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
800                    inner_offset = next_offset;
801                } else {
802                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
803                    inner_depth.increment()?;
804                }
805                let val_ref =
806                self.server_socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
807                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
808                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
809                {
810                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
811                }
812                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
813                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
814                }
815            }
816
817            next_offset += envelope_size;
818            _next_ordinal_to_read += 1;
819            if next_offset >= end_offset {
820                return Ok(());
821            }
822
823            // Decode unknown envelopes for gaps in ordinals.
824            while _next_ordinal_to_read < 2 {
825                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
826                _next_ordinal_to_read += 1;
827                next_offset += envelope_size;
828            }
829
830            let next_out_of_line = decoder.next_out_of_line();
831            let handles_before = decoder.remaining_handles();
832            if let Some((inlined, num_bytes, num_handles)) =
833                fidl::encoding::decode_envelope_header(decoder, next_offset)?
834            {
835                let member_inline_size =
836                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
837                        decoder.context,
838                    );
839                if inlined != (member_inline_size <= 4) {
840                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
841                }
842                let inner_offset;
843                let mut inner_depth = depth.clone();
844                if inlined {
845                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
846                    inner_offset = next_offset;
847                } else {
848                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
849                    inner_depth.increment()?;
850                }
851                let val_ref = self.socket_label.get_or_insert_with(|| {
852                    fidl::new_empty!(
853                        fidl::encoding::UnboundedString,
854                        fidl::encoding::DefaultFuchsiaResourceDialect
855                    )
856                });
857                fidl::decode!(
858                    fidl::encoding::UnboundedString,
859                    fidl::encoding::DefaultFuchsiaResourceDialect,
860                    val_ref,
861                    decoder,
862                    inner_offset,
863                    inner_depth
864                )?;
865                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
866                {
867                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
868                }
869                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
870                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
871                }
872            }
873
874            next_offset += envelope_size;
875
876            // Decode the remaining unknown envelopes.
877            while next_offset < end_offset {
878                _next_ordinal_to_read += 1;
879                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
880                next_offset += envelope_size;
881            }
882
883            Ok(())
884        }
885    }
886}
fidl_fuchsia_hardware_sockettunnel/fidl_fuchsia_hardware_sockettunnel.rs

fidl_fuchsia_hardware_sockettunnel/
fidl_fuchsia_hardware_sockettunnel.rs
