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

fidl_fuchsia_location_position/
fidl_fuchsia_location_position.rs
