fdomain_fuchsia_component_resolution/
fdomain_fuchsia_component_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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9pub use fidl_fuchsia_component_resolution_common::*;
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13#[derive(Debug, PartialEq)]
14pub struct ResolverResolveWithContextResponse {
15    pub component: Component,
16}
17
18impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
19    for ResolverResolveWithContextResponse
20{
21}
22
23#[derive(Debug, PartialEq)]
24pub struct ResolverResolveResponse {
25    pub component: Component,
26}
27
28impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for ResolverResolveResponse {}
29
30/// A component is a unit of executable software.
31///
32/// This object provides the component's declaration, access to its package's
33/// content, and relevant metadata as resolved `fuchsia.component.resolution.Resolver`.
34#[derive(Debug, Default, PartialEq)]
35pub struct Component {
36    /// The resolved URL of the component.
37    /// This is the canonical URL obtained by the component resolver after
38    /// following redirects and resolving relative paths.
39    pub url: Option<String>,
40    /// Binary representation of the component's declaration (`fuchsia.component.decl.Component`).
41    /// This information is typically obtained from the component's manifest
42    /// or generated by the component resolver.
43    pub decl: Option<fdomain_fuchsia_mem::Data>,
44    /// The package that contains the component.
45    /// By convention, the component's package is mapped to "/pkg" in its
46    /// namespace at runtime.
47    ///
48    /// This is null if the component is not represented as a package.
49    /// In that case, it is the runner's responsibility to load the component's
50    /// resource from the `url`.  This mechanism is used for web
51    /// applications.
52    ///
53    /// Most runners, including but not limited to the builtin ELF runner,
54    /// require the package's directory connection to have OPEN_RIGHT_EXECUTABLE
55    /// rights in order to run the resolved component.
56    pub package: Option<Package>,
57    /// Binary representation of the component's configuration values
58    /// (`fuchsia.component.config.ValuesData`).
59    pub config_values: Option<fdomain_fuchsia_mem::Data>,
60    /// The context used to resolve `component_url`s relative to this
61    /// component. Pass this value to `Resolver::ResolveWithContext()` when
62    /// resolving a component URL that _may_ be relative to this `Component`.
63    ///
64    /// The `resolution_context` is an opaque value (from the perspective of
65    /// component resolution) that is provided by a component `Resolver` to save
66    /// with a parent `Component`.
67    ///
68    /// `Resolver`s that can resolve relative path component URLs, via
69    /// `ResolveWithContext`, should return a `resolution_context` from both
70    /// `Resolve` and `ResolveWithContext`. Relative path component URLs can
71    /// only be resolved via `ResolveWithContext`, which requires a valid
72    /// resolution `Context`.
73    pub resolution_context: Option<Context>,
74    /// The target ABI revision of the resolved component.
75    pub abi_revision: Option<u64>,
76    #[doc(hidden)]
77    pub __source_breaking: fidl::marker::SourceBreaking,
78}
79
80impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for Component {}
81
82/// A package is a signed collection of immutable files.
83///
84/// This object provides access to a package's content and relevant metadata.
85#[derive(Debug, Default, PartialEq)]
86pub struct Package {
87    /// The URL of the package itself.
88    pub url: Option<String>,
89    /// The package's content directory.
90    pub directory: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>>,
91    #[doc(hidden)]
92    pub __source_breaking: fidl::marker::SourceBreaking,
93}
94
95impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for Package {}
96
97#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
98pub struct ResolverMarker;
99
100impl fdomain_client::fidl::ProtocolMarker for ResolverMarker {
101    type Proxy = ResolverProxy;
102    type RequestStream = ResolverRequestStream;
103
104    const DEBUG_NAME: &'static str = "fuchsia.component.resolution.Resolver";
105}
106impl fdomain_client::fidl::DiscoverableProtocolMarker for ResolverMarker {}
107pub type ResolverResolveResult = Result<Component, ResolverError>;
108pub type ResolverResolveWithContextResult = Result<Component, ResolverError>;
109
110pub trait ResolverProxyInterface: Send + Sync {
111    type ResolveResponseFut: std::future::Future<Output = Result<ResolverResolveResult, fidl::Error>>
112        + Send;
113    fn r#resolve(&self, component_url: &str) -> Self::ResolveResponseFut;
114    type ResolveWithContextResponseFut: std::future::Future<Output = Result<ResolverResolveWithContextResult, fidl::Error>>
115        + Send;
116    fn r#resolve_with_context(
117        &self,
118        component_url: &str,
119        context: &Context,
120    ) -> Self::ResolveWithContextResponseFut;
121}
122
123#[derive(Debug, Clone)]
124pub struct ResolverProxy {
125    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
126}
127
128impl fdomain_client::fidl::Proxy for ResolverProxy {
129    type Protocol = ResolverMarker;
130
131    fn from_channel(inner: fdomain_client::Channel) -> Self {
132        Self::new(inner)
133    }
134
135    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
136        self.client.into_channel().map_err(|client| Self { client })
137    }
138
139    fn as_channel(&self) -> &fdomain_client::Channel {
140        self.client.as_channel()
141    }
142}
143
144impl ResolverProxy {
145    /// Create a new Proxy for fuchsia.component.resolution/Resolver.
146    pub fn new(channel: fdomain_client::Channel) -> Self {
147        let protocol_name = <ResolverMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
148        Self { client: fidl::client::Client::new(channel, protocol_name) }
149    }
150
151    /// Get a Stream of events from the remote end of the protocol.
152    ///
153    /// # Panics
154    ///
155    /// Panics if the event stream was already taken.
156    pub fn take_event_stream(&self) -> ResolverEventStream {
157        ResolverEventStream { event_receiver: self.client.take_event_receiver() }
158    }
159
160    /// Resolves a component with the given absolute URL.
161    ///
162    /// `component_url` is the unescaped URL of the component to resolve.
163    ///
164    /// If successful, returns information about the component
165    /// that was resolved.
166    ///
167    /// On failure, returns a `ResolverError` error.
168    pub fn r#resolve(
169        &self,
170        mut component_url: &str,
171    ) -> fidl::client::QueryResponseFut<
172        ResolverResolveResult,
173        fdomain_client::fidl::FDomainResourceDialect,
174    > {
175        ResolverProxyInterface::r#resolve(self, component_url)
176    }
177
178    /// Resolves a component with the absolute or relative URL. If relative, the
179    /// component will be resolved relative to the supplied `context`.
180    ///
181    /// `component_url` is the unescaped URL of the component to resolve, the
182    /// format of which can be either:
183    ///
184    ///   * a fully-qualified absolute component URL; or
185    ///   * a subpackaged-component reference, prefixed by a URI relative
186    ///     path to its containing subpackage (for example,
187    ///     `child_package#meta/some_component.cm`)
188    ///
189    /// `context` is the `resolution_context` of a previously-resolved
190    /// `Component`, providing the context for resoving a relative URL.
191    pub fn r#resolve_with_context(
192        &self,
193        mut component_url: &str,
194        mut context: &Context,
195    ) -> fidl::client::QueryResponseFut<
196        ResolverResolveWithContextResult,
197        fdomain_client::fidl::FDomainResourceDialect,
198    > {
199        ResolverProxyInterface::r#resolve_with_context(self, component_url, context)
200    }
201}
202
203impl ResolverProxyInterface for ResolverProxy {
204    type ResolveResponseFut = fidl::client::QueryResponseFut<
205        ResolverResolveResult,
206        fdomain_client::fidl::FDomainResourceDialect,
207    >;
208    fn r#resolve(&self, mut component_url: &str) -> Self::ResolveResponseFut {
209        fn _decode(
210            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
211        ) -> Result<ResolverResolveResult, fidl::Error> {
212            let _response = fidl::client::decode_transaction_body::<
213                fidl::encoding::ResultType<ResolverResolveResponse, ResolverError>,
214                fdomain_client::fidl::FDomainResourceDialect,
215                0x57f9cfe88bf1f2e5,
216            >(_buf?)?;
217            Ok(_response.map(|x| x.component))
218        }
219        self.client.send_query_and_decode::<ResolverResolveRequest, ResolverResolveResult>(
220            (component_url,),
221            0x57f9cfe88bf1f2e5,
222            fidl::encoding::DynamicFlags::empty(),
223            _decode,
224        )
225    }
226
227    type ResolveWithContextResponseFut = fidl::client::QueryResponseFut<
228        ResolverResolveWithContextResult,
229        fdomain_client::fidl::FDomainResourceDialect,
230    >;
231    fn r#resolve_with_context(
232        &self,
233        mut component_url: &str,
234        mut context: &Context,
235    ) -> Self::ResolveWithContextResponseFut {
236        fn _decode(
237            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
238        ) -> Result<ResolverResolveWithContextResult, fidl::Error> {
239            let _response = fidl::client::decode_transaction_body::<
240                fidl::encoding::ResultType<ResolverResolveWithContextResponse, ResolverError>,
241                fdomain_client::fidl::FDomainResourceDialect,
242                0x4d64b0de827070bd,
243            >(_buf?)?;
244            Ok(_response.map(|x| x.component))
245        }
246        self.client.send_query_and_decode::<
247            ResolverResolveWithContextRequest,
248            ResolverResolveWithContextResult,
249        >(
250            (component_url, context,),
251            0x4d64b0de827070bd,
252            fidl::encoding::DynamicFlags::empty(),
253            _decode,
254        )
255    }
256}
257
258pub struct ResolverEventStream {
259    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
260}
261
262impl std::marker::Unpin for ResolverEventStream {}
263
264impl futures::stream::FusedStream for ResolverEventStream {
265    fn is_terminated(&self) -> bool {
266        self.event_receiver.is_terminated()
267    }
268}
269
270impl futures::Stream for ResolverEventStream {
271    type Item = Result<ResolverEvent, fidl::Error>;
272
273    fn poll_next(
274        mut self: std::pin::Pin<&mut Self>,
275        cx: &mut std::task::Context<'_>,
276    ) -> std::task::Poll<Option<Self::Item>> {
277        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
278            &mut self.event_receiver,
279            cx
280        )?) {
281            Some(buf) => std::task::Poll::Ready(Some(ResolverEvent::decode(buf))),
282            None => std::task::Poll::Ready(None),
283        }
284    }
285}
286
287#[derive(Debug)]
288pub enum ResolverEvent {
289    #[non_exhaustive]
290    _UnknownEvent {
291        /// Ordinal of the event that was sent.
292        ordinal: u64,
293    },
294}
295
296impl ResolverEvent {
297    /// Decodes a message buffer as a [`ResolverEvent`].
298    fn decode(
299        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
300    ) -> Result<ResolverEvent, fidl::Error> {
301        let (bytes, _handles) = buf.split_mut();
302        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
303        debug_assert_eq!(tx_header.tx_id, 0);
304        match tx_header.ordinal {
305            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
306                Ok(ResolverEvent::_UnknownEvent { ordinal: tx_header.ordinal })
307            }
308            _ => Err(fidl::Error::UnknownOrdinal {
309                ordinal: tx_header.ordinal,
310                protocol_name: <ResolverMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
311            }),
312        }
313    }
314}
315
316/// A Stream of incoming requests for fuchsia.component.resolution/Resolver.
317pub struct ResolverRequestStream {
318    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
319    is_terminated: bool,
320}
321
322impl std::marker::Unpin for ResolverRequestStream {}
323
324impl futures::stream::FusedStream for ResolverRequestStream {
325    fn is_terminated(&self) -> bool {
326        self.is_terminated
327    }
328}
329
330impl fdomain_client::fidl::RequestStream for ResolverRequestStream {
331    type Protocol = ResolverMarker;
332    type ControlHandle = ResolverControlHandle;
333
334    fn from_channel(channel: fdomain_client::Channel) -> Self {
335        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
336    }
337
338    fn control_handle(&self) -> Self::ControlHandle {
339        ResolverControlHandle { inner: self.inner.clone() }
340    }
341
342    fn into_inner(
343        self,
344    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
345    {
346        (self.inner, self.is_terminated)
347    }
348
349    fn from_inner(
350        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
351        is_terminated: bool,
352    ) -> Self {
353        Self { inner, is_terminated }
354    }
355}
356
357impl futures::Stream for ResolverRequestStream {
358    type Item = Result<ResolverRequest, fidl::Error>;
359
360    fn poll_next(
361        mut self: std::pin::Pin<&mut Self>,
362        cx: &mut std::task::Context<'_>,
363    ) -> std::task::Poll<Option<Self::Item>> {
364        let this = &mut *self;
365        if this.inner.check_shutdown(cx) {
366            this.is_terminated = true;
367            return std::task::Poll::Ready(None);
368        }
369        if this.is_terminated {
370            panic!("polled ResolverRequestStream after completion");
371        }
372        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
373            |bytes, handles| {
374                match this.inner.channel().read_etc(cx, bytes, handles) {
375                    std::task::Poll::Ready(Ok(())) => {}
376                    std::task::Poll::Pending => return std::task::Poll::Pending,
377                    std::task::Poll::Ready(Err(None)) => {
378                        this.is_terminated = true;
379                        return std::task::Poll::Ready(None);
380                    }
381                    std::task::Poll::Ready(Err(Some(e))) => {
382                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
383                            e.into(),
384                        ))));
385                    }
386                }
387
388                // A message has been received from the channel
389                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
390
391                std::task::Poll::Ready(Some(match header.ordinal {
392                    0x57f9cfe88bf1f2e5 => {
393                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
394                        let mut req = fidl::new_empty!(
395                            ResolverResolveRequest,
396                            fdomain_client::fidl::FDomainResourceDialect
397                        );
398                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ResolverResolveRequest>(&header, _body_bytes, handles, &mut req)?;
399                        let control_handle = ResolverControlHandle { inner: this.inner.clone() };
400                        Ok(ResolverRequest::Resolve {
401                            component_url: req.component_url,
402
403                            responder: ResolverResolveResponder {
404                                control_handle: std::mem::ManuallyDrop::new(control_handle),
405                                tx_id: header.tx_id,
406                            },
407                        })
408                    }
409                    0x4d64b0de827070bd => {
410                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
411                        let mut req = fidl::new_empty!(
412                            ResolverResolveWithContextRequest,
413                            fdomain_client::fidl::FDomainResourceDialect
414                        );
415                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ResolverResolveWithContextRequest>(&header, _body_bytes, handles, &mut req)?;
416                        let control_handle = ResolverControlHandle { inner: this.inner.clone() };
417                        Ok(ResolverRequest::ResolveWithContext {
418                            component_url: req.component_url,
419                            context: req.context,
420
421                            responder: ResolverResolveWithContextResponder {
422                                control_handle: std::mem::ManuallyDrop::new(control_handle),
423                                tx_id: header.tx_id,
424                            },
425                        })
426                    }
427                    _ if header.tx_id == 0
428                        && header
429                            .dynamic_flags()
430                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
431                    {
432                        Ok(ResolverRequest::_UnknownMethod {
433                            ordinal: header.ordinal,
434                            control_handle: ResolverControlHandle { inner: this.inner.clone() },
435                            method_type: fidl::MethodType::OneWay,
436                        })
437                    }
438                    _ if header
439                        .dynamic_flags()
440                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
441                    {
442                        this.inner.send_framework_err(
443                            fidl::encoding::FrameworkErr::UnknownMethod,
444                            header.tx_id,
445                            header.ordinal,
446                            header.dynamic_flags(),
447                            (bytes, handles),
448                        )?;
449                        Ok(ResolverRequest::_UnknownMethod {
450                            ordinal: header.ordinal,
451                            control_handle: ResolverControlHandle { inner: this.inner.clone() },
452                            method_type: fidl::MethodType::TwoWay,
453                        })
454                    }
455                    _ => Err(fidl::Error::UnknownOrdinal {
456                        ordinal: header.ordinal,
457                        protocol_name:
458                            <ResolverMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
459                    }),
460                }))
461            },
462        )
463    }
464}
465
466/// An interface for resolving a URL to a component.
467///
468/// This interface is implemented by components that provide support
469/// for loading components with a particular URL scheme.   For example,
470/// the Fuchsia package component resolver exposes a service with this
471/// interface to resolve component URLs using the "fuchsia-pkg://" scheme.
472///
473/// To use a resolver to resolve URLs within your realm, register it
474/// in your realm's manifest.
475///
476/// Note: The component manager is the only intended direct client of this
477/// interface.
478#[derive(Debug)]
479pub enum ResolverRequest {
480    /// Resolves a component with the given absolute URL.
481    ///
482    /// `component_url` is the unescaped URL of the component to resolve.
483    ///
484    /// If successful, returns information about the component
485    /// that was resolved.
486    ///
487    /// On failure, returns a `ResolverError` error.
488    Resolve { component_url: String, responder: ResolverResolveResponder },
489    /// Resolves a component with the absolute or relative URL. If relative, the
490    /// component will be resolved relative to the supplied `context`.
491    ///
492    /// `component_url` is the unescaped URL of the component to resolve, the
493    /// format of which can be either:
494    ///
495    ///   * a fully-qualified absolute component URL; or
496    ///   * a subpackaged-component reference, prefixed by a URI relative
497    ///     path to its containing subpackage (for example,
498    ///     `child_package#meta/some_component.cm`)
499    ///
500    /// `context` is the `resolution_context` of a previously-resolved
501    /// `Component`, providing the context for resoving a relative URL.
502    ResolveWithContext {
503        component_url: String,
504        context: Context,
505        responder: ResolverResolveWithContextResponder,
506    },
507    /// An interaction was received which does not match any known method.
508    #[non_exhaustive]
509    _UnknownMethod {
510        /// Ordinal of the method that was called.
511        ordinal: u64,
512        control_handle: ResolverControlHandle,
513        method_type: fidl::MethodType,
514    },
515}
516
517impl ResolverRequest {
518    #[allow(irrefutable_let_patterns)]
519    pub fn into_resolve(self) -> Option<(String, ResolverResolveResponder)> {
520        if let ResolverRequest::Resolve { component_url, responder } = self {
521            Some((component_url, responder))
522        } else {
523            None
524        }
525    }
526
527    #[allow(irrefutable_let_patterns)]
528    pub fn into_resolve_with_context(
529        self,
530    ) -> Option<(String, Context, ResolverResolveWithContextResponder)> {
531        if let ResolverRequest::ResolveWithContext { component_url, context, responder } = self {
532            Some((component_url, context, responder))
533        } else {
534            None
535        }
536    }
537
538    /// Name of the method defined in FIDL
539    pub fn method_name(&self) -> &'static str {
540        match *self {
541            ResolverRequest::Resolve { .. } => "resolve",
542            ResolverRequest::ResolveWithContext { .. } => "resolve_with_context",
543            ResolverRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
544                "unknown one-way method"
545            }
546            ResolverRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
547                "unknown two-way method"
548            }
549        }
550    }
551}
552
553#[derive(Debug, Clone)]
554pub struct ResolverControlHandle {
555    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
556}
557
558impl ResolverControlHandle {
559    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
560        self.inner.shutdown_with_epitaph(status.into())
561    }
562}
563
564impl fdomain_client::fidl::ControlHandle for ResolverControlHandle {
565    fn shutdown(&self) {
566        self.inner.shutdown()
567    }
568
569    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
570        self.inner.shutdown_with_epitaph(status)
571    }
572
573    fn is_closed(&self) -> bool {
574        self.inner.channel().is_closed()
575    }
576    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
577        self.inner.channel().on_closed()
578    }
579}
580
581impl ResolverControlHandle {}
582
583#[must_use = "FIDL methods require a response to be sent"]
584#[derive(Debug)]
585pub struct ResolverResolveResponder {
586    control_handle: std::mem::ManuallyDrop<ResolverControlHandle>,
587    tx_id: u32,
588}
589
590/// Set the the channel to be shutdown (see [`ResolverControlHandle::shutdown`])
591/// if the responder is dropped without sending a response, so that the client
592/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
593impl std::ops::Drop for ResolverResolveResponder {
594    fn drop(&mut self) {
595        self.control_handle.shutdown();
596        // Safety: drops once, never accessed again
597        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
598    }
599}
600
601impl fdomain_client::fidl::Responder for ResolverResolveResponder {
602    type ControlHandle = ResolverControlHandle;
603
604    fn control_handle(&self) -> &ResolverControlHandle {
605        &self.control_handle
606    }
607
608    fn drop_without_shutdown(mut self) {
609        // Safety: drops once, never accessed again due to mem::forget
610        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
611        // Prevent Drop from running (which would shut down the channel)
612        std::mem::forget(self);
613    }
614}
615
616impl ResolverResolveResponder {
617    /// Sends a response to the FIDL transaction.
618    ///
619    /// Sets the channel to shutdown if an error occurs.
620    pub fn send(self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
621        let _result = self.send_raw(result);
622        if _result.is_err() {
623            self.control_handle.shutdown();
624        }
625        self.drop_without_shutdown();
626        _result
627    }
628
629    /// Similar to "send" but does not shutdown the channel if an error occurs.
630    pub fn send_no_shutdown_on_err(
631        self,
632        mut result: Result<Component, ResolverError>,
633    ) -> Result<(), fidl::Error> {
634        let _result = self.send_raw(result);
635        self.drop_without_shutdown();
636        _result
637    }
638
639    fn send_raw(&self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
640        self.control_handle
641            .inner
642            .send::<fidl::encoding::ResultType<ResolverResolveResponse, ResolverError>>(
643                result.as_mut().map_err(|e| *e).map(|component| (component,)),
644                self.tx_id,
645                0x57f9cfe88bf1f2e5,
646                fidl::encoding::DynamicFlags::empty(),
647            )
648    }
649}
650
651#[must_use = "FIDL methods require a response to be sent"]
652#[derive(Debug)]
653pub struct ResolverResolveWithContextResponder {
654    control_handle: std::mem::ManuallyDrop<ResolverControlHandle>,
655    tx_id: u32,
656}
657
658/// Set the the channel to be shutdown (see [`ResolverControlHandle::shutdown`])
659/// if the responder is dropped without sending a response, so that the client
660/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
661impl std::ops::Drop for ResolverResolveWithContextResponder {
662    fn drop(&mut self) {
663        self.control_handle.shutdown();
664        // Safety: drops once, never accessed again
665        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
666    }
667}
668
669impl fdomain_client::fidl::Responder for ResolverResolveWithContextResponder {
670    type ControlHandle = ResolverControlHandle;
671
672    fn control_handle(&self) -> &ResolverControlHandle {
673        &self.control_handle
674    }
675
676    fn drop_without_shutdown(mut self) {
677        // Safety: drops once, never accessed again due to mem::forget
678        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
679        // Prevent Drop from running (which would shut down the channel)
680        std::mem::forget(self);
681    }
682}
683
684impl ResolverResolveWithContextResponder {
685    /// Sends a response to the FIDL transaction.
686    ///
687    /// Sets the channel to shutdown if an error occurs.
688    pub fn send(self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
689        let _result = self.send_raw(result);
690        if _result.is_err() {
691            self.control_handle.shutdown();
692        }
693        self.drop_without_shutdown();
694        _result
695    }
696
697    /// Similar to "send" but does not shutdown the channel if an error occurs.
698    pub fn send_no_shutdown_on_err(
699        self,
700        mut result: Result<Component, ResolverError>,
701    ) -> Result<(), fidl::Error> {
702        let _result = self.send_raw(result);
703        self.drop_without_shutdown();
704        _result
705    }
706
707    fn send_raw(&self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
708        self.control_handle.inner.send::<fidl::encoding::ResultType<
709            ResolverResolveWithContextResponse,
710            ResolverError,
711        >>(
712            result.as_mut().map_err(|e| *e).map(|component| (component,)),
713            self.tx_id,
714            0x4d64b0de827070bd,
715            fidl::encoding::DynamicFlags::empty(),
716        )
717    }
718}
719
720mod internal {
721    use super::*;
722
723    impl fidl::encoding::ResourceTypeMarker for ResolverResolveWithContextResponse {
724        type Borrowed<'a> = &'a mut Self;
725        fn take_or_borrow<'a>(
726            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
727        ) -> Self::Borrowed<'a> {
728            value
729        }
730    }
731
732    unsafe impl fidl::encoding::TypeMarker for ResolverResolveWithContextResponse {
733        type Owned = Self;
734
735        #[inline(always)]
736        fn inline_align(_context: fidl::encoding::Context) -> usize {
737            8
738        }
739
740        #[inline(always)]
741        fn inline_size(_context: fidl::encoding::Context) -> usize {
742            16
743        }
744    }
745
746    unsafe impl
747        fidl::encoding::Encode<
748            ResolverResolveWithContextResponse,
749            fdomain_client::fidl::FDomainResourceDialect,
750        > for &mut ResolverResolveWithContextResponse
751    {
752        #[inline]
753        unsafe fn encode(
754            self,
755            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
756            offset: usize,
757            _depth: fidl::encoding::Depth,
758        ) -> fidl::Result<()> {
759            encoder.debug_check_bounds::<ResolverResolveWithContextResponse>(offset);
760            // Delegate to tuple encoding.
761            fidl::encoding::Encode::<
762                ResolverResolveWithContextResponse,
763                fdomain_client::fidl::FDomainResourceDialect,
764            >::encode(
765                (<Component as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
766                    &mut self.component,
767                ),),
768                encoder,
769                offset,
770                _depth,
771            )
772        }
773    }
774    unsafe impl<T0: fidl::encoding::Encode<Component, fdomain_client::fidl::FDomainResourceDialect>>
775        fidl::encoding::Encode<
776            ResolverResolveWithContextResponse,
777            fdomain_client::fidl::FDomainResourceDialect,
778        > for (T0,)
779    {
780        #[inline]
781        unsafe fn encode(
782            self,
783            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
784            offset: usize,
785            depth: fidl::encoding::Depth,
786        ) -> fidl::Result<()> {
787            encoder.debug_check_bounds::<ResolverResolveWithContextResponse>(offset);
788            // Zero out padding regions. There's no need to apply masks
789            // because the unmasked parts will be overwritten by fields.
790            // Write the fields.
791            self.0.encode(encoder, offset + 0, depth)?;
792            Ok(())
793        }
794    }
795
796    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
797        for ResolverResolveWithContextResponse
798    {
799        #[inline(always)]
800        fn new_empty() -> Self {
801            Self {
802                component: fidl::new_empty!(
803                    Component,
804                    fdomain_client::fidl::FDomainResourceDialect
805                ),
806            }
807        }
808
809        #[inline]
810        unsafe fn decode(
811            &mut self,
812            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
813            offset: usize,
814            _depth: fidl::encoding::Depth,
815        ) -> fidl::Result<()> {
816            decoder.debug_check_bounds::<Self>(offset);
817            // Verify that padding bytes are zero.
818            fidl::decode!(
819                Component,
820                fdomain_client::fidl::FDomainResourceDialect,
821                &mut self.component,
822                decoder,
823                offset + 0,
824                _depth
825            )?;
826            Ok(())
827        }
828    }
829
830    impl fidl::encoding::ResourceTypeMarker for ResolverResolveResponse {
831        type Borrowed<'a> = &'a mut Self;
832        fn take_or_borrow<'a>(
833            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
834        ) -> Self::Borrowed<'a> {
835            value
836        }
837    }
838
839    unsafe impl fidl::encoding::TypeMarker for ResolverResolveResponse {
840        type Owned = Self;
841
842        #[inline(always)]
843        fn inline_align(_context: fidl::encoding::Context) -> usize {
844            8
845        }
846
847        #[inline(always)]
848        fn inline_size(_context: fidl::encoding::Context) -> usize {
849            16
850        }
851    }
852
853    unsafe impl
854        fidl::encoding::Encode<
855            ResolverResolveResponse,
856            fdomain_client::fidl::FDomainResourceDialect,
857        > for &mut ResolverResolveResponse
858    {
859        #[inline]
860        unsafe fn encode(
861            self,
862            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
863            offset: usize,
864            _depth: fidl::encoding::Depth,
865        ) -> fidl::Result<()> {
866            encoder.debug_check_bounds::<ResolverResolveResponse>(offset);
867            // Delegate to tuple encoding.
868            fidl::encoding::Encode::<
869                ResolverResolveResponse,
870                fdomain_client::fidl::FDomainResourceDialect,
871            >::encode(
872                (<Component as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
873                    &mut self.component,
874                ),),
875                encoder,
876                offset,
877                _depth,
878            )
879        }
880    }
881    unsafe impl<T0: fidl::encoding::Encode<Component, fdomain_client::fidl::FDomainResourceDialect>>
882        fidl::encoding::Encode<
883            ResolverResolveResponse,
884            fdomain_client::fidl::FDomainResourceDialect,
885        > for (T0,)
886    {
887        #[inline]
888        unsafe fn encode(
889            self,
890            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
891            offset: usize,
892            depth: fidl::encoding::Depth,
893        ) -> fidl::Result<()> {
894            encoder.debug_check_bounds::<ResolverResolveResponse>(offset);
895            // Zero out padding regions. There's no need to apply masks
896            // because the unmasked parts will be overwritten by fields.
897            // Write the fields.
898            self.0.encode(encoder, offset + 0, depth)?;
899            Ok(())
900        }
901    }
902
903    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
904        for ResolverResolveResponse
905    {
906        #[inline(always)]
907        fn new_empty() -> Self {
908            Self {
909                component: fidl::new_empty!(
910                    Component,
911                    fdomain_client::fidl::FDomainResourceDialect
912                ),
913            }
914        }
915
916        #[inline]
917        unsafe fn decode(
918            &mut self,
919            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
920            offset: usize,
921            _depth: fidl::encoding::Depth,
922        ) -> fidl::Result<()> {
923            decoder.debug_check_bounds::<Self>(offset);
924            // Verify that padding bytes are zero.
925            fidl::decode!(
926                Component,
927                fdomain_client::fidl::FDomainResourceDialect,
928                &mut self.component,
929                decoder,
930                offset + 0,
931                _depth
932            )?;
933            Ok(())
934        }
935    }
936
937    impl Component {
938        #[inline(always)]
939        fn max_ordinal_present(&self) -> u64 {
940            if let Some(_) = self.abi_revision {
941                return 6;
942            }
943            if let Some(_) = self.resolution_context {
944                return 5;
945            }
946            if let Some(_) = self.config_values {
947                return 4;
948            }
949            if let Some(_) = self.package {
950                return 3;
951            }
952            if let Some(_) = self.decl {
953                return 2;
954            }
955            if let Some(_) = self.url {
956                return 1;
957            }
958            0
959        }
960    }
961
962    impl fidl::encoding::ResourceTypeMarker for Component {
963        type Borrowed<'a> = &'a mut Self;
964        fn take_or_borrow<'a>(
965            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
966        ) -> Self::Borrowed<'a> {
967            value
968        }
969    }
970
971    unsafe impl fidl::encoding::TypeMarker for Component {
972        type Owned = Self;
973
974        #[inline(always)]
975        fn inline_align(_context: fidl::encoding::Context) -> usize {
976            8
977        }
978
979        #[inline(always)]
980        fn inline_size(_context: fidl::encoding::Context) -> usize {
981            16
982        }
983    }
984
985    unsafe impl fidl::encoding::Encode<Component, fdomain_client::fidl::FDomainResourceDialect>
986        for &mut Component
987    {
988        unsafe fn encode(
989            self,
990            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
991            offset: usize,
992            mut depth: fidl::encoding::Depth,
993        ) -> fidl::Result<()> {
994            encoder.debug_check_bounds::<Component>(offset);
995            // Vector header
996            let max_ordinal: u64 = self.max_ordinal_present();
997            encoder.write_num(max_ordinal, offset);
998            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
999            // Calling encoder.out_of_line_offset(0) is not allowed.
1000            if max_ordinal == 0 {
1001                return Ok(());
1002            }
1003            depth.increment()?;
1004            let envelope_size = 8;
1005            let bytes_len = max_ordinal as usize * envelope_size;
1006            #[allow(unused_variables)]
1007            let offset = encoder.out_of_line_offset(bytes_len);
1008            let mut _prev_end_offset: usize = 0;
1009            if 1 > max_ordinal {
1010                return Ok(());
1011            }
1012
1013            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1014            // are envelope_size bytes.
1015            let cur_offset: usize = (1 - 1) * envelope_size;
1016
1017            // Zero reserved fields.
1018            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1019
1020            // Safety:
1021            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1022            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1023            //   envelope_size bytes, there is always sufficient room.
1024            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2083>, fdomain_client::fidl::FDomainResourceDialect>(
1025            self.url.as_ref().map(<fidl::encoding::BoundedString<2083> as fidl::encoding::ValueTypeMarker>::borrow),
1026            encoder, offset + cur_offset, depth
1027        )?;
1028
1029            _prev_end_offset = cur_offset + envelope_size;
1030            if 2 > max_ordinal {
1031                return Ok(());
1032            }
1033
1034            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1035            // are envelope_size bytes.
1036            let cur_offset: usize = (2 - 1) * envelope_size;
1037
1038            // Zero reserved fields.
1039            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1040
1041            // Safety:
1042            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1043            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1044            //   envelope_size bytes, there is always sufficient room.
1045            fidl::encoding::encode_in_envelope_optional::<fdomain_fuchsia_mem::Data, fdomain_client::fidl::FDomainResourceDialect>(
1046            self.decl.as_mut().map(<fdomain_fuchsia_mem::Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1047            encoder, offset + cur_offset, depth
1048        )?;
1049
1050            _prev_end_offset = cur_offset + envelope_size;
1051            if 3 > max_ordinal {
1052                return Ok(());
1053            }
1054
1055            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1056            // are envelope_size bytes.
1057            let cur_offset: usize = (3 - 1) * envelope_size;
1058
1059            // Zero reserved fields.
1060            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1061
1062            // Safety:
1063            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1064            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1065            //   envelope_size bytes, there is always sufficient room.
1066            fidl::encoding::encode_in_envelope_optional::<
1067                Package,
1068                fdomain_client::fidl::FDomainResourceDialect,
1069            >(
1070                self.package
1071                    .as_mut()
1072                    .map(<Package as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1073                encoder,
1074                offset + cur_offset,
1075                depth,
1076            )?;
1077
1078            _prev_end_offset = cur_offset + envelope_size;
1079            if 4 > max_ordinal {
1080                return Ok(());
1081            }
1082
1083            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1084            // are envelope_size bytes.
1085            let cur_offset: usize = (4 - 1) * envelope_size;
1086
1087            // Zero reserved fields.
1088            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1089
1090            // Safety:
1091            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1092            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1093            //   envelope_size bytes, there is always sufficient room.
1094            fidl::encoding::encode_in_envelope_optional::<fdomain_fuchsia_mem::Data, fdomain_client::fidl::FDomainResourceDialect>(
1095            self.config_values.as_mut().map(<fdomain_fuchsia_mem::Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1096            encoder, offset + cur_offset, depth
1097        )?;
1098
1099            _prev_end_offset = cur_offset + envelope_size;
1100            if 5 > max_ordinal {
1101                return Ok(());
1102            }
1103
1104            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1105            // are envelope_size bytes.
1106            let cur_offset: usize = (5 - 1) * envelope_size;
1107
1108            // Zero reserved fields.
1109            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1110
1111            // Safety:
1112            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1113            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1114            //   envelope_size bytes, there is always sufficient room.
1115            fidl::encoding::encode_in_envelope_optional::<
1116                Context,
1117                fdomain_client::fidl::FDomainResourceDialect,
1118            >(
1119                self.resolution_context
1120                    .as_ref()
1121                    .map(<Context as fidl::encoding::ValueTypeMarker>::borrow),
1122                encoder,
1123                offset + cur_offset,
1124                depth,
1125            )?;
1126
1127            _prev_end_offset = cur_offset + envelope_size;
1128            if 6 > max_ordinal {
1129                return Ok(());
1130            }
1131
1132            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1133            // are envelope_size bytes.
1134            let cur_offset: usize = (6 - 1) * envelope_size;
1135
1136            // Zero reserved fields.
1137            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1138
1139            // Safety:
1140            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1141            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1142            //   envelope_size bytes, there is always sufficient room.
1143            fidl::encoding::encode_in_envelope_optional::<
1144                u64,
1145                fdomain_client::fidl::FDomainResourceDialect,
1146            >(
1147                self.abi_revision.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1148                encoder,
1149                offset + cur_offset,
1150                depth,
1151            )?;
1152
1153            _prev_end_offset = cur_offset + envelope_size;
1154
1155            Ok(())
1156        }
1157    }
1158
1159    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Component {
1160        #[inline(always)]
1161        fn new_empty() -> Self {
1162            Self::default()
1163        }
1164
1165        unsafe fn decode(
1166            &mut self,
1167            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
1168            offset: usize,
1169            mut depth: fidl::encoding::Depth,
1170        ) -> fidl::Result<()> {
1171            decoder.debug_check_bounds::<Self>(offset);
1172            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1173                None => return Err(fidl::Error::NotNullable),
1174                Some(len) => len,
1175            };
1176            // Calling decoder.out_of_line_offset(0) is not allowed.
1177            if len == 0 {
1178                return Ok(());
1179            };
1180            depth.increment()?;
1181            let envelope_size = 8;
1182            let bytes_len = len * envelope_size;
1183            let offset = decoder.out_of_line_offset(bytes_len)?;
1184            // Decode the envelope for each type.
1185            let mut _next_ordinal_to_read = 0;
1186            let mut next_offset = offset;
1187            let end_offset = offset + bytes_len;
1188            _next_ordinal_to_read += 1;
1189            if next_offset >= end_offset {
1190                return Ok(());
1191            }
1192
1193            // Decode unknown envelopes for gaps in ordinals.
1194            while _next_ordinal_to_read < 1 {
1195                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1196                _next_ordinal_to_read += 1;
1197                next_offset += envelope_size;
1198            }
1199
1200            let next_out_of_line = decoder.next_out_of_line();
1201            let handles_before = decoder.remaining_handles();
1202            if let Some((inlined, num_bytes, num_handles)) =
1203                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1204            {
1205                let member_inline_size = <fidl::encoding::BoundedString<2083> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1206                if inlined != (member_inline_size <= 4) {
1207                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1208                }
1209                let inner_offset;
1210                let mut inner_depth = depth.clone();
1211                if inlined {
1212                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1213                    inner_offset = next_offset;
1214                } else {
1215                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1216                    inner_depth.increment()?;
1217                }
1218                let val_ref = self.url.get_or_insert_with(|| {
1219                    fidl::new_empty!(
1220                        fidl::encoding::BoundedString<2083>,
1221                        fdomain_client::fidl::FDomainResourceDialect
1222                    )
1223                });
1224                fidl::decode!(
1225                    fidl::encoding::BoundedString<2083>,
1226                    fdomain_client::fidl::FDomainResourceDialect,
1227                    val_ref,
1228                    decoder,
1229                    inner_offset,
1230                    inner_depth
1231                )?;
1232                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1233                {
1234                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1235                }
1236                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1237                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1238                }
1239            }
1240
1241            next_offset += envelope_size;
1242            _next_ordinal_to_read += 1;
1243            if next_offset >= end_offset {
1244                return Ok(());
1245            }
1246
1247            // Decode unknown envelopes for gaps in ordinals.
1248            while _next_ordinal_to_read < 2 {
1249                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1250                _next_ordinal_to_read += 1;
1251                next_offset += envelope_size;
1252            }
1253
1254            let next_out_of_line = decoder.next_out_of_line();
1255            let handles_before = decoder.remaining_handles();
1256            if let Some((inlined, num_bytes, num_handles)) =
1257                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1258            {
1259                let member_inline_size =
1260                    <fdomain_fuchsia_mem::Data as fidl::encoding::TypeMarker>::inline_size(
1261                        decoder.context,
1262                    );
1263                if inlined != (member_inline_size <= 4) {
1264                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1265                }
1266                let inner_offset;
1267                let mut inner_depth = depth.clone();
1268                if inlined {
1269                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1270                    inner_offset = next_offset;
1271                } else {
1272                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1273                    inner_depth.increment()?;
1274                }
1275                let val_ref = self.decl.get_or_insert_with(|| {
1276                    fidl::new_empty!(
1277                        fdomain_fuchsia_mem::Data,
1278                        fdomain_client::fidl::FDomainResourceDialect
1279                    )
1280                });
1281                fidl::decode!(
1282                    fdomain_fuchsia_mem::Data,
1283                    fdomain_client::fidl::FDomainResourceDialect,
1284                    val_ref,
1285                    decoder,
1286                    inner_offset,
1287                    inner_depth
1288                )?;
1289                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1290                {
1291                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1292                }
1293                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1294                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1295                }
1296            }
1297
1298            next_offset += envelope_size;
1299            _next_ordinal_to_read += 1;
1300            if next_offset >= end_offset {
1301                return Ok(());
1302            }
1303
1304            // Decode unknown envelopes for gaps in ordinals.
1305            while _next_ordinal_to_read < 3 {
1306                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1307                _next_ordinal_to_read += 1;
1308                next_offset += envelope_size;
1309            }
1310
1311            let next_out_of_line = decoder.next_out_of_line();
1312            let handles_before = decoder.remaining_handles();
1313            if let Some((inlined, num_bytes, num_handles)) =
1314                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1315            {
1316                let member_inline_size =
1317                    <Package as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1318                if inlined != (member_inline_size <= 4) {
1319                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1320                }
1321                let inner_offset;
1322                let mut inner_depth = depth.clone();
1323                if inlined {
1324                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1325                    inner_offset = next_offset;
1326                } else {
1327                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1328                    inner_depth.increment()?;
1329                }
1330                let val_ref = self.package.get_or_insert_with(|| {
1331                    fidl::new_empty!(Package, fdomain_client::fidl::FDomainResourceDialect)
1332                });
1333                fidl::decode!(
1334                    Package,
1335                    fdomain_client::fidl::FDomainResourceDialect,
1336                    val_ref,
1337                    decoder,
1338                    inner_offset,
1339                    inner_depth
1340                )?;
1341                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1342                {
1343                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1344                }
1345                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1346                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1347                }
1348            }
1349
1350            next_offset += envelope_size;
1351            _next_ordinal_to_read += 1;
1352            if next_offset >= end_offset {
1353                return Ok(());
1354            }
1355
1356            // Decode unknown envelopes for gaps in ordinals.
1357            while _next_ordinal_to_read < 4 {
1358                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1359                _next_ordinal_to_read += 1;
1360                next_offset += envelope_size;
1361            }
1362
1363            let next_out_of_line = decoder.next_out_of_line();
1364            let handles_before = decoder.remaining_handles();
1365            if let Some((inlined, num_bytes, num_handles)) =
1366                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1367            {
1368                let member_inline_size =
1369                    <fdomain_fuchsia_mem::Data as fidl::encoding::TypeMarker>::inline_size(
1370                        decoder.context,
1371                    );
1372                if inlined != (member_inline_size <= 4) {
1373                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1374                }
1375                let inner_offset;
1376                let mut inner_depth = depth.clone();
1377                if inlined {
1378                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1379                    inner_offset = next_offset;
1380                } else {
1381                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1382                    inner_depth.increment()?;
1383                }
1384                let val_ref = self.config_values.get_or_insert_with(|| {
1385                    fidl::new_empty!(
1386                        fdomain_fuchsia_mem::Data,
1387                        fdomain_client::fidl::FDomainResourceDialect
1388                    )
1389                });
1390                fidl::decode!(
1391                    fdomain_fuchsia_mem::Data,
1392                    fdomain_client::fidl::FDomainResourceDialect,
1393                    val_ref,
1394                    decoder,
1395                    inner_offset,
1396                    inner_depth
1397                )?;
1398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1399                {
1400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1401                }
1402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1404                }
1405            }
1406
1407            next_offset += envelope_size;
1408            _next_ordinal_to_read += 1;
1409            if next_offset >= end_offset {
1410                return Ok(());
1411            }
1412
1413            // Decode unknown envelopes for gaps in ordinals.
1414            while _next_ordinal_to_read < 5 {
1415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1416                _next_ordinal_to_read += 1;
1417                next_offset += envelope_size;
1418            }
1419
1420            let next_out_of_line = decoder.next_out_of_line();
1421            let handles_before = decoder.remaining_handles();
1422            if let Some((inlined, num_bytes, num_handles)) =
1423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1424            {
1425                let member_inline_size =
1426                    <Context as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1427                if inlined != (member_inline_size <= 4) {
1428                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1429                }
1430                let inner_offset;
1431                let mut inner_depth = depth.clone();
1432                if inlined {
1433                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1434                    inner_offset = next_offset;
1435                } else {
1436                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1437                    inner_depth.increment()?;
1438                }
1439                let val_ref = self.resolution_context.get_or_insert_with(|| {
1440                    fidl::new_empty!(Context, fdomain_client::fidl::FDomainResourceDialect)
1441                });
1442                fidl::decode!(
1443                    Context,
1444                    fdomain_client::fidl::FDomainResourceDialect,
1445                    val_ref,
1446                    decoder,
1447                    inner_offset,
1448                    inner_depth
1449                )?;
1450                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1451                {
1452                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1453                }
1454                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1455                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1456                }
1457            }
1458
1459            next_offset += envelope_size;
1460            _next_ordinal_to_read += 1;
1461            if next_offset >= end_offset {
1462                return Ok(());
1463            }
1464
1465            // Decode unknown envelopes for gaps in ordinals.
1466            while _next_ordinal_to_read < 6 {
1467                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1468                _next_ordinal_to_read += 1;
1469                next_offset += envelope_size;
1470            }
1471
1472            let next_out_of_line = decoder.next_out_of_line();
1473            let handles_before = decoder.remaining_handles();
1474            if let Some((inlined, num_bytes, num_handles)) =
1475                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1476            {
1477                let member_inline_size =
1478                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1479                if inlined != (member_inline_size <= 4) {
1480                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1481                }
1482                let inner_offset;
1483                let mut inner_depth = depth.clone();
1484                if inlined {
1485                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1486                    inner_offset = next_offset;
1487                } else {
1488                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1489                    inner_depth.increment()?;
1490                }
1491                let val_ref = self.abi_revision.get_or_insert_with(|| {
1492                    fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect)
1493                });
1494                fidl::decode!(
1495                    u64,
1496                    fdomain_client::fidl::FDomainResourceDialect,
1497                    val_ref,
1498                    decoder,
1499                    inner_offset,
1500                    inner_depth
1501                )?;
1502                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1503                {
1504                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1505                }
1506                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1507                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1508                }
1509            }
1510
1511            next_offset += envelope_size;
1512
1513            // Decode the remaining unknown envelopes.
1514            while next_offset < end_offset {
1515                _next_ordinal_to_read += 1;
1516                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1517                next_offset += envelope_size;
1518            }
1519
1520            Ok(())
1521        }
1522    }
1523
1524    impl Package {
1525        #[inline(always)]
1526        fn max_ordinal_present(&self) -> u64 {
1527            if let Some(_) = self.directory {
1528                return 2;
1529            }
1530            if let Some(_) = self.url {
1531                return 1;
1532            }
1533            0
1534        }
1535    }
1536
1537    impl fidl::encoding::ResourceTypeMarker for Package {
1538        type Borrowed<'a> = &'a mut Self;
1539        fn take_or_borrow<'a>(
1540            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1541        ) -> Self::Borrowed<'a> {
1542            value
1543        }
1544    }
1545
1546    unsafe impl fidl::encoding::TypeMarker for Package {
1547        type Owned = Self;
1548
1549        #[inline(always)]
1550        fn inline_align(_context: fidl::encoding::Context) -> usize {
1551            8
1552        }
1553
1554        #[inline(always)]
1555        fn inline_size(_context: fidl::encoding::Context) -> usize {
1556            16
1557        }
1558    }
1559
1560    unsafe impl fidl::encoding::Encode<Package, fdomain_client::fidl::FDomainResourceDialect>
1561        for &mut Package
1562    {
1563        unsafe fn encode(
1564            self,
1565            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
1566            offset: usize,
1567            mut depth: fidl::encoding::Depth,
1568        ) -> fidl::Result<()> {
1569            encoder.debug_check_bounds::<Package>(offset);
1570            // Vector header
1571            let max_ordinal: u64 = self.max_ordinal_present();
1572            encoder.write_num(max_ordinal, offset);
1573            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1574            // Calling encoder.out_of_line_offset(0) is not allowed.
1575            if max_ordinal == 0 {
1576                return Ok(());
1577            }
1578            depth.increment()?;
1579            let envelope_size = 8;
1580            let bytes_len = max_ordinal as usize * envelope_size;
1581            #[allow(unused_variables)]
1582            let offset = encoder.out_of_line_offset(bytes_len);
1583            let mut _prev_end_offset: usize = 0;
1584            if 1 > max_ordinal {
1585                return Ok(());
1586            }
1587
1588            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1589            // are envelope_size bytes.
1590            let cur_offset: usize = (1 - 1) * envelope_size;
1591
1592            // Zero reserved fields.
1593            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1594
1595            // Safety:
1596            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1597            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1598            //   envelope_size bytes, there is always sufficient room.
1599            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2083>, fdomain_client::fidl::FDomainResourceDialect>(
1600            self.url.as_ref().map(<fidl::encoding::BoundedString<2083> as fidl::encoding::ValueTypeMarker>::borrow),
1601            encoder, offset + cur_offset, depth
1602        )?;
1603
1604            _prev_end_offset = cur_offset + envelope_size;
1605            if 2 > max_ordinal {
1606                return Ok(());
1607            }
1608
1609            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1610            // are envelope_size bytes.
1611            let cur_offset: usize = (2 - 1) * envelope_size;
1612
1613            // Zero reserved fields.
1614            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1615
1616            // Safety:
1617            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1618            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1619            //   envelope_size bytes, there is always sufficient room.
1620            fidl::encoding::encode_in_envelope_optional::<
1621                fidl::encoding::Endpoint<
1622                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1623                >,
1624                fdomain_client::fidl::FDomainResourceDialect,
1625            >(
1626                self.directory.as_mut().map(
1627                    <fidl::encoding::Endpoint<
1628                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1629                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1630                ),
1631                encoder,
1632                offset + cur_offset,
1633                depth,
1634            )?;
1635
1636            _prev_end_offset = cur_offset + envelope_size;
1637
1638            Ok(())
1639        }
1640    }
1641
1642    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Package {
1643        #[inline(always)]
1644        fn new_empty() -> Self {
1645            Self::default()
1646        }
1647
1648        unsafe fn decode(
1649            &mut self,
1650            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
1651            offset: usize,
1652            mut depth: fidl::encoding::Depth,
1653        ) -> fidl::Result<()> {
1654            decoder.debug_check_bounds::<Self>(offset);
1655            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1656                None => return Err(fidl::Error::NotNullable),
1657                Some(len) => len,
1658            };
1659            // Calling decoder.out_of_line_offset(0) is not allowed.
1660            if len == 0 {
1661                return Ok(());
1662            };
1663            depth.increment()?;
1664            let envelope_size = 8;
1665            let bytes_len = len * envelope_size;
1666            let offset = decoder.out_of_line_offset(bytes_len)?;
1667            // Decode the envelope for each type.
1668            let mut _next_ordinal_to_read = 0;
1669            let mut next_offset = offset;
1670            let end_offset = offset + bytes_len;
1671            _next_ordinal_to_read += 1;
1672            if next_offset >= end_offset {
1673                return Ok(());
1674            }
1675
1676            // Decode unknown envelopes for gaps in ordinals.
1677            while _next_ordinal_to_read < 1 {
1678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1679                _next_ordinal_to_read += 1;
1680                next_offset += envelope_size;
1681            }
1682
1683            let next_out_of_line = decoder.next_out_of_line();
1684            let handles_before = decoder.remaining_handles();
1685            if let Some((inlined, num_bytes, num_handles)) =
1686                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1687            {
1688                let member_inline_size = <fidl::encoding::BoundedString<2083> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1689                if inlined != (member_inline_size <= 4) {
1690                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1691                }
1692                let inner_offset;
1693                let mut inner_depth = depth.clone();
1694                if inlined {
1695                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1696                    inner_offset = next_offset;
1697                } else {
1698                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1699                    inner_depth.increment()?;
1700                }
1701                let val_ref = self.url.get_or_insert_with(|| {
1702                    fidl::new_empty!(
1703                        fidl::encoding::BoundedString<2083>,
1704                        fdomain_client::fidl::FDomainResourceDialect
1705                    )
1706                });
1707                fidl::decode!(
1708                    fidl::encoding::BoundedString<2083>,
1709                    fdomain_client::fidl::FDomainResourceDialect,
1710                    val_ref,
1711                    decoder,
1712                    inner_offset,
1713                    inner_depth
1714                )?;
1715                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1716                {
1717                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1718                }
1719                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1720                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1721                }
1722            }
1723
1724            next_offset += envelope_size;
1725            _next_ordinal_to_read += 1;
1726            if next_offset >= end_offset {
1727                return Ok(());
1728            }
1729
1730            // Decode unknown envelopes for gaps in ordinals.
1731            while _next_ordinal_to_read < 2 {
1732                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1733                _next_ordinal_to_read += 1;
1734                next_offset += envelope_size;
1735            }
1736
1737            let next_out_of_line = decoder.next_out_of_line();
1738            let handles_before = decoder.remaining_handles();
1739            if let Some((inlined, num_bytes, num_handles)) =
1740                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1741            {
1742                let member_inline_size = <fidl::encoding::Endpoint<
1743                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1744                > as fidl::encoding::TypeMarker>::inline_size(
1745                    decoder.context
1746                );
1747                if inlined != (member_inline_size <= 4) {
1748                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1749                }
1750                let inner_offset;
1751                let mut inner_depth = depth.clone();
1752                if inlined {
1753                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1754                    inner_offset = next_offset;
1755                } else {
1756                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1757                    inner_depth.increment()?;
1758                }
1759                let val_ref = self.directory.get_or_insert_with(|| {
1760                    fidl::new_empty!(
1761                        fidl::encoding::Endpoint<
1762                            fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1763                        >,
1764                        fdomain_client::fidl::FDomainResourceDialect
1765                    )
1766                });
1767                fidl::decode!(
1768                    fidl::encoding::Endpoint<
1769                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1770                    >,
1771                    fdomain_client::fidl::FDomainResourceDialect,
1772                    val_ref,
1773                    decoder,
1774                    inner_offset,
1775                    inner_depth
1776                )?;
1777                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1778                {
1779                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1780                }
1781                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1782                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1783                }
1784            }
1785
1786            next_offset += envelope_size;
1787
1788            // Decode the remaining unknown envelopes.
1789            while next_offset < end_offset {
1790                _next_ordinal_to_read += 1;
1791                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1792                next_offset += envelope_size;
1793            }
1794
1795            Ok(())
1796        }
1797    }
1798}
fdomain_fuchsia_component_resolution/fdomain_fuchsia_component_resolution.rs

fdomain_fuchsia_component_resolution/
fdomain_fuchsia_component_resolution.rs
