fidl_fuchsia_developer_ffx_speedtest/
fidl_fuchsia_developer_ffx_speedtest.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_developer_ffx_speedtest__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct SpeedtestSocketDownRequest {
16    pub socket: fidl::Socket,
17    pub params: TransferParams,
18}
19
20impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
21    for SpeedtestSocketDownRequest
22{
23}
24
25#[derive(Debug, PartialEq)]
26pub struct SpeedtestSocketUpRequest {
27    pub socket: fidl::Socket,
28    pub params: TransferParams,
29}
30
31impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SpeedtestSocketUpRequest {}
32
33#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
34pub struct SpeedtestMarker;
35
36impl fidl::endpoints::ProtocolMarker for SpeedtestMarker {
37    type Proxy = SpeedtestProxy;
38    type RequestStream = SpeedtestRequestStream;
39    #[cfg(target_os = "fuchsia")]
40    type SynchronousProxy = SpeedtestSynchronousProxy;
41
42    const DEBUG_NAME: &'static str = "fuchsia.developer.ffx.speedtest.Speedtest";
43}
44impl fidl::endpoints::DiscoverableProtocolMarker for SpeedtestMarker {}
45
46pub trait SpeedtestProxyInterface: Send + Sync {
47    type PingResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
48    fn r#ping(&self) -> Self::PingResponseFut;
49    type SocketUpResponseFut: std::future::Future<Output = Result<TransferReport, fidl::Error>>
50        + Send;
51    fn r#socket_up(
52        &self,
53        socket: fidl::Socket,
54        params: &TransferParams,
55    ) -> Self::SocketUpResponseFut;
56    type SocketDownResponseFut: std::future::Future<Output = Result<TransferReport, fidl::Error>>
57        + Send;
58    fn r#socket_down(
59        &self,
60        socket: fidl::Socket,
61        params: &TransferParams,
62    ) -> Self::SocketDownResponseFut;
63}
64#[derive(Debug)]
65#[cfg(target_os = "fuchsia")]
66pub struct SpeedtestSynchronousProxy {
67    client: fidl::client::sync::Client,
68}
69
70#[cfg(target_os = "fuchsia")]
71impl fidl::endpoints::SynchronousProxy for SpeedtestSynchronousProxy {
72    type Proxy = SpeedtestProxy;
73    type Protocol = SpeedtestMarker;
74
75    fn from_channel(inner: fidl::Channel) -> Self {
76        Self::new(inner)
77    }
78
79    fn into_channel(self) -> fidl::Channel {
80        self.client.into_channel()
81    }
82
83    fn as_channel(&self) -> &fidl::Channel {
84        self.client.as_channel()
85    }
86}
87
88#[cfg(target_os = "fuchsia")]
89impl SpeedtestSynchronousProxy {
90    pub fn new(channel: fidl::Channel) -> Self {
91        let protocol_name = <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
92        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
93    }
94
95    pub fn into_channel(self) -> fidl::Channel {
96        self.client.into_channel()
97    }
98
99    /// Waits until an event arrives and returns it. It is safe for other
100    /// threads to make concurrent requests while waiting for an event.
101    pub fn wait_for_event(
102        &self,
103        deadline: zx::MonotonicInstant,
104    ) -> Result<SpeedtestEvent, fidl::Error> {
105        SpeedtestEvent::decode(self.client.wait_for_event(deadline)?)
106    }
107
108    /// No-op, server responds immediately.
109    pub fn r#ping(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
110        let _response = self.client.send_query::<
111            fidl::encoding::EmptyPayload,
112            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
113        >(
114            (),
115            0x1511ccb237874689,
116            fidl::encoding::DynamicFlags::FLEXIBLE,
117            ___deadline,
118        )?
119        .into_result::<SpeedtestMarker>("ping")?;
120        Ok(_response)
121    }
122
123    /// Server writes data into the provided zircon socket and reports stats.
124    pub fn r#socket_up(
125        &self,
126        mut socket: fidl::Socket,
127        mut params: &TransferParams,
128        ___deadline: zx::MonotonicInstant,
129    ) -> Result<TransferReport, fidl::Error> {
130        let _response = self
131            .client
132            .send_query::<SpeedtestSocketUpRequest, fidl::encoding::FlexibleType<TransferReport>>(
133                (socket, params),
134                0x7c530a369209ae87,
135                fidl::encoding::DynamicFlags::FLEXIBLE,
136                ___deadline,
137            )?
138            .into_result::<SpeedtestMarker>("socket_up")?;
139        Ok(_response)
140    }
141
142    /// Server reads data from the provided zircon socket and reports stats.
143    pub fn r#socket_down(
144        &self,
145        mut socket: fidl::Socket,
146        mut params: &TransferParams,
147        ___deadline: zx::MonotonicInstant,
148    ) -> Result<TransferReport, fidl::Error> {
149        let _response = self
150            .client
151            .send_query::<SpeedtestSocketDownRequest, fidl::encoding::FlexibleType<TransferReport>>(
152                (socket, params),
153                0x426e13de44070751,
154                fidl::encoding::DynamicFlags::FLEXIBLE,
155                ___deadline,
156            )?
157            .into_result::<SpeedtestMarker>("socket_down")?;
158        Ok(_response)
159    }
160}
161
162#[cfg(target_os = "fuchsia")]
163impl From<SpeedtestSynchronousProxy> for zx::Handle {
164    fn from(value: SpeedtestSynchronousProxy) -> Self {
165        value.into_channel().into()
166    }
167}
168
169#[cfg(target_os = "fuchsia")]
170impl From<fidl::Channel> for SpeedtestSynchronousProxy {
171    fn from(value: fidl::Channel) -> Self {
172        Self::new(value)
173    }
174}
175
176#[cfg(target_os = "fuchsia")]
177impl fidl::endpoints::FromClient for SpeedtestSynchronousProxy {
178    type Protocol = SpeedtestMarker;
179
180    fn from_client(value: fidl::endpoints::ClientEnd<SpeedtestMarker>) -> Self {
181        Self::new(value.into_channel())
182    }
183}
184
185#[derive(Debug, Clone)]
186pub struct SpeedtestProxy {
187    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
188}
189
190impl fidl::endpoints::Proxy for SpeedtestProxy {
191    type Protocol = SpeedtestMarker;
192
193    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
194        Self::new(inner)
195    }
196
197    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
198        self.client.into_channel().map_err(|client| Self { client })
199    }
200
201    fn as_channel(&self) -> &::fidl::AsyncChannel {
202        self.client.as_channel()
203    }
204}
205
206impl SpeedtestProxy {
207    /// Create a new Proxy for fuchsia.developer.ffx.speedtest/Speedtest.
208    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
209        let protocol_name = <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
210        Self { client: fidl::client::Client::new(channel, protocol_name) }
211    }
212
213    /// Get a Stream of events from the remote end of the protocol.
214    ///
215    /// # Panics
216    ///
217    /// Panics if the event stream was already taken.
218    pub fn take_event_stream(&self) -> SpeedtestEventStream {
219        SpeedtestEventStream { event_receiver: self.client.take_event_receiver() }
220    }
221
222    /// No-op, server responds immediately.
223    pub fn r#ping(
224        &self,
225    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
226        SpeedtestProxyInterface::r#ping(self)
227    }
228
229    /// Server writes data into the provided zircon socket and reports stats.
230    pub fn r#socket_up(
231        &self,
232        mut socket: fidl::Socket,
233        mut params: &TransferParams,
234    ) -> fidl::client::QueryResponseFut<TransferReport, fidl::encoding::DefaultFuchsiaResourceDialect>
235    {
236        SpeedtestProxyInterface::r#socket_up(self, socket, params)
237    }
238
239    /// Server reads data from the provided zircon socket and reports stats.
240    pub fn r#socket_down(
241        &self,
242        mut socket: fidl::Socket,
243        mut params: &TransferParams,
244    ) -> fidl::client::QueryResponseFut<TransferReport, fidl::encoding::DefaultFuchsiaResourceDialect>
245    {
246        SpeedtestProxyInterface::r#socket_down(self, socket, params)
247    }
248}
249
250impl SpeedtestProxyInterface for SpeedtestProxy {
251    type PingResponseFut =
252        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
253    fn r#ping(&self) -> Self::PingResponseFut {
254        fn _decode(
255            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
256        ) -> Result<(), fidl::Error> {
257            let _response = fidl::client::decode_transaction_body::<
258                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
259                fidl::encoding::DefaultFuchsiaResourceDialect,
260                0x1511ccb237874689,
261            >(_buf?)?
262            .into_result::<SpeedtestMarker>("ping")?;
263            Ok(_response)
264        }
265        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
266            (),
267            0x1511ccb237874689,
268            fidl::encoding::DynamicFlags::FLEXIBLE,
269            _decode,
270        )
271    }
272
273    type SocketUpResponseFut = fidl::client::QueryResponseFut<
274        TransferReport,
275        fidl::encoding::DefaultFuchsiaResourceDialect,
276    >;
277    fn r#socket_up(
278        &self,
279        mut socket: fidl::Socket,
280        mut params: &TransferParams,
281    ) -> Self::SocketUpResponseFut {
282        fn _decode(
283            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
284        ) -> Result<TransferReport, fidl::Error> {
285            let _response = fidl::client::decode_transaction_body::<
286                fidl::encoding::FlexibleType<TransferReport>,
287                fidl::encoding::DefaultFuchsiaResourceDialect,
288                0x7c530a369209ae87,
289            >(_buf?)?
290            .into_result::<SpeedtestMarker>("socket_up")?;
291            Ok(_response)
292        }
293        self.client.send_query_and_decode::<SpeedtestSocketUpRequest, TransferReport>(
294            (socket, params),
295            0x7c530a369209ae87,
296            fidl::encoding::DynamicFlags::FLEXIBLE,
297            _decode,
298        )
299    }
300
301    type SocketDownResponseFut = fidl::client::QueryResponseFut<
302        TransferReport,
303        fidl::encoding::DefaultFuchsiaResourceDialect,
304    >;
305    fn r#socket_down(
306        &self,
307        mut socket: fidl::Socket,
308        mut params: &TransferParams,
309    ) -> Self::SocketDownResponseFut {
310        fn _decode(
311            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
312        ) -> Result<TransferReport, fidl::Error> {
313            let _response = fidl::client::decode_transaction_body::<
314                fidl::encoding::FlexibleType<TransferReport>,
315                fidl::encoding::DefaultFuchsiaResourceDialect,
316                0x426e13de44070751,
317            >(_buf?)?
318            .into_result::<SpeedtestMarker>("socket_down")?;
319            Ok(_response)
320        }
321        self.client.send_query_and_decode::<SpeedtestSocketDownRequest, TransferReport>(
322            (socket, params),
323            0x426e13de44070751,
324            fidl::encoding::DynamicFlags::FLEXIBLE,
325            _decode,
326        )
327    }
328}
329
330pub struct SpeedtestEventStream {
331    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
332}
333
334impl std::marker::Unpin for SpeedtestEventStream {}
335
336impl futures::stream::FusedStream for SpeedtestEventStream {
337    fn is_terminated(&self) -> bool {
338        self.event_receiver.is_terminated()
339    }
340}
341
342impl futures::Stream for SpeedtestEventStream {
343    type Item = Result<SpeedtestEvent, fidl::Error>;
344
345    fn poll_next(
346        mut self: std::pin::Pin<&mut Self>,
347        cx: &mut std::task::Context<'_>,
348    ) -> std::task::Poll<Option<Self::Item>> {
349        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
350            &mut self.event_receiver,
351            cx
352        )?) {
353            Some(buf) => std::task::Poll::Ready(Some(SpeedtestEvent::decode(buf))),
354            None => std::task::Poll::Ready(None),
355        }
356    }
357}
358
359#[derive(Debug)]
360pub enum SpeedtestEvent {
361    #[non_exhaustive]
362    _UnknownEvent {
363        /// Ordinal of the event that was sent.
364        ordinal: u64,
365    },
366}
367
368impl SpeedtestEvent {
369    /// Decodes a message buffer as a [`SpeedtestEvent`].
370    fn decode(
371        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
372    ) -> Result<SpeedtestEvent, fidl::Error> {
373        let (bytes, _handles) = buf.split_mut();
374        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
375        debug_assert_eq!(tx_header.tx_id, 0);
376        match tx_header.ordinal {
377            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
378                Ok(SpeedtestEvent::_UnknownEvent { ordinal: tx_header.ordinal })
379            }
380            _ => Err(fidl::Error::UnknownOrdinal {
381                ordinal: tx_header.ordinal,
382                protocol_name: <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
383            }),
384        }
385    }
386}
387
388/// A Stream of incoming requests for fuchsia.developer.ffx.speedtest/Speedtest.
389pub struct SpeedtestRequestStream {
390    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
391    is_terminated: bool,
392}
393
394impl std::marker::Unpin for SpeedtestRequestStream {}
395
396impl futures::stream::FusedStream for SpeedtestRequestStream {
397    fn is_terminated(&self) -> bool {
398        self.is_terminated
399    }
400}
401
402impl fidl::endpoints::RequestStream for SpeedtestRequestStream {
403    type Protocol = SpeedtestMarker;
404    type ControlHandle = SpeedtestControlHandle;
405
406    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
407        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
408    }
409
410    fn control_handle(&self) -> Self::ControlHandle {
411        SpeedtestControlHandle { inner: self.inner.clone() }
412    }
413
414    fn into_inner(
415        self,
416    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
417    {
418        (self.inner, self.is_terminated)
419    }
420
421    fn from_inner(
422        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
423        is_terminated: bool,
424    ) -> Self {
425        Self { inner, is_terminated }
426    }
427}
428
429impl futures::Stream for SpeedtestRequestStream {
430    type Item = Result<SpeedtestRequest, fidl::Error>;
431
432    fn poll_next(
433        mut self: std::pin::Pin<&mut Self>,
434        cx: &mut std::task::Context<'_>,
435    ) -> std::task::Poll<Option<Self::Item>> {
436        let this = &mut *self;
437        if this.inner.check_shutdown(cx) {
438            this.is_terminated = true;
439            return std::task::Poll::Ready(None);
440        }
441        if this.is_terminated {
442            panic!("polled SpeedtestRequestStream after completion");
443        }
444        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
445            |bytes, handles| {
446                match this.inner.channel().read_etc(cx, bytes, handles) {
447                    std::task::Poll::Ready(Ok(())) => {}
448                    std::task::Poll::Pending => return std::task::Poll::Pending,
449                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
450                        this.is_terminated = true;
451                        return std::task::Poll::Ready(None);
452                    }
453                    std::task::Poll::Ready(Err(e)) => {
454                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
455                            e.into(),
456                        ))));
457                    }
458                }
459
460                // A message has been received from the channel
461                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
462
463                std::task::Poll::Ready(Some(match header.ordinal {
464                    0x1511ccb237874689 => {
465                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
466                        let mut req = fidl::new_empty!(
467                            fidl::encoding::EmptyPayload,
468                            fidl::encoding::DefaultFuchsiaResourceDialect
469                        );
470                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
471                        let control_handle = SpeedtestControlHandle { inner: this.inner.clone() };
472                        Ok(SpeedtestRequest::Ping {
473                            responder: SpeedtestPingResponder {
474                                control_handle: std::mem::ManuallyDrop::new(control_handle),
475                                tx_id: header.tx_id,
476                            },
477                        })
478                    }
479                    0x7c530a369209ae87 => {
480                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
481                        let mut req = fidl::new_empty!(
482                            SpeedtestSocketUpRequest,
483                            fidl::encoding::DefaultFuchsiaResourceDialect
484                        );
485                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SpeedtestSocketUpRequest>(&header, _body_bytes, handles, &mut req)?;
486                        let control_handle = SpeedtestControlHandle { inner: this.inner.clone() };
487                        Ok(SpeedtestRequest::SocketUp {
488                            socket: req.socket,
489                            params: req.params,
490
491                            responder: SpeedtestSocketUpResponder {
492                                control_handle: std::mem::ManuallyDrop::new(control_handle),
493                                tx_id: header.tx_id,
494                            },
495                        })
496                    }
497                    0x426e13de44070751 => {
498                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
499                        let mut req = fidl::new_empty!(
500                            SpeedtestSocketDownRequest,
501                            fidl::encoding::DefaultFuchsiaResourceDialect
502                        );
503                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SpeedtestSocketDownRequest>(&header, _body_bytes, handles, &mut req)?;
504                        let control_handle = SpeedtestControlHandle { inner: this.inner.clone() };
505                        Ok(SpeedtestRequest::SocketDown {
506                            socket: req.socket,
507                            params: req.params,
508
509                            responder: SpeedtestSocketDownResponder {
510                                control_handle: std::mem::ManuallyDrop::new(control_handle),
511                                tx_id: header.tx_id,
512                            },
513                        })
514                    }
515                    _ if header.tx_id == 0
516                        && header
517                            .dynamic_flags()
518                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
519                    {
520                        Ok(SpeedtestRequest::_UnknownMethod {
521                            ordinal: header.ordinal,
522                            control_handle: SpeedtestControlHandle { inner: this.inner.clone() },
523                            method_type: fidl::MethodType::OneWay,
524                        })
525                    }
526                    _ if header
527                        .dynamic_flags()
528                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
529                    {
530                        this.inner.send_framework_err(
531                            fidl::encoding::FrameworkErr::UnknownMethod,
532                            header.tx_id,
533                            header.ordinal,
534                            header.dynamic_flags(),
535                            (bytes, handles),
536                        )?;
537                        Ok(SpeedtestRequest::_UnknownMethod {
538                            ordinal: header.ordinal,
539                            control_handle: SpeedtestControlHandle { inner: this.inner.clone() },
540                            method_type: fidl::MethodType::TwoWay,
541                        })
542                    }
543                    _ => Err(fidl::Error::UnknownOrdinal {
544                        ordinal: header.ordinal,
545                        protocol_name:
546                            <SpeedtestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
547                    }),
548                }))
549            },
550        )
551    }
552}
553
554#[derive(Debug)]
555pub enum SpeedtestRequest {
556    /// No-op, server responds immediately.
557    Ping { responder: SpeedtestPingResponder },
558    /// Server writes data into the provided zircon socket and reports stats.
559    SocketUp { socket: fidl::Socket, params: TransferParams, responder: SpeedtestSocketUpResponder },
560    /// Server reads data from the provided zircon socket and reports stats.
561    SocketDown {
562        socket: fidl::Socket,
563        params: TransferParams,
564        responder: SpeedtestSocketDownResponder,
565    },
566    /// An interaction was received which does not match any known method.
567    #[non_exhaustive]
568    _UnknownMethod {
569        /// Ordinal of the method that was called.
570        ordinal: u64,
571        control_handle: SpeedtestControlHandle,
572        method_type: fidl::MethodType,
573    },
574}
575
576impl SpeedtestRequest {
577    #[allow(irrefutable_let_patterns)]
578    pub fn into_ping(self) -> Option<(SpeedtestPingResponder)> {
579        if let SpeedtestRequest::Ping { responder } = self { Some((responder)) } else { None }
580    }
581
582    #[allow(irrefutable_let_patterns)]
583    pub fn into_socket_up(
584        self,
585    ) -> Option<(fidl::Socket, TransferParams, SpeedtestSocketUpResponder)> {
586        if let SpeedtestRequest::SocketUp { socket, params, responder } = self {
587            Some((socket, params, responder))
588        } else {
589            None
590        }
591    }
592
593    #[allow(irrefutable_let_patterns)]
594    pub fn into_socket_down(
595        self,
596    ) -> Option<(fidl::Socket, TransferParams, SpeedtestSocketDownResponder)> {
597        if let SpeedtestRequest::SocketDown { socket, params, responder } = self {
598            Some((socket, params, responder))
599        } else {
600            None
601        }
602    }
603
604    /// Name of the method defined in FIDL
605    pub fn method_name(&self) -> &'static str {
606        match *self {
607            SpeedtestRequest::Ping { .. } => "ping",
608            SpeedtestRequest::SocketUp { .. } => "socket_up",
609            SpeedtestRequest::SocketDown { .. } => "socket_down",
610            SpeedtestRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
611                "unknown one-way method"
612            }
613            SpeedtestRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
614                "unknown two-way method"
615            }
616        }
617    }
618}
619
620#[derive(Debug, Clone)]
621pub struct SpeedtestControlHandle {
622    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
623}
624
625impl fidl::endpoints::ControlHandle for SpeedtestControlHandle {
626    fn shutdown(&self) {
627        self.inner.shutdown()
628    }
629    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
630        self.inner.shutdown_with_epitaph(status)
631    }
632
633    fn is_closed(&self) -> bool {
634        self.inner.channel().is_closed()
635    }
636    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
637        self.inner.channel().on_closed()
638    }
639
640    #[cfg(target_os = "fuchsia")]
641    fn signal_peer(
642        &self,
643        clear_mask: zx::Signals,
644        set_mask: zx::Signals,
645    ) -> Result<(), zx_status::Status> {
646        use fidl::Peered;
647        self.inner.channel().signal_peer(clear_mask, set_mask)
648    }
649}
650
651impl SpeedtestControlHandle {}
652
653#[must_use = "FIDL methods require a response to be sent"]
654#[derive(Debug)]
655pub struct SpeedtestPingResponder {
656    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
657    tx_id: u32,
658}
659
660/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
661/// if the responder is dropped without sending a response, so that the client
662/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
663impl std::ops::Drop for SpeedtestPingResponder {
664    fn drop(&mut self) {
665        self.control_handle.shutdown();
666        // Safety: drops once, never accessed again
667        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
668    }
669}
670
671impl fidl::endpoints::Responder for SpeedtestPingResponder {
672    type ControlHandle = SpeedtestControlHandle;
673
674    fn control_handle(&self) -> &SpeedtestControlHandle {
675        &self.control_handle
676    }
677
678    fn drop_without_shutdown(mut self) {
679        // Safety: drops once, never accessed again due to mem::forget
680        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
681        // Prevent Drop from running (which would shut down the channel)
682        std::mem::forget(self);
683    }
684}
685
686impl SpeedtestPingResponder {
687    /// Sends a response to the FIDL transaction.
688    ///
689    /// Sets the channel to shutdown if an error occurs.
690    pub fn send(self) -> Result<(), fidl::Error> {
691        let _result = self.send_raw();
692        if _result.is_err() {
693            self.control_handle.shutdown();
694        }
695        self.drop_without_shutdown();
696        _result
697    }
698
699    /// Similar to "send" but does not shutdown the channel if an error occurs.
700    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
701        let _result = self.send_raw();
702        self.drop_without_shutdown();
703        _result
704    }
705
706    fn send_raw(&self) -> Result<(), fidl::Error> {
707        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
708            fidl::encoding::Flexible::new(()),
709            self.tx_id,
710            0x1511ccb237874689,
711            fidl::encoding::DynamicFlags::FLEXIBLE,
712        )
713    }
714}
715
716#[must_use = "FIDL methods require a response to be sent"]
717#[derive(Debug)]
718pub struct SpeedtestSocketUpResponder {
719    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
720    tx_id: u32,
721}
722
723/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
724/// if the responder is dropped without sending a response, so that the client
725/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
726impl std::ops::Drop for SpeedtestSocketUpResponder {
727    fn drop(&mut self) {
728        self.control_handle.shutdown();
729        // Safety: drops once, never accessed again
730        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
731    }
732}
733
734impl fidl::endpoints::Responder for SpeedtestSocketUpResponder {
735    type ControlHandle = SpeedtestControlHandle;
736
737    fn control_handle(&self) -> &SpeedtestControlHandle {
738        &self.control_handle
739    }
740
741    fn drop_without_shutdown(mut self) {
742        // Safety: drops once, never accessed again due to mem::forget
743        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
744        // Prevent Drop from running (which would shut down the channel)
745        std::mem::forget(self);
746    }
747}
748
749impl SpeedtestSocketUpResponder {
750    /// Sends a response to the FIDL transaction.
751    ///
752    /// Sets the channel to shutdown if an error occurs.
753    pub fn send(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
754        let _result = self.send_raw(payload);
755        if _result.is_err() {
756            self.control_handle.shutdown();
757        }
758        self.drop_without_shutdown();
759        _result
760    }
761
762    /// Similar to "send" but does not shutdown the channel if an error occurs.
763    pub fn send_no_shutdown_on_err(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
764        let _result = self.send_raw(payload);
765        self.drop_without_shutdown();
766        _result
767    }
768
769    fn send_raw(&self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
770        self.control_handle.inner.send::<fidl::encoding::FlexibleType<TransferReport>>(
771            fidl::encoding::Flexible::new(payload),
772            self.tx_id,
773            0x7c530a369209ae87,
774            fidl::encoding::DynamicFlags::FLEXIBLE,
775        )
776    }
777}
778
779#[must_use = "FIDL methods require a response to be sent"]
780#[derive(Debug)]
781pub struct SpeedtestSocketDownResponder {
782    control_handle: std::mem::ManuallyDrop<SpeedtestControlHandle>,
783    tx_id: u32,
784}
785
786/// Set the the channel to be shutdown (see [`SpeedtestControlHandle::shutdown`])
787/// if the responder is dropped without sending a response, so that the client
788/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
789impl std::ops::Drop for SpeedtestSocketDownResponder {
790    fn drop(&mut self) {
791        self.control_handle.shutdown();
792        // Safety: drops once, never accessed again
793        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
794    }
795}
796
797impl fidl::endpoints::Responder for SpeedtestSocketDownResponder {
798    type ControlHandle = SpeedtestControlHandle;
799
800    fn control_handle(&self) -> &SpeedtestControlHandle {
801        &self.control_handle
802    }
803
804    fn drop_without_shutdown(mut self) {
805        // Safety: drops once, never accessed again due to mem::forget
806        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
807        // Prevent Drop from running (which would shut down the channel)
808        std::mem::forget(self);
809    }
810}
811
812impl SpeedtestSocketDownResponder {
813    /// Sends a response to the FIDL transaction.
814    ///
815    /// Sets the channel to shutdown if an error occurs.
816    pub fn send(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
817        let _result = self.send_raw(payload);
818        if _result.is_err() {
819            self.control_handle.shutdown();
820        }
821        self.drop_without_shutdown();
822        _result
823    }
824
825    /// Similar to "send" but does not shutdown the channel if an error occurs.
826    pub fn send_no_shutdown_on_err(self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
827        let _result = self.send_raw(payload);
828        self.drop_without_shutdown();
829        _result
830    }
831
832    fn send_raw(&self, mut payload: &TransferReport) -> Result<(), fidl::Error> {
833        self.control_handle.inner.send::<fidl::encoding::FlexibleType<TransferReport>>(
834            fidl::encoding::Flexible::new(payload),
835            self.tx_id,
836            0x426e13de44070751,
837            fidl::encoding::DynamicFlags::FLEXIBLE,
838        )
839    }
840}
841
842mod internal {
843    use super::*;
844
845    impl fidl::encoding::ResourceTypeMarker for SpeedtestSocketDownRequest {
846        type Borrowed<'a> = &'a mut Self;
847        fn take_or_borrow<'a>(
848            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
849        ) -> Self::Borrowed<'a> {
850            value
851        }
852    }
853
854    unsafe impl fidl::encoding::TypeMarker for SpeedtestSocketDownRequest {
855        type Owned = Self;
856
857        #[inline(always)]
858        fn inline_align(_context: fidl::encoding::Context) -> usize {
859            8
860        }
861
862        #[inline(always)]
863        fn inline_size(_context: fidl::encoding::Context) -> usize {
864            24
865        }
866    }
867
868    unsafe impl
869        fidl::encoding::Encode<
870            SpeedtestSocketDownRequest,
871            fidl::encoding::DefaultFuchsiaResourceDialect,
872        > for &mut SpeedtestSocketDownRequest
873    {
874        #[inline]
875        unsafe fn encode(
876            self,
877            encoder: &mut fidl::encoding::Encoder<
878                '_,
879                fidl::encoding::DefaultFuchsiaResourceDialect,
880            >,
881            offset: usize,
882            _depth: fidl::encoding::Depth,
883        ) -> fidl::Result<()> {
884            encoder.debug_check_bounds::<SpeedtestSocketDownRequest>(offset);
885            // Delegate to tuple encoding.
886            fidl::encoding::Encode::<
887                SpeedtestSocketDownRequest,
888                fidl::encoding::DefaultFuchsiaResourceDialect,
889            >::encode(
890                (
891                    <fidl::encoding::HandleType<
892                        fidl::Socket,
893                        { fidl::ObjectType::SOCKET.into_raw() },
894                        16388,
895                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
896                        &mut self.socket
897                    ),
898                    <TransferParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
899                ),
900                encoder,
901                offset,
902                _depth,
903            )
904        }
905    }
906    unsafe impl<
907        T0: fidl::encoding::Encode<
908                fidl::encoding::HandleType<
909                    fidl::Socket,
910                    { fidl::ObjectType::SOCKET.into_raw() },
911                    16388,
912                >,
913                fidl::encoding::DefaultFuchsiaResourceDialect,
914            >,
915        T1: fidl::encoding::Encode<TransferParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
916    >
917        fidl::encoding::Encode<
918            SpeedtestSocketDownRequest,
919            fidl::encoding::DefaultFuchsiaResourceDialect,
920        > for (T0, T1)
921    {
922        #[inline]
923        unsafe fn encode(
924            self,
925            encoder: &mut fidl::encoding::Encoder<
926                '_,
927                fidl::encoding::DefaultFuchsiaResourceDialect,
928            >,
929            offset: usize,
930            depth: fidl::encoding::Depth,
931        ) -> fidl::Result<()> {
932            encoder.debug_check_bounds::<SpeedtestSocketDownRequest>(offset);
933            // Zero out padding regions. There's no need to apply masks
934            // because the unmasked parts will be overwritten by fields.
935            unsafe {
936                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
937                (ptr as *mut u64).write_unaligned(0);
938            }
939            // Write the fields.
940            self.0.encode(encoder, offset + 0, depth)?;
941            self.1.encode(encoder, offset + 8, depth)?;
942            Ok(())
943        }
944    }
945
946    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
947        for SpeedtestSocketDownRequest
948    {
949        #[inline(always)]
950        fn new_empty() -> Self {
951            Self {
952                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16388>, fidl::encoding::DefaultFuchsiaResourceDialect),
953                params: fidl::new_empty!(
954                    TransferParams,
955                    fidl::encoding::DefaultFuchsiaResourceDialect
956                ),
957            }
958        }
959
960        #[inline]
961        unsafe fn decode(
962            &mut self,
963            decoder: &mut fidl::encoding::Decoder<
964                '_,
965                fidl::encoding::DefaultFuchsiaResourceDialect,
966            >,
967            offset: usize,
968            _depth: fidl::encoding::Depth,
969        ) -> fidl::Result<()> {
970            decoder.debug_check_bounds::<Self>(offset);
971            // Verify that padding bytes are zero.
972            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
973            let padval = unsafe { (ptr as *const u64).read_unaligned() };
974            let mask = 0xffffffff00000000u64;
975            let maskedval = padval & mask;
976            if maskedval != 0 {
977                return Err(fidl::Error::NonZeroPadding {
978                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
979                });
980            }
981            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16388>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
982            fidl::decode!(
983                TransferParams,
984                fidl::encoding::DefaultFuchsiaResourceDialect,
985                &mut self.params,
986                decoder,
987                offset + 8,
988                _depth
989            )?;
990            Ok(())
991        }
992    }
993
994    impl fidl::encoding::ResourceTypeMarker for SpeedtestSocketUpRequest {
995        type Borrowed<'a> = &'a mut Self;
996        fn take_or_borrow<'a>(
997            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
998        ) -> Self::Borrowed<'a> {
999            value
1000        }
1001    }
1002
1003    unsafe impl fidl::encoding::TypeMarker for SpeedtestSocketUpRequest {
1004        type Owned = Self;
1005
1006        #[inline(always)]
1007        fn inline_align(_context: fidl::encoding::Context) -> usize {
1008            8
1009        }
1010
1011        #[inline(always)]
1012        fn inline_size(_context: fidl::encoding::Context) -> usize {
1013            24
1014        }
1015    }
1016
1017    unsafe impl
1018        fidl::encoding::Encode<
1019            SpeedtestSocketUpRequest,
1020            fidl::encoding::DefaultFuchsiaResourceDialect,
1021        > for &mut SpeedtestSocketUpRequest
1022    {
1023        #[inline]
1024        unsafe fn encode(
1025            self,
1026            encoder: &mut fidl::encoding::Encoder<
1027                '_,
1028                fidl::encoding::DefaultFuchsiaResourceDialect,
1029            >,
1030            offset: usize,
1031            _depth: fidl::encoding::Depth,
1032        ) -> fidl::Result<()> {
1033            encoder.debug_check_bounds::<SpeedtestSocketUpRequest>(offset);
1034            // Delegate to tuple encoding.
1035            fidl::encoding::Encode::<
1036                SpeedtestSocketUpRequest,
1037                fidl::encoding::DefaultFuchsiaResourceDialect,
1038            >::encode(
1039                (
1040                    <fidl::encoding::HandleType<
1041                        fidl::Socket,
1042                        { fidl::ObjectType::SOCKET.into_raw() },
1043                        16392,
1044                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1045                        &mut self.socket
1046                    ),
1047                    <TransferParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
1048                ),
1049                encoder,
1050                offset,
1051                _depth,
1052            )
1053        }
1054    }
1055    unsafe impl<
1056        T0: fidl::encoding::Encode<
1057                fidl::encoding::HandleType<
1058                    fidl::Socket,
1059                    { fidl::ObjectType::SOCKET.into_raw() },
1060                    16392,
1061                >,
1062                fidl::encoding::DefaultFuchsiaResourceDialect,
1063            >,
1064        T1: fidl::encoding::Encode<TransferParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
1065    >
1066        fidl::encoding::Encode<
1067            SpeedtestSocketUpRequest,
1068            fidl::encoding::DefaultFuchsiaResourceDialect,
1069        > for (T0, T1)
1070    {
1071        #[inline]
1072        unsafe fn encode(
1073            self,
1074            encoder: &mut fidl::encoding::Encoder<
1075                '_,
1076                fidl::encoding::DefaultFuchsiaResourceDialect,
1077            >,
1078            offset: usize,
1079            depth: fidl::encoding::Depth,
1080        ) -> fidl::Result<()> {
1081            encoder.debug_check_bounds::<SpeedtestSocketUpRequest>(offset);
1082            // Zero out padding regions. There's no need to apply masks
1083            // because the unmasked parts will be overwritten by fields.
1084            unsafe {
1085                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1086                (ptr as *mut u64).write_unaligned(0);
1087            }
1088            // Write the fields.
1089            self.0.encode(encoder, offset + 0, depth)?;
1090            self.1.encode(encoder, offset + 8, depth)?;
1091            Ok(())
1092        }
1093    }
1094
1095    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1096        for SpeedtestSocketUpRequest
1097    {
1098        #[inline(always)]
1099        fn new_empty() -> Self {
1100            Self {
1101                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect),
1102                params: fidl::new_empty!(
1103                    TransferParams,
1104                    fidl::encoding::DefaultFuchsiaResourceDialect
1105                ),
1106            }
1107        }
1108
1109        #[inline]
1110        unsafe fn decode(
1111            &mut self,
1112            decoder: &mut fidl::encoding::Decoder<
1113                '_,
1114                fidl::encoding::DefaultFuchsiaResourceDialect,
1115            >,
1116            offset: usize,
1117            _depth: fidl::encoding::Depth,
1118        ) -> fidl::Result<()> {
1119            decoder.debug_check_bounds::<Self>(offset);
1120            // Verify that padding bytes are zero.
1121            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1122            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1123            let mask = 0xffffffff00000000u64;
1124            let maskedval = padval & mask;
1125            if maskedval != 0 {
1126                return Err(fidl::Error::NonZeroPadding {
1127                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1128                });
1129            }
1130            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
1131            fidl::decode!(
1132                TransferParams,
1133                fidl::encoding::DefaultFuchsiaResourceDialect,
1134                &mut self.params,
1135                decoder,
1136                offset + 8,
1137                _depth
1138            )?;
1139            Ok(())
1140        }
1141    }
1142}
fidl_fuchsia_developer_ffx_speedtest/fidl_fuchsia_developer_ffx_speedtest.rs

fidl_fuchsia_developer_ffx_speedtest/
fidl_fuchsia_developer_ffx_speedtest.rs
