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

fidl_fuchsia_developer_ffx_speedtest/
fidl_fuchsia_developer_ffx_speedtest.rs
