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

fidl_fuchsia_location_namedplace/
fidl_fuchsia_location_namedplace.rs
