fidl_fuchsia_intl/
fidl_fuchsia_intl.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_intl_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct PropertyProviderMarker;
16
17impl fidl::endpoints::ProtocolMarker for PropertyProviderMarker {
18    type Proxy = PropertyProviderProxy;
19    type RequestStream = PropertyProviderRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = PropertyProviderSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.intl.PropertyProvider";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for PropertyProviderMarker {}
26
27pub trait PropertyProviderProxyInterface: Send + Sync {
28    type GetProfileResponseFut: std::future::Future<Output = Result<Profile, fidl::Error>> + Send;
29    fn r#get_profile(&self) -> Self::GetProfileResponseFut;
30}
31#[derive(Debug)]
32#[cfg(target_os = "fuchsia")]
33pub struct PropertyProviderSynchronousProxy {
34    client: fidl::client::sync::Client,
35}
36
37#[cfg(target_os = "fuchsia")]
38impl fidl::endpoints::SynchronousProxy for PropertyProviderSynchronousProxy {
39    type Proxy = PropertyProviderProxy;
40    type Protocol = PropertyProviderMarker;
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 PropertyProviderSynchronousProxy {
57    pub fn new(channel: fidl::Channel) -> Self {
58        let protocol_name = <PropertyProviderMarker 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<PropertyProviderEvent, fidl::Error> {
72        PropertyProviderEvent::decode(self.client.wait_for_event(deadline)?)
73    }
74
75    /// Gets the user's internationalization profile.
76    pub fn r#get_profile(&self, ___deadline: zx::MonotonicInstant) -> Result<Profile, fidl::Error> {
77        let _response = self
78            .client
79            .send_query::<fidl::encoding::EmptyPayload, PropertyProviderGetProfileResponse>(
80                (),
81                0x10bf06e68d36d3eb,
82                fidl::encoding::DynamicFlags::empty(),
83                ___deadline,
84            )?;
85        Ok(_response.profile)
86    }
87}
88
89#[cfg(target_os = "fuchsia")]
90impl From<PropertyProviderSynchronousProxy> for zx::Handle {
91    fn from(value: PropertyProviderSynchronousProxy) -> Self {
92        value.into_channel().into()
93    }
94}
95
96#[cfg(target_os = "fuchsia")]
97impl From<fidl::Channel> for PropertyProviderSynchronousProxy {
98    fn from(value: fidl::Channel) -> Self {
99        Self::new(value)
100    }
101}
102
103#[derive(Debug, Clone)]
104pub struct PropertyProviderProxy {
105    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
106}
107
108impl fidl::endpoints::Proxy for PropertyProviderProxy {
109    type Protocol = PropertyProviderMarker;
110
111    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
112        Self::new(inner)
113    }
114
115    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
116        self.client.into_channel().map_err(|client| Self { client })
117    }
118
119    fn as_channel(&self) -> &::fidl::AsyncChannel {
120        self.client.as_channel()
121    }
122}
123
124impl PropertyProviderProxy {
125    /// Create a new Proxy for fuchsia.intl/PropertyProvider.
126    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
127        let protocol_name = <PropertyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
128        Self { client: fidl::client::Client::new(channel, protocol_name) }
129    }
130
131    /// Get a Stream of events from the remote end of the protocol.
132    ///
133    /// # Panics
134    ///
135    /// Panics if the event stream was already taken.
136    pub fn take_event_stream(&self) -> PropertyProviderEventStream {
137        PropertyProviderEventStream { event_receiver: self.client.take_event_receiver() }
138    }
139
140    /// Gets the user's internationalization profile.
141    pub fn r#get_profile(
142        &self,
143    ) -> fidl::client::QueryResponseFut<Profile, fidl::encoding::DefaultFuchsiaResourceDialect>
144    {
145        PropertyProviderProxyInterface::r#get_profile(self)
146    }
147}
148
149impl PropertyProviderProxyInterface for PropertyProviderProxy {
150    type GetProfileResponseFut =
151        fidl::client::QueryResponseFut<Profile, fidl::encoding::DefaultFuchsiaResourceDialect>;
152    fn r#get_profile(&self) -> Self::GetProfileResponseFut {
153        fn _decode(
154            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
155        ) -> Result<Profile, fidl::Error> {
156            let _response = fidl::client::decode_transaction_body::<
157                PropertyProviderGetProfileResponse,
158                fidl::encoding::DefaultFuchsiaResourceDialect,
159                0x10bf06e68d36d3eb,
160            >(_buf?)?;
161            Ok(_response.profile)
162        }
163        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Profile>(
164            (),
165            0x10bf06e68d36d3eb,
166            fidl::encoding::DynamicFlags::empty(),
167            _decode,
168        )
169    }
170}
171
172pub struct PropertyProviderEventStream {
173    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
174}
175
176impl std::marker::Unpin for PropertyProviderEventStream {}
177
178impl futures::stream::FusedStream for PropertyProviderEventStream {
179    fn is_terminated(&self) -> bool {
180        self.event_receiver.is_terminated()
181    }
182}
183
184impl futures::Stream for PropertyProviderEventStream {
185    type Item = Result<PropertyProviderEvent, fidl::Error>;
186
187    fn poll_next(
188        mut self: std::pin::Pin<&mut Self>,
189        cx: &mut std::task::Context<'_>,
190    ) -> std::task::Poll<Option<Self::Item>> {
191        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
192            &mut self.event_receiver,
193            cx
194        )?) {
195            Some(buf) => std::task::Poll::Ready(Some(PropertyProviderEvent::decode(buf))),
196            None => std::task::Poll::Ready(None),
197        }
198    }
199}
200
201#[derive(Debug)]
202pub enum PropertyProviderEvent {
203    OnChange {},
204}
205
206impl PropertyProviderEvent {
207    #[allow(irrefutable_let_patterns)]
208    pub fn into_on_change(self) -> Option<()> {
209        if let PropertyProviderEvent::OnChange {} = self {
210            Some(())
211        } else {
212            None
213        }
214    }
215
216    /// Decodes a message buffer as a [`PropertyProviderEvent`].
217    fn decode(
218        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
219    ) -> Result<PropertyProviderEvent, fidl::Error> {
220        let (bytes, _handles) = buf.split_mut();
221        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
222        debug_assert_eq!(tx_header.tx_id, 0);
223        match tx_header.ordinal {
224            0x26b9ed6e23c46991 => {
225                let mut out = fidl::new_empty!(
226                    fidl::encoding::EmptyPayload,
227                    fidl::encoding::DefaultFuchsiaResourceDialect
228                );
229                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
230                Ok((PropertyProviderEvent::OnChange {}))
231            }
232            _ => Err(fidl::Error::UnknownOrdinal {
233                ordinal: tx_header.ordinal,
234                protocol_name:
235                    <PropertyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
236            }),
237        }
238    }
239}
240
241/// A Stream of incoming requests for fuchsia.intl/PropertyProvider.
242pub struct PropertyProviderRequestStream {
243    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
244    is_terminated: bool,
245}
246
247impl std::marker::Unpin for PropertyProviderRequestStream {}
248
249impl futures::stream::FusedStream for PropertyProviderRequestStream {
250    fn is_terminated(&self) -> bool {
251        self.is_terminated
252    }
253}
254
255impl fidl::endpoints::RequestStream for PropertyProviderRequestStream {
256    type Protocol = PropertyProviderMarker;
257    type ControlHandle = PropertyProviderControlHandle;
258
259    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
260        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
261    }
262
263    fn control_handle(&self) -> Self::ControlHandle {
264        PropertyProviderControlHandle { inner: self.inner.clone() }
265    }
266
267    fn into_inner(
268        self,
269    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
270    {
271        (self.inner, self.is_terminated)
272    }
273
274    fn from_inner(
275        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
276        is_terminated: bool,
277    ) -> Self {
278        Self { inner, is_terminated }
279    }
280}
281
282impl futures::Stream for PropertyProviderRequestStream {
283    type Item = Result<PropertyProviderRequest, fidl::Error>;
284
285    fn poll_next(
286        mut self: std::pin::Pin<&mut Self>,
287        cx: &mut std::task::Context<'_>,
288    ) -> std::task::Poll<Option<Self::Item>> {
289        let this = &mut *self;
290        if this.inner.check_shutdown(cx) {
291            this.is_terminated = true;
292            return std::task::Poll::Ready(None);
293        }
294        if this.is_terminated {
295            panic!("polled PropertyProviderRequestStream after completion");
296        }
297        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
298            |bytes, handles| {
299                match this.inner.channel().read_etc(cx, bytes, handles) {
300                    std::task::Poll::Ready(Ok(())) => {}
301                    std::task::Poll::Pending => return std::task::Poll::Pending,
302                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
303                        this.is_terminated = true;
304                        return std::task::Poll::Ready(None);
305                    }
306                    std::task::Poll::Ready(Err(e)) => {
307                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
308                            e.into(),
309                        ))))
310                    }
311                }
312
313                // A message has been received from the channel
314                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
315
316                std::task::Poll::Ready(Some(match header.ordinal {
317                    0x10bf06e68d36d3eb => {
318                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
319                        let mut req = fidl::new_empty!(
320                            fidl::encoding::EmptyPayload,
321                            fidl::encoding::DefaultFuchsiaResourceDialect
322                        );
323                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
324                        let control_handle =
325                            PropertyProviderControlHandle { inner: this.inner.clone() };
326                        Ok(PropertyProviderRequest::GetProfile {
327                            responder: PropertyProviderGetProfileResponder {
328                                control_handle: std::mem::ManuallyDrop::new(control_handle),
329                                tx_id: header.tx_id,
330                            },
331                        })
332                    }
333                    _ => Err(fidl::Error::UnknownOrdinal {
334                        ordinal: header.ordinal,
335                        protocol_name:
336                            <PropertyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
337                    }),
338                }))
339            },
340        )
341    }
342}
343
344/// Provides internationalization properties.
345///
346/// Components that need to change their behavior in response to the user's internationalization
347/// profile may request an instance of this service from their namespace, if available. A component
348/// may choose to pass along the service that it received from its parent to its own children, or to
349/// override it and apply additional customizations.
350///
351/// See also `fuchsia.ui.views.View`.
352#[derive(Debug)]
353pub enum PropertyProviderRequest {
354    /// Gets the user's internationalization profile.
355    GetProfile { responder: PropertyProviderGetProfileResponder },
356}
357
358impl PropertyProviderRequest {
359    #[allow(irrefutable_let_patterns)]
360    pub fn into_get_profile(self) -> Option<(PropertyProviderGetProfileResponder)> {
361        if let PropertyProviderRequest::GetProfile { responder } = self {
362            Some((responder))
363        } else {
364            None
365        }
366    }
367
368    /// Name of the method defined in FIDL
369    pub fn method_name(&self) -> &'static str {
370        match *self {
371            PropertyProviderRequest::GetProfile { .. } => "get_profile",
372        }
373    }
374}
375
376#[derive(Debug, Clone)]
377pub struct PropertyProviderControlHandle {
378    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
379}
380
381impl fidl::endpoints::ControlHandle for PropertyProviderControlHandle {
382    fn shutdown(&self) {
383        self.inner.shutdown()
384    }
385    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
386        self.inner.shutdown_with_epitaph(status)
387    }
388
389    fn is_closed(&self) -> bool {
390        self.inner.channel().is_closed()
391    }
392    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
393        self.inner.channel().on_closed()
394    }
395
396    #[cfg(target_os = "fuchsia")]
397    fn signal_peer(
398        &self,
399        clear_mask: zx::Signals,
400        set_mask: zx::Signals,
401    ) -> Result<(), zx_status::Status> {
402        use fidl::Peered;
403        self.inner.channel().signal_peer(clear_mask, set_mask)
404    }
405}
406
407impl PropertyProviderControlHandle {
408    pub fn send_on_change(&self) -> Result<(), fidl::Error> {
409        self.inner.send::<fidl::encoding::EmptyPayload>(
410            (),
411            0,
412            0x26b9ed6e23c46991,
413            fidl::encoding::DynamicFlags::empty(),
414        )
415    }
416}
417
418#[must_use = "FIDL methods require a response to be sent"]
419#[derive(Debug)]
420pub struct PropertyProviderGetProfileResponder {
421    control_handle: std::mem::ManuallyDrop<PropertyProviderControlHandle>,
422    tx_id: u32,
423}
424
425/// Set the the channel to be shutdown (see [`PropertyProviderControlHandle::shutdown`])
426/// if the responder is dropped without sending a response, so that the client
427/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
428impl std::ops::Drop for PropertyProviderGetProfileResponder {
429    fn drop(&mut self) {
430        self.control_handle.shutdown();
431        // Safety: drops once, never accessed again
432        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
433    }
434}
435
436impl fidl::endpoints::Responder for PropertyProviderGetProfileResponder {
437    type ControlHandle = PropertyProviderControlHandle;
438
439    fn control_handle(&self) -> &PropertyProviderControlHandle {
440        &self.control_handle
441    }
442
443    fn drop_without_shutdown(mut self) {
444        // Safety: drops once, never accessed again due to mem::forget
445        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
446        // Prevent Drop from running (which would shut down the channel)
447        std::mem::forget(self);
448    }
449}
450
451impl PropertyProviderGetProfileResponder {
452    /// Sends a response to the FIDL transaction.
453    ///
454    /// Sets the channel to shutdown if an error occurs.
455    pub fn send(self, mut profile: &Profile) -> Result<(), fidl::Error> {
456        let _result = self.send_raw(profile);
457        if _result.is_err() {
458            self.control_handle.shutdown();
459        }
460        self.drop_without_shutdown();
461        _result
462    }
463
464    /// Similar to "send" but does not shutdown the channel if an error occurs.
465    pub fn send_no_shutdown_on_err(self, mut profile: &Profile) -> Result<(), fidl::Error> {
466        let _result = self.send_raw(profile);
467        self.drop_without_shutdown();
468        _result
469    }
470
471    fn send_raw(&self, mut profile: &Profile) -> Result<(), fidl::Error> {
472        self.control_handle.inner.send::<PropertyProviderGetProfileResponse>(
473            (profile,),
474            self.tx_id,
475            0x10bf06e68d36d3eb,
476            fidl::encoding::DynamicFlags::empty(),
477        )
478    }
479}
480
481#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
482pub struct TimeZonesMarker;
483
484impl fidl::endpoints::ProtocolMarker for TimeZonesMarker {
485    type Proxy = TimeZonesProxy;
486    type RequestStream = TimeZonesRequestStream;
487    #[cfg(target_os = "fuchsia")]
488    type SynchronousProxy = TimeZonesSynchronousProxy;
489
490    const DEBUG_NAME: &'static str = "fuchsia.intl.TimeZones";
491}
492impl fidl::endpoints::DiscoverableProtocolMarker for TimeZonesMarker {}
493pub type TimeZonesAbsoluteToCivilTimeResult = Result<CivilTime, TimeZonesError>;
494pub type TimeZonesCivilToAbsoluteTimeResult = Result<i64, TimeZonesError>;
495pub type TimeZonesGetTimeZoneInfoResult = Result<TimeZoneInfo, TimeZonesError>;
496
497pub trait TimeZonesProxyInterface: Send + Sync {
498    type AbsoluteToCivilTimeResponseFut: std::future::Future<Output = Result<TimeZonesAbsoluteToCivilTimeResult, fidl::Error>>
499        + Send;
500    fn r#absolute_to_civil_time(
501        &self,
502        time_zone_id: &TimeZoneId,
503        absolute_time: i64,
504    ) -> Self::AbsoluteToCivilTimeResponseFut;
505    type CivilToAbsoluteTimeResponseFut: std::future::Future<Output = Result<TimeZonesCivilToAbsoluteTimeResult, fidl::Error>>
506        + Send;
507    fn r#civil_to_absolute_time(
508        &self,
509        civil_time: &CivilTime,
510        options: &CivilToAbsoluteTimeOptions,
511    ) -> Self::CivilToAbsoluteTimeResponseFut;
512    type GetTimeZoneInfoResponseFut: std::future::Future<Output = Result<TimeZonesGetTimeZoneInfoResult, fidl::Error>>
513        + Send;
514    fn r#get_time_zone_info(
515        &self,
516        time_zone_id: &TimeZoneId,
517        at_time: i64,
518    ) -> Self::GetTimeZoneInfoResponseFut;
519}
520#[derive(Debug)]
521#[cfg(target_os = "fuchsia")]
522pub struct TimeZonesSynchronousProxy {
523    client: fidl::client::sync::Client,
524}
525
526#[cfg(target_os = "fuchsia")]
527impl fidl::endpoints::SynchronousProxy for TimeZonesSynchronousProxy {
528    type Proxy = TimeZonesProxy;
529    type Protocol = TimeZonesMarker;
530
531    fn from_channel(inner: fidl::Channel) -> Self {
532        Self::new(inner)
533    }
534
535    fn into_channel(self) -> fidl::Channel {
536        self.client.into_channel()
537    }
538
539    fn as_channel(&self) -> &fidl::Channel {
540        self.client.as_channel()
541    }
542}
543
544#[cfg(target_os = "fuchsia")]
545impl TimeZonesSynchronousProxy {
546    pub fn new(channel: fidl::Channel) -> Self {
547        let protocol_name = <TimeZonesMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
548        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
549    }
550
551    pub fn into_channel(self) -> fidl::Channel {
552        self.client.into_channel()
553    }
554
555    /// Waits until an event arrives and returns it. It is safe for other
556    /// threads to make concurrent requests while waiting for an event.
557    pub fn wait_for_event(
558        &self,
559        deadline: zx::MonotonicInstant,
560    ) -> Result<TimeZonesEvent, fidl::Error> {
561        TimeZonesEvent::decode(self.client.wait_for_event(deadline)?)
562    }
563
564    /// Converts the given absolute time to a civil date and time in the given time zone, using the
565    /// Gregorian calendar.
566    pub fn r#absolute_to_civil_time(
567        &self,
568        mut time_zone_id: &TimeZoneId,
569        mut absolute_time: i64,
570        ___deadline: zx::MonotonicInstant,
571    ) -> Result<TimeZonesAbsoluteToCivilTimeResult, fidl::Error> {
572        let _response = self.client.send_query::<
573            TimeZonesAbsoluteToCivilTimeRequest,
574            fidl::encoding::ResultType<TimeZonesAbsoluteToCivilTimeResponse, TimeZonesError>,
575        >(
576            (time_zone_id, absolute_time,),
577            0x25377a4d9196e205,
578            fidl::encoding::DynamicFlags::empty(),
579            ___deadline,
580        )?;
581        Ok(_response.map(|x| x.civil_time))
582    }
583
584    /// Converts the given civil date and time in the given time zone to nanoseconds since the Unix
585    /// epoch.
586    pub fn r#civil_to_absolute_time(
587        &self,
588        mut civil_time: &CivilTime,
589        mut options: &CivilToAbsoluteTimeOptions,
590        ___deadline: zx::MonotonicInstant,
591    ) -> Result<TimeZonesCivilToAbsoluteTimeResult, fidl::Error> {
592        let _response = self.client.send_query::<
593            TimeZonesCivilToAbsoluteTimeRequest,
594            fidl::encoding::ResultType<TimeZonesCivilToAbsoluteTimeResponse, TimeZonesError>,
595        >(
596            (civil_time, options,),
597            0xc1277c7a1413aa6,
598            fidl::encoding::DynamicFlags::empty(),
599            ___deadline,
600        )?;
601        Ok(_response.map(|x| x.absolute_time))
602    }
603
604    /// Retrieves details about a time zone at a specified one.
605    pub fn r#get_time_zone_info(
606        &self,
607        mut time_zone_id: &TimeZoneId,
608        mut at_time: i64,
609        ___deadline: zx::MonotonicInstant,
610    ) -> Result<TimeZonesGetTimeZoneInfoResult, fidl::Error> {
611        let _response =
612            self.client.send_query::<TimeZonesGetTimeZoneInfoRequest, fidl::encoding::ResultType<
613                TimeZonesGetTimeZoneInfoResponse,
614                TimeZonesError,
615            >>(
616                (time_zone_id, at_time),
617                0x2144cbac1d76fe65,
618                fidl::encoding::DynamicFlags::empty(),
619                ___deadline,
620            )?;
621        Ok(_response.map(|x| x.time_zone_info))
622    }
623}
624
625#[cfg(target_os = "fuchsia")]
626impl From<TimeZonesSynchronousProxy> for zx::Handle {
627    fn from(value: TimeZonesSynchronousProxy) -> Self {
628        value.into_channel().into()
629    }
630}
631
632#[cfg(target_os = "fuchsia")]
633impl From<fidl::Channel> for TimeZonesSynchronousProxy {
634    fn from(value: fidl::Channel) -> Self {
635        Self::new(value)
636    }
637}
638
639#[derive(Debug, Clone)]
640pub struct TimeZonesProxy {
641    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
642}
643
644impl fidl::endpoints::Proxy for TimeZonesProxy {
645    type Protocol = TimeZonesMarker;
646
647    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
648        Self::new(inner)
649    }
650
651    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
652        self.client.into_channel().map_err(|client| Self { client })
653    }
654
655    fn as_channel(&self) -> &::fidl::AsyncChannel {
656        self.client.as_channel()
657    }
658}
659
660impl TimeZonesProxy {
661    /// Create a new Proxy for fuchsia.intl/TimeZones.
662    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
663        let protocol_name = <TimeZonesMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
664        Self { client: fidl::client::Client::new(channel, protocol_name) }
665    }
666
667    /// Get a Stream of events from the remote end of the protocol.
668    ///
669    /// # Panics
670    ///
671    /// Panics if the event stream was already taken.
672    pub fn take_event_stream(&self) -> TimeZonesEventStream {
673        TimeZonesEventStream { event_receiver: self.client.take_event_receiver() }
674    }
675
676    /// Converts the given absolute time to a civil date and time in the given time zone, using the
677    /// Gregorian calendar.
678    pub fn r#absolute_to_civil_time(
679        &self,
680        mut time_zone_id: &TimeZoneId,
681        mut absolute_time: i64,
682    ) -> fidl::client::QueryResponseFut<
683        TimeZonesAbsoluteToCivilTimeResult,
684        fidl::encoding::DefaultFuchsiaResourceDialect,
685    > {
686        TimeZonesProxyInterface::r#absolute_to_civil_time(self, time_zone_id, absolute_time)
687    }
688
689    /// Converts the given civil date and time in the given time zone to nanoseconds since the Unix
690    /// epoch.
691    pub fn r#civil_to_absolute_time(
692        &self,
693        mut civil_time: &CivilTime,
694        mut options: &CivilToAbsoluteTimeOptions,
695    ) -> fidl::client::QueryResponseFut<
696        TimeZonesCivilToAbsoluteTimeResult,
697        fidl::encoding::DefaultFuchsiaResourceDialect,
698    > {
699        TimeZonesProxyInterface::r#civil_to_absolute_time(self, civil_time, options)
700    }
701
702    /// Retrieves details about a time zone at a specified one.
703    pub fn r#get_time_zone_info(
704        &self,
705        mut time_zone_id: &TimeZoneId,
706        mut at_time: i64,
707    ) -> fidl::client::QueryResponseFut<
708        TimeZonesGetTimeZoneInfoResult,
709        fidl::encoding::DefaultFuchsiaResourceDialect,
710    > {
711        TimeZonesProxyInterface::r#get_time_zone_info(self, time_zone_id, at_time)
712    }
713}
714
715impl TimeZonesProxyInterface for TimeZonesProxy {
716    type AbsoluteToCivilTimeResponseFut = fidl::client::QueryResponseFut<
717        TimeZonesAbsoluteToCivilTimeResult,
718        fidl::encoding::DefaultFuchsiaResourceDialect,
719    >;
720    fn r#absolute_to_civil_time(
721        &self,
722        mut time_zone_id: &TimeZoneId,
723        mut absolute_time: i64,
724    ) -> Self::AbsoluteToCivilTimeResponseFut {
725        fn _decode(
726            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
727        ) -> Result<TimeZonesAbsoluteToCivilTimeResult, fidl::Error> {
728            let _response = fidl::client::decode_transaction_body::<
729                fidl::encoding::ResultType<TimeZonesAbsoluteToCivilTimeResponse, TimeZonesError>,
730                fidl::encoding::DefaultFuchsiaResourceDialect,
731                0x25377a4d9196e205,
732            >(_buf?)?;
733            Ok(_response.map(|x| x.civil_time))
734        }
735        self.client.send_query_and_decode::<
736            TimeZonesAbsoluteToCivilTimeRequest,
737            TimeZonesAbsoluteToCivilTimeResult,
738        >(
739            (time_zone_id, absolute_time,),
740            0x25377a4d9196e205,
741            fidl::encoding::DynamicFlags::empty(),
742            _decode,
743        )
744    }
745
746    type CivilToAbsoluteTimeResponseFut = fidl::client::QueryResponseFut<
747        TimeZonesCivilToAbsoluteTimeResult,
748        fidl::encoding::DefaultFuchsiaResourceDialect,
749    >;
750    fn r#civil_to_absolute_time(
751        &self,
752        mut civil_time: &CivilTime,
753        mut options: &CivilToAbsoluteTimeOptions,
754    ) -> Self::CivilToAbsoluteTimeResponseFut {
755        fn _decode(
756            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
757        ) -> Result<TimeZonesCivilToAbsoluteTimeResult, fidl::Error> {
758            let _response = fidl::client::decode_transaction_body::<
759                fidl::encoding::ResultType<TimeZonesCivilToAbsoluteTimeResponse, TimeZonesError>,
760                fidl::encoding::DefaultFuchsiaResourceDialect,
761                0xc1277c7a1413aa6,
762            >(_buf?)?;
763            Ok(_response.map(|x| x.absolute_time))
764        }
765        self.client.send_query_and_decode::<
766            TimeZonesCivilToAbsoluteTimeRequest,
767            TimeZonesCivilToAbsoluteTimeResult,
768        >(
769            (civil_time, options,),
770            0xc1277c7a1413aa6,
771            fidl::encoding::DynamicFlags::empty(),
772            _decode,
773        )
774    }
775
776    type GetTimeZoneInfoResponseFut = fidl::client::QueryResponseFut<
777        TimeZonesGetTimeZoneInfoResult,
778        fidl::encoding::DefaultFuchsiaResourceDialect,
779    >;
780    fn r#get_time_zone_info(
781        &self,
782        mut time_zone_id: &TimeZoneId,
783        mut at_time: i64,
784    ) -> Self::GetTimeZoneInfoResponseFut {
785        fn _decode(
786            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
787        ) -> Result<TimeZonesGetTimeZoneInfoResult, fidl::Error> {
788            let _response = fidl::client::decode_transaction_body::<
789                fidl::encoding::ResultType<TimeZonesGetTimeZoneInfoResponse, TimeZonesError>,
790                fidl::encoding::DefaultFuchsiaResourceDialect,
791                0x2144cbac1d76fe65,
792            >(_buf?)?;
793            Ok(_response.map(|x| x.time_zone_info))
794        }
795        self.client.send_query_and_decode::<
796            TimeZonesGetTimeZoneInfoRequest,
797            TimeZonesGetTimeZoneInfoResult,
798        >(
799            (time_zone_id, at_time,),
800            0x2144cbac1d76fe65,
801            fidl::encoding::DynamicFlags::empty(),
802            _decode,
803        )
804    }
805}
806
807pub struct TimeZonesEventStream {
808    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
809}
810
811impl std::marker::Unpin for TimeZonesEventStream {}
812
813impl futures::stream::FusedStream for TimeZonesEventStream {
814    fn is_terminated(&self) -> bool {
815        self.event_receiver.is_terminated()
816    }
817}
818
819impl futures::Stream for TimeZonesEventStream {
820    type Item = Result<TimeZonesEvent, fidl::Error>;
821
822    fn poll_next(
823        mut self: std::pin::Pin<&mut Self>,
824        cx: &mut std::task::Context<'_>,
825    ) -> std::task::Poll<Option<Self::Item>> {
826        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
827            &mut self.event_receiver,
828            cx
829        )?) {
830            Some(buf) => std::task::Poll::Ready(Some(TimeZonesEvent::decode(buf))),
831            None => std::task::Poll::Ready(None),
832        }
833    }
834}
835
836#[derive(Debug)]
837pub enum TimeZonesEvent {}
838
839impl TimeZonesEvent {
840    /// Decodes a message buffer as a [`TimeZonesEvent`].
841    fn decode(
842        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
843    ) -> Result<TimeZonesEvent, fidl::Error> {
844        let (bytes, _handles) = buf.split_mut();
845        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
846        debug_assert_eq!(tx_header.tx_id, 0);
847        match tx_header.ordinal {
848            _ => Err(fidl::Error::UnknownOrdinal {
849                ordinal: tx_header.ordinal,
850                protocol_name: <TimeZonesMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
851            }),
852        }
853    }
854}
855
856/// A Stream of incoming requests for fuchsia.intl/TimeZones.
857pub struct TimeZonesRequestStream {
858    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
859    is_terminated: bool,
860}
861
862impl std::marker::Unpin for TimeZonesRequestStream {}
863
864impl futures::stream::FusedStream for TimeZonesRequestStream {
865    fn is_terminated(&self) -> bool {
866        self.is_terminated
867    }
868}
869
870impl fidl::endpoints::RequestStream for TimeZonesRequestStream {
871    type Protocol = TimeZonesMarker;
872    type ControlHandle = TimeZonesControlHandle;
873
874    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
875        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
876    }
877
878    fn control_handle(&self) -> Self::ControlHandle {
879        TimeZonesControlHandle { inner: self.inner.clone() }
880    }
881
882    fn into_inner(
883        self,
884    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
885    {
886        (self.inner, self.is_terminated)
887    }
888
889    fn from_inner(
890        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
891        is_terminated: bool,
892    ) -> Self {
893        Self { inner, is_terminated }
894    }
895}
896
897impl futures::Stream for TimeZonesRequestStream {
898    type Item = Result<TimeZonesRequest, fidl::Error>;
899
900    fn poll_next(
901        mut self: std::pin::Pin<&mut Self>,
902        cx: &mut std::task::Context<'_>,
903    ) -> std::task::Poll<Option<Self::Item>> {
904        let this = &mut *self;
905        if this.inner.check_shutdown(cx) {
906            this.is_terminated = true;
907            return std::task::Poll::Ready(None);
908        }
909        if this.is_terminated {
910            panic!("polled TimeZonesRequestStream after completion");
911        }
912        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
913            |bytes, handles| {
914                match this.inner.channel().read_etc(cx, bytes, handles) {
915                    std::task::Poll::Ready(Ok(())) => {}
916                    std::task::Poll::Pending => return std::task::Poll::Pending,
917                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
918                        this.is_terminated = true;
919                        return std::task::Poll::Ready(None);
920                    }
921                    std::task::Poll::Ready(Err(e)) => {
922                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
923                            e.into(),
924                        ))))
925                    }
926                }
927
928                // A message has been received from the channel
929                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
930
931                std::task::Poll::Ready(Some(match header.ordinal {
932                    0x25377a4d9196e205 => {
933                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
934                        let mut req = fidl::new_empty!(
935                            TimeZonesAbsoluteToCivilTimeRequest,
936                            fidl::encoding::DefaultFuchsiaResourceDialect
937                        );
938                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TimeZonesAbsoluteToCivilTimeRequest>(&header, _body_bytes, handles, &mut req)?;
939                        let control_handle = TimeZonesControlHandle { inner: this.inner.clone() };
940                        Ok(TimeZonesRequest::AbsoluteToCivilTime {
941                            time_zone_id: req.time_zone_id,
942                            absolute_time: req.absolute_time,
943
944                            responder: TimeZonesAbsoluteToCivilTimeResponder {
945                                control_handle: std::mem::ManuallyDrop::new(control_handle),
946                                tx_id: header.tx_id,
947                            },
948                        })
949                    }
950                    0xc1277c7a1413aa6 => {
951                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
952                        let mut req = fidl::new_empty!(
953                            TimeZonesCivilToAbsoluteTimeRequest,
954                            fidl::encoding::DefaultFuchsiaResourceDialect
955                        );
956                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TimeZonesCivilToAbsoluteTimeRequest>(&header, _body_bytes, handles, &mut req)?;
957                        let control_handle = TimeZonesControlHandle { inner: this.inner.clone() };
958                        Ok(TimeZonesRequest::CivilToAbsoluteTime {
959                            civil_time: req.civil_time,
960                            options: req.options,
961
962                            responder: TimeZonesCivilToAbsoluteTimeResponder {
963                                control_handle: std::mem::ManuallyDrop::new(control_handle),
964                                tx_id: header.tx_id,
965                            },
966                        })
967                    }
968                    0x2144cbac1d76fe65 => {
969                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
970                        let mut req = fidl::new_empty!(
971                            TimeZonesGetTimeZoneInfoRequest,
972                            fidl::encoding::DefaultFuchsiaResourceDialect
973                        );
974                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TimeZonesGetTimeZoneInfoRequest>(&header, _body_bytes, handles, &mut req)?;
975                        let control_handle = TimeZonesControlHandle { inner: this.inner.clone() };
976                        Ok(TimeZonesRequest::GetTimeZoneInfo {
977                            time_zone_id: req.time_zone_id,
978                            at_time: req.at_time,
979
980                            responder: TimeZonesGetTimeZoneInfoResponder {
981                                control_handle: std::mem::ManuallyDrop::new(control_handle),
982                                tx_id: header.tx_id,
983                            },
984                        })
985                    }
986                    _ => Err(fidl::Error::UnknownOrdinal {
987                        ordinal: header.ordinal,
988                        protocol_name:
989                            <TimeZonesMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
990                    }),
991                }))
992            },
993        )
994    }
995}
996
997/// Provides information about time zones and offers date-time conversion methods.
998///
999/// TODO(https://fxbug.dev/42162409): Add time zone info methods, including offsets from UTC.
1000#[derive(Debug)]
1001pub enum TimeZonesRequest {
1002    /// Converts the given absolute time to a civil date and time in the given time zone, using the
1003    /// Gregorian calendar.
1004    AbsoluteToCivilTime {
1005        time_zone_id: TimeZoneId,
1006        absolute_time: i64,
1007        responder: TimeZonesAbsoluteToCivilTimeResponder,
1008    },
1009    /// Converts the given civil date and time in the given time zone to nanoseconds since the Unix
1010    /// epoch.
1011    CivilToAbsoluteTime {
1012        civil_time: CivilTime,
1013        options: CivilToAbsoluteTimeOptions,
1014        responder: TimeZonesCivilToAbsoluteTimeResponder,
1015    },
1016    /// Retrieves details about a time zone at a specified one.
1017    GetTimeZoneInfo {
1018        time_zone_id: TimeZoneId,
1019        at_time: i64,
1020        responder: TimeZonesGetTimeZoneInfoResponder,
1021    },
1022}
1023
1024impl TimeZonesRequest {
1025    #[allow(irrefutable_let_patterns)]
1026    pub fn into_absolute_to_civil_time(
1027        self,
1028    ) -> Option<(TimeZoneId, i64, TimeZonesAbsoluteToCivilTimeResponder)> {
1029        if let TimeZonesRequest::AbsoluteToCivilTime { time_zone_id, absolute_time, responder } =
1030            self
1031        {
1032            Some((time_zone_id, absolute_time, responder))
1033        } else {
1034            None
1035        }
1036    }
1037
1038    #[allow(irrefutable_let_patterns)]
1039    pub fn into_civil_to_absolute_time(
1040        self,
1041    ) -> Option<(CivilTime, CivilToAbsoluteTimeOptions, TimeZonesCivilToAbsoluteTimeResponder)>
1042    {
1043        if let TimeZonesRequest::CivilToAbsoluteTime { civil_time, options, responder } = self {
1044            Some((civil_time, options, responder))
1045        } else {
1046            None
1047        }
1048    }
1049
1050    #[allow(irrefutable_let_patterns)]
1051    pub fn into_get_time_zone_info(
1052        self,
1053    ) -> Option<(TimeZoneId, i64, TimeZonesGetTimeZoneInfoResponder)> {
1054        if let TimeZonesRequest::GetTimeZoneInfo { time_zone_id, at_time, responder } = self {
1055            Some((time_zone_id, at_time, responder))
1056        } else {
1057            None
1058        }
1059    }
1060
1061    /// Name of the method defined in FIDL
1062    pub fn method_name(&self) -> &'static str {
1063        match *self {
1064            TimeZonesRequest::AbsoluteToCivilTime { .. } => "absolute_to_civil_time",
1065            TimeZonesRequest::CivilToAbsoluteTime { .. } => "civil_to_absolute_time",
1066            TimeZonesRequest::GetTimeZoneInfo { .. } => "get_time_zone_info",
1067        }
1068    }
1069}
1070
1071#[derive(Debug, Clone)]
1072pub struct TimeZonesControlHandle {
1073    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1074}
1075
1076impl fidl::endpoints::ControlHandle for TimeZonesControlHandle {
1077    fn shutdown(&self) {
1078        self.inner.shutdown()
1079    }
1080    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1081        self.inner.shutdown_with_epitaph(status)
1082    }
1083
1084    fn is_closed(&self) -> bool {
1085        self.inner.channel().is_closed()
1086    }
1087    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1088        self.inner.channel().on_closed()
1089    }
1090
1091    #[cfg(target_os = "fuchsia")]
1092    fn signal_peer(
1093        &self,
1094        clear_mask: zx::Signals,
1095        set_mask: zx::Signals,
1096    ) -> Result<(), zx_status::Status> {
1097        use fidl::Peered;
1098        self.inner.channel().signal_peer(clear_mask, set_mask)
1099    }
1100}
1101
1102impl TimeZonesControlHandle {}
1103
1104#[must_use = "FIDL methods require a response to be sent"]
1105#[derive(Debug)]
1106pub struct TimeZonesAbsoluteToCivilTimeResponder {
1107    control_handle: std::mem::ManuallyDrop<TimeZonesControlHandle>,
1108    tx_id: u32,
1109}
1110
1111/// Set the the channel to be shutdown (see [`TimeZonesControlHandle::shutdown`])
1112/// if the responder is dropped without sending a response, so that the client
1113/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1114impl std::ops::Drop for TimeZonesAbsoluteToCivilTimeResponder {
1115    fn drop(&mut self) {
1116        self.control_handle.shutdown();
1117        // Safety: drops once, never accessed again
1118        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1119    }
1120}
1121
1122impl fidl::endpoints::Responder for TimeZonesAbsoluteToCivilTimeResponder {
1123    type ControlHandle = TimeZonesControlHandle;
1124
1125    fn control_handle(&self) -> &TimeZonesControlHandle {
1126        &self.control_handle
1127    }
1128
1129    fn drop_without_shutdown(mut self) {
1130        // Safety: drops once, never accessed again due to mem::forget
1131        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1132        // Prevent Drop from running (which would shut down the channel)
1133        std::mem::forget(self);
1134    }
1135}
1136
1137impl TimeZonesAbsoluteToCivilTimeResponder {
1138    /// Sends a response to the FIDL transaction.
1139    ///
1140    /// Sets the channel to shutdown if an error occurs.
1141    pub fn send(self, mut result: Result<&CivilTime, TimeZonesError>) -> Result<(), fidl::Error> {
1142        let _result = self.send_raw(result);
1143        if _result.is_err() {
1144            self.control_handle.shutdown();
1145        }
1146        self.drop_without_shutdown();
1147        _result
1148    }
1149
1150    /// Similar to "send" but does not shutdown the channel if an error occurs.
1151    pub fn send_no_shutdown_on_err(
1152        self,
1153        mut result: Result<&CivilTime, TimeZonesError>,
1154    ) -> Result<(), fidl::Error> {
1155        let _result = self.send_raw(result);
1156        self.drop_without_shutdown();
1157        _result
1158    }
1159
1160    fn send_raw(&self, mut result: Result<&CivilTime, TimeZonesError>) -> Result<(), fidl::Error> {
1161        self.control_handle.inner.send::<fidl::encoding::ResultType<
1162            TimeZonesAbsoluteToCivilTimeResponse,
1163            TimeZonesError,
1164        >>(
1165            result.map(|civil_time| (civil_time,)),
1166            self.tx_id,
1167            0x25377a4d9196e205,
1168            fidl::encoding::DynamicFlags::empty(),
1169        )
1170    }
1171}
1172
1173#[must_use = "FIDL methods require a response to be sent"]
1174#[derive(Debug)]
1175pub struct TimeZonesCivilToAbsoluteTimeResponder {
1176    control_handle: std::mem::ManuallyDrop<TimeZonesControlHandle>,
1177    tx_id: u32,
1178}
1179
1180/// Set the the channel to be shutdown (see [`TimeZonesControlHandle::shutdown`])
1181/// if the responder is dropped without sending a response, so that the client
1182/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1183impl std::ops::Drop for TimeZonesCivilToAbsoluteTimeResponder {
1184    fn drop(&mut self) {
1185        self.control_handle.shutdown();
1186        // Safety: drops once, never accessed again
1187        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1188    }
1189}
1190
1191impl fidl::endpoints::Responder for TimeZonesCivilToAbsoluteTimeResponder {
1192    type ControlHandle = TimeZonesControlHandle;
1193
1194    fn control_handle(&self) -> &TimeZonesControlHandle {
1195        &self.control_handle
1196    }
1197
1198    fn drop_without_shutdown(mut self) {
1199        // Safety: drops once, never accessed again due to mem::forget
1200        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1201        // Prevent Drop from running (which would shut down the channel)
1202        std::mem::forget(self);
1203    }
1204}
1205
1206impl TimeZonesCivilToAbsoluteTimeResponder {
1207    /// Sends a response to the FIDL transaction.
1208    ///
1209    /// Sets the channel to shutdown if an error occurs.
1210    pub fn send(self, mut result: Result<i64, TimeZonesError>) -> Result<(), fidl::Error> {
1211        let _result = self.send_raw(result);
1212        if _result.is_err() {
1213            self.control_handle.shutdown();
1214        }
1215        self.drop_without_shutdown();
1216        _result
1217    }
1218
1219    /// Similar to "send" but does not shutdown the channel if an error occurs.
1220    pub fn send_no_shutdown_on_err(
1221        self,
1222        mut result: Result<i64, TimeZonesError>,
1223    ) -> Result<(), fidl::Error> {
1224        let _result = self.send_raw(result);
1225        self.drop_without_shutdown();
1226        _result
1227    }
1228
1229    fn send_raw(&self, mut result: Result<i64, TimeZonesError>) -> Result<(), fidl::Error> {
1230        self.control_handle.inner.send::<fidl::encoding::ResultType<
1231            TimeZonesCivilToAbsoluteTimeResponse,
1232            TimeZonesError,
1233        >>(
1234            result.map(|absolute_time| (absolute_time,)),
1235            self.tx_id,
1236            0xc1277c7a1413aa6,
1237            fidl::encoding::DynamicFlags::empty(),
1238        )
1239    }
1240}
1241
1242#[must_use = "FIDL methods require a response to be sent"]
1243#[derive(Debug)]
1244pub struct TimeZonesGetTimeZoneInfoResponder {
1245    control_handle: std::mem::ManuallyDrop<TimeZonesControlHandle>,
1246    tx_id: u32,
1247}
1248
1249/// Set the the channel to be shutdown (see [`TimeZonesControlHandle::shutdown`])
1250/// if the responder is dropped without sending a response, so that the client
1251/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1252impl std::ops::Drop for TimeZonesGetTimeZoneInfoResponder {
1253    fn drop(&mut self) {
1254        self.control_handle.shutdown();
1255        // Safety: drops once, never accessed again
1256        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1257    }
1258}
1259
1260impl fidl::endpoints::Responder for TimeZonesGetTimeZoneInfoResponder {
1261    type ControlHandle = TimeZonesControlHandle;
1262
1263    fn control_handle(&self) -> &TimeZonesControlHandle {
1264        &self.control_handle
1265    }
1266
1267    fn drop_without_shutdown(mut self) {
1268        // Safety: drops once, never accessed again due to mem::forget
1269        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1270        // Prevent Drop from running (which would shut down the channel)
1271        std::mem::forget(self);
1272    }
1273}
1274
1275impl TimeZonesGetTimeZoneInfoResponder {
1276    /// Sends a response to the FIDL transaction.
1277    ///
1278    /// Sets the channel to shutdown if an error occurs.
1279    pub fn send(
1280        self,
1281        mut result: Result<&TimeZoneInfo, TimeZonesError>,
1282    ) -> Result<(), fidl::Error> {
1283        let _result = self.send_raw(result);
1284        if _result.is_err() {
1285            self.control_handle.shutdown();
1286        }
1287        self.drop_without_shutdown();
1288        _result
1289    }
1290
1291    /// Similar to "send" but does not shutdown the channel if an error occurs.
1292    pub fn send_no_shutdown_on_err(
1293        self,
1294        mut result: Result<&TimeZoneInfo, TimeZonesError>,
1295    ) -> Result<(), fidl::Error> {
1296        let _result = self.send_raw(result);
1297        self.drop_without_shutdown();
1298        _result
1299    }
1300
1301    fn send_raw(
1302        &self,
1303        mut result: Result<&TimeZoneInfo, TimeZonesError>,
1304    ) -> Result<(), fidl::Error> {
1305        self.control_handle.inner.send::<fidl::encoding::ResultType<
1306            TimeZonesGetTimeZoneInfoResponse,
1307            TimeZonesError,
1308        >>(
1309            result.map(|time_zone_info| (time_zone_info,)),
1310            self.tx_id,
1311            0x2144cbac1d76fe65,
1312            fidl::encoding::DynamicFlags::empty(),
1313        )
1314    }
1315}
1316
1317mod internal {
1318    use super::*;
1319}
fidl_fuchsia_intl/fidl_fuchsia_intl.rs

fidl_fuchsia_intl/
fidl_fuchsia_intl.rs
