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

fidl_fuchsia_net_ndp/
fidl_fuchsia_net_ndp.rs
