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