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

fidl_fuchsia_update_config/
fidl_fuchsia_update_config.rs
