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

fidl_test_proxy_stress/
fidl_test_proxy_stress.rs
