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 `resolved_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 fdomain_client::fidl::ControlHandle for ResolverControlHandle {
559    fn shutdown(&self) {
560        self.inner.shutdown()
561    }
562
563    fn is_closed(&self) -> bool {
564        self.inner.channel().is_closed()
565    }
566    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
567        self.inner.channel().on_closed()
568    }
569}
570
571impl ResolverControlHandle {}
572
573#[must_use = "FIDL methods require a response to be sent"]
574#[derive(Debug)]
575pub struct ResolverResolveResponder {
576    control_handle: std::mem::ManuallyDrop<ResolverControlHandle>,
577    tx_id: u32,
578}
579
580/// Set the the channel to be shutdown (see [`ResolverControlHandle::shutdown`])
581/// if the responder is dropped without sending a response, so that the client
582/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
583impl std::ops::Drop for ResolverResolveResponder {
584    fn drop(&mut self) {
585        self.control_handle.shutdown();
586        // Safety: drops once, never accessed again
587        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
588    }
589}
590
591impl fdomain_client::fidl::Responder for ResolverResolveResponder {
592    type ControlHandle = ResolverControlHandle;
593
594    fn control_handle(&self) -> &ResolverControlHandle {
595        &self.control_handle
596    }
597
598    fn drop_without_shutdown(mut self) {
599        // Safety: drops once, never accessed again due to mem::forget
600        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
601        // Prevent Drop from running (which would shut down the channel)
602        std::mem::forget(self);
603    }
604}
605
606impl ResolverResolveResponder {
607    /// Sends a response to the FIDL transaction.
608    ///
609    /// Sets the channel to shutdown if an error occurs.
610    pub fn send(self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
611        let _result = self.send_raw(result);
612        if _result.is_err() {
613            self.control_handle.shutdown();
614        }
615        self.drop_without_shutdown();
616        _result
617    }
618
619    /// Similar to "send" but does not shutdown the channel if an error occurs.
620    pub fn send_no_shutdown_on_err(
621        self,
622        mut result: Result<Component, ResolverError>,
623    ) -> Result<(), fidl::Error> {
624        let _result = self.send_raw(result);
625        self.drop_without_shutdown();
626        _result
627    }
628
629    fn send_raw(&self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
630        self.control_handle
631            .inner
632            .send::<fidl::encoding::ResultType<ResolverResolveResponse, ResolverError>>(
633                result.as_mut().map_err(|e| *e).map(|component| (component,)),
634                self.tx_id,
635                0x57f9cfe88bf1f2e5,
636                fidl::encoding::DynamicFlags::empty(),
637            )
638    }
639}
640
641#[must_use = "FIDL methods require a response to be sent"]
642#[derive(Debug)]
643pub struct ResolverResolveWithContextResponder {
644    control_handle: std::mem::ManuallyDrop<ResolverControlHandle>,
645    tx_id: u32,
646}
647
648/// Set the the channel to be shutdown (see [`ResolverControlHandle::shutdown`])
649/// if the responder is dropped without sending a response, so that the client
650/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
651impl std::ops::Drop for ResolverResolveWithContextResponder {
652    fn drop(&mut self) {
653        self.control_handle.shutdown();
654        // Safety: drops once, never accessed again
655        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
656    }
657}
658
659impl fdomain_client::fidl::Responder for ResolverResolveWithContextResponder {
660    type ControlHandle = ResolverControlHandle;
661
662    fn control_handle(&self) -> &ResolverControlHandle {
663        &self.control_handle
664    }
665
666    fn drop_without_shutdown(mut self) {
667        // Safety: drops once, never accessed again due to mem::forget
668        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
669        // Prevent Drop from running (which would shut down the channel)
670        std::mem::forget(self);
671    }
672}
673
674impl ResolverResolveWithContextResponder {
675    /// Sends a response to the FIDL transaction.
676    ///
677    /// Sets the channel to shutdown if an error occurs.
678    pub fn send(self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
679        let _result = self.send_raw(result);
680        if _result.is_err() {
681            self.control_handle.shutdown();
682        }
683        self.drop_without_shutdown();
684        _result
685    }
686
687    /// Similar to "send" but does not shutdown the channel if an error occurs.
688    pub fn send_no_shutdown_on_err(
689        self,
690        mut result: Result<Component, ResolverError>,
691    ) -> Result<(), fidl::Error> {
692        let _result = self.send_raw(result);
693        self.drop_without_shutdown();
694        _result
695    }
696
697    fn send_raw(&self, mut result: Result<Component, ResolverError>) -> Result<(), fidl::Error> {
698        self.control_handle.inner.send::<fidl::encoding::ResultType<
699            ResolverResolveWithContextResponse,
700            ResolverError,
701        >>(
702            result.as_mut().map_err(|e| *e).map(|component| (component,)),
703            self.tx_id,
704            0x4d64b0de827070bd,
705            fidl::encoding::DynamicFlags::empty(),
706        )
707    }
708}
709
710mod internal {
711    use super::*;
712
713    impl fidl::encoding::ResourceTypeMarker for ResolverResolveWithContextResponse {
714        type Borrowed<'a> = &'a mut Self;
715        fn take_or_borrow<'a>(
716            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
717        ) -> Self::Borrowed<'a> {
718            value
719        }
720    }
721
722    unsafe impl fidl::encoding::TypeMarker for ResolverResolveWithContextResponse {
723        type Owned = Self;
724
725        #[inline(always)]
726        fn inline_align(_context: fidl::encoding::Context) -> usize {
727            8
728        }
729
730        #[inline(always)]
731        fn inline_size(_context: fidl::encoding::Context) -> usize {
732            16
733        }
734    }
735
736    unsafe impl
737        fidl::encoding::Encode<
738            ResolverResolveWithContextResponse,
739            fdomain_client::fidl::FDomainResourceDialect,
740        > for &mut ResolverResolveWithContextResponse
741    {
742        #[inline]
743        unsafe fn encode(
744            self,
745            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
746            offset: usize,
747            _depth: fidl::encoding::Depth,
748        ) -> fidl::Result<()> {
749            encoder.debug_check_bounds::<ResolverResolveWithContextResponse>(offset);
750            // Delegate to tuple encoding.
751            fidl::encoding::Encode::<
752                ResolverResolveWithContextResponse,
753                fdomain_client::fidl::FDomainResourceDialect,
754            >::encode(
755                (<Component as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
756                    &mut self.component,
757                ),),
758                encoder,
759                offset,
760                _depth,
761            )
762        }
763    }
764    unsafe impl<T0: fidl::encoding::Encode<Component, fdomain_client::fidl::FDomainResourceDialect>>
765        fidl::encoding::Encode<
766            ResolverResolveWithContextResponse,
767            fdomain_client::fidl::FDomainResourceDialect,
768        > for (T0,)
769    {
770        #[inline]
771        unsafe fn encode(
772            self,
773            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
774            offset: usize,
775            depth: fidl::encoding::Depth,
776        ) -> fidl::Result<()> {
777            encoder.debug_check_bounds::<ResolverResolveWithContextResponse>(offset);
778            // Zero out padding regions. There's no need to apply masks
779            // because the unmasked parts will be overwritten by fields.
780            // Write the fields.
781            self.0.encode(encoder, offset + 0, depth)?;
782            Ok(())
783        }
784    }
785
786    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
787        for ResolverResolveWithContextResponse
788    {
789        #[inline(always)]
790        fn new_empty() -> Self {
791            Self {
792                component: fidl::new_empty!(
793                    Component,
794                    fdomain_client::fidl::FDomainResourceDialect
795                ),
796            }
797        }
798
799        #[inline]
800        unsafe fn decode(
801            &mut self,
802            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
803            offset: usize,
804            _depth: fidl::encoding::Depth,
805        ) -> fidl::Result<()> {
806            decoder.debug_check_bounds::<Self>(offset);
807            // Verify that padding bytes are zero.
808            fidl::decode!(
809                Component,
810                fdomain_client::fidl::FDomainResourceDialect,
811                &mut self.component,
812                decoder,
813                offset + 0,
814                _depth
815            )?;
816            Ok(())
817        }
818    }
819
820    impl fidl::encoding::ResourceTypeMarker for ResolverResolveResponse {
821        type Borrowed<'a> = &'a mut Self;
822        fn take_or_borrow<'a>(
823            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
824        ) -> Self::Borrowed<'a> {
825            value
826        }
827    }
828
829    unsafe impl fidl::encoding::TypeMarker for ResolverResolveResponse {
830        type Owned = Self;
831
832        #[inline(always)]
833        fn inline_align(_context: fidl::encoding::Context) -> usize {
834            8
835        }
836
837        #[inline(always)]
838        fn inline_size(_context: fidl::encoding::Context) -> usize {
839            16
840        }
841    }
842
843    unsafe impl
844        fidl::encoding::Encode<
845            ResolverResolveResponse,
846            fdomain_client::fidl::FDomainResourceDialect,
847        > for &mut ResolverResolveResponse
848    {
849        #[inline]
850        unsafe fn encode(
851            self,
852            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
853            offset: usize,
854            _depth: fidl::encoding::Depth,
855        ) -> fidl::Result<()> {
856            encoder.debug_check_bounds::<ResolverResolveResponse>(offset);
857            // Delegate to tuple encoding.
858            fidl::encoding::Encode::<
859                ResolverResolveResponse,
860                fdomain_client::fidl::FDomainResourceDialect,
861            >::encode(
862                (<Component as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
863                    &mut self.component,
864                ),),
865                encoder,
866                offset,
867                _depth,
868            )
869        }
870    }
871    unsafe impl<T0: fidl::encoding::Encode<Component, fdomain_client::fidl::FDomainResourceDialect>>
872        fidl::encoding::Encode<
873            ResolverResolveResponse,
874            fdomain_client::fidl::FDomainResourceDialect,
875        > for (T0,)
876    {
877        #[inline]
878        unsafe fn encode(
879            self,
880            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
881            offset: usize,
882            depth: fidl::encoding::Depth,
883        ) -> fidl::Result<()> {
884            encoder.debug_check_bounds::<ResolverResolveResponse>(offset);
885            // Zero out padding regions. There's no need to apply masks
886            // because the unmasked parts will be overwritten by fields.
887            // Write the fields.
888            self.0.encode(encoder, offset + 0, depth)?;
889            Ok(())
890        }
891    }
892
893    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
894        for ResolverResolveResponse
895    {
896        #[inline(always)]
897        fn new_empty() -> Self {
898            Self {
899                component: fidl::new_empty!(
900                    Component,
901                    fdomain_client::fidl::FDomainResourceDialect
902                ),
903            }
904        }
905
906        #[inline]
907        unsafe fn decode(
908            &mut self,
909            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
910            offset: usize,
911            _depth: fidl::encoding::Depth,
912        ) -> fidl::Result<()> {
913            decoder.debug_check_bounds::<Self>(offset);
914            // Verify that padding bytes are zero.
915            fidl::decode!(
916                Component,
917                fdomain_client::fidl::FDomainResourceDialect,
918                &mut self.component,
919                decoder,
920                offset + 0,
921                _depth
922            )?;
923            Ok(())
924        }
925    }
926
927    impl Component {
928        #[inline(always)]
929        fn max_ordinal_present(&self) -> u64 {
930            if let Some(_) = self.abi_revision {
931                return 6;
932            }
933            if let Some(_) = self.resolution_context {
934                return 5;
935            }
936            if let Some(_) = self.config_values {
937                return 4;
938            }
939            if let Some(_) = self.package {
940                return 3;
941            }
942            if let Some(_) = self.decl {
943                return 2;
944            }
945            if let Some(_) = self.url {
946                return 1;
947            }
948            0
949        }
950    }
951
952    impl fidl::encoding::ResourceTypeMarker for Component {
953        type Borrowed<'a> = &'a mut Self;
954        fn take_or_borrow<'a>(
955            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
956        ) -> Self::Borrowed<'a> {
957            value
958        }
959    }
960
961    unsafe impl fidl::encoding::TypeMarker for Component {
962        type Owned = Self;
963
964        #[inline(always)]
965        fn inline_align(_context: fidl::encoding::Context) -> usize {
966            8
967        }
968
969        #[inline(always)]
970        fn inline_size(_context: fidl::encoding::Context) -> usize {
971            16
972        }
973    }
974
975    unsafe impl fidl::encoding::Encode<Component, fdomain_client::fidl::FDomainResourceDialect>
976        for &mut Component
977    {
978        unsafe fn encode(
979            self,
980            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
981            offset: usize,
982            mut depth: fidl::encoding::Depth,
983        ) -> fidl::Result<()> {
984            encoder.debug_check_bounds::<Component>(offset);
985            // Vector header
986            let max_ordinal: u64 = self.max_ordinal_present();
987            encoder.write_num(max_ordinal, offset);
988            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
989            // Calling encoder.out_of_line_offset(0) is not allowed.
990            if max_ordinal == 0 {
991                return Ok(());
992            }
993            depth.increment()?;
994            let envelope_size = 8;
995            let bytes_len = max_ordinal as usize * envelope_size;
996            #[allow(unused_variables)]
997            let offset = encoder.out_of_line_offset(bytes_len);
998            let mut _prev_end_offset: usize = 0;
999            if 1 > max_ordinal {
1000                return Ok(());
1001            }
1002
1003            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1004            // are envelope_size bytes.
1005            let cur_offset: usize = (1 - 1) * envelope_size;
1006
1007            // Zero reserved fields.
1008            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1009
1010            // Safety:
1011            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1012            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1013            //   envelope_size bytes, there is always sufficient room.
1014            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2083>, fdomain_client::fidl::FDomainResourceDialect>(
1015            self.url.as_ref().map(<fidl::encoding::BoundedString<2083> as fidl::encoding::ValueTypeMarker>::borrow),
1016            encoder, offset + cur_offset, depth
1017        )?;
1018
1019            _prev_end_offset = cur_offset + envelope_size;
1020            if 2 > max_ordinal {
1021                return Ok(());
1022            }
1023
1024            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1025            // are envelope_size bytes.
1026            let cur_offset: usize = (2 - 1) * envelope_size;
1027
1028            // Zero reserved fields.
1029            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1030
1031            // Safety:
1032            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1033            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1034            //   envelope_size bytes, there is always sufficient room.
1035            fidl::encoding::encode_in_envelope_optional::<fdomain_fuchsia_mem::Data, fdomain_client::fidl::FDomainResourceDialect>(
1036            self.decl.as_mut().map(<fdomain_fuchsia_mem::Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1037            encoder, offset + cur_offset, depth
1038        )?;
1039
1040            _prev_end_offset = cur_offset + envelope_size;
1041            if 3 > max_ordinal {
1042                return Ok(());
1043            }
1044
1045            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1046            // are envelope_size bytes.
1047            let cur_offset: usize = (3 - 1) * envelope_size;
1048
1049            // Zero reserved fields.
1050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1051
1052            // Safety:
1053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1055            //   envelope_size bytes, there is always sufficient room.
1056            fidl::encoding::encode_in_envelope_optional::<
1057                Package,
1058                fdomain_client::fidl::FDomainResourceDialect,
1059            >(
1060                self.package
1061                    .as_mut()
1062                    .map(<Package as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1063                encoder,
1064                offset + cur_offset,
1065                depth,
1066            )?;
1067
1068            _prev_end_offset = cur_offset + envelope_size;
1069            if 4 > max_ordinal {
1070                return Ok(());
1071            }
1072
1073            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1074            // are envelope_size bytes.
1075            let cur_offset: usize = (4 - 1) * envelope_size;
1076
1077            // Zero reserved fields.
1078            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1079
1080            // Safety:
1081            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1082            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1083            //   envelope_size bytes, there is always sufficient room.
1084            fidl::encoding::encode_in_envelope_optional::<fdomain_fuchsia_mem::Data, fdomain_client::fidl::FDomainResourceDialect>(
1085            self.config_values.as_mut().map(<fdomain_fuchsia_mem::Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1086            encoder, offset + cur_offset, depth
1087        )?;
1088
1089            _prev_end_offset = cur_offset + envelope_size;
1090            if 5 > max_ordinal {
1091                return Ok(());
1092            }
1093
1094            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1095            // are envelope_size bytes.
1096            let cur_offset: usize = (5 - 1) * envelope_size;
1097
1098            // Zero reserved fields.
1099            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1100
1101            // Safety:
1102            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1103            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1104            //   envelope_size bytes, there is always sufficient room.
1105            fidl::encoding::encode_in_envelope_optional::<
1106                Context,
1107                fdomain_client::fidl::FDomainResourceDialect,
1108            >(
1109                self.resolution_context
1110                    .as_ref()
1111                    .map(<Context as fidl::encoding::ValueTypeMarker>::borrow),
1112                encoder,
1113                offset + cur_offset,
1114                depth,
1115            )?;
1116
1117            _prev_end_offset = cur_offset + envelope_size;
1118            if 6 > max_ordinal {
1119                return Ok(());
1120            }
1121
1122            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1123            // are envelope_size bytes.
1124            let cur_offset: usize = (6 - 1) * envelope_size;
1125
1126            // Zero reserved fields.
1127            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1128
1129            // Safety:
1130            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1131            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1132            //   envelope_size bytes, there is always sufficient room.
1133            fidl::encoding::encode_in_envelope_optional::<
1134                u64,
1135                fdomain_client::fidl::FDomainResourceDialect,
1136            >(
1137                self.abi_revision.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1138                encoder,
1139                offset + cur_offset,
1140                depth,
1141            )?;
1142
1143            _prev_end_offset = cur_offset + envelope_size;
1144
1145            Ok(())
1146        }
1147    }
1148
1149    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Component {
1150        #[inline(always)]
1151        fn new_empty() -> Self {
1152            Self::default()
1153        }
1154
1155        unsafe fn decode(
1156            &mut self,
1157            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
1158            offset: usize,
1159            mut depth: fidl::encoding::Depth,
1160        ) -> fidl::Result<()> {
1161            decoder.debug_check_bounds::<Self>(offset);
1162            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1163                None => return Err(fidl::Error::NotNullable),
1164                Some(len) => len,
1165            };
1166            // Calling decoder.out_of_line_offset(0) is not allowed.
1167            if len == 0 {
1168                return Ok(());
1169            };
1170            depth.increment()?;
1171            let envelope_size = 8;
1172            let bytes_len = len * envelope_size;
1173            let offset = decoder.out_of_line_offset(bytes_len)?;
1174            // Decode the envelope for each type.
1175            let mut _next_ordinal_to_read = 0;
1176            let mut next_offset = offset;
1177            let end_offset = offset + bytes_len;
1178            _next_ordinal_to_read += 1;
1179            if next_offset >= end_offset {
1180                return Ok(());
1181            }
1182
1183            // Decode unknown envelopes for gaps in ordinals.
1184            while _next_ordinal_to_read < 1 {
1185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1186                _next_ordinal_to_read += 1;
1187                next_offset += envelope_size;
1188            }
1189
1190            let next_out_of_line = decoder.next_out_of_line();
1191            let handles_before = decoder.remaining_handles();
1192            if let Some((inlined, num_bytes, num_handles)) =
1193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1194            {
1195                let member_inline_size = <fidl::encoding::BoundedString<2083> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1196                if inlined != (member_inline_size <= 4) {
1197                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1198                }
1199                let inner_offset;
1200                let mut inner_depth = depth.clone();
1201                if inlined {
1202                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1203                    inner_offset = next_offset;
1204                } else {
1205                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1206                    inner_depth.increment()?;
1207                }
1208                let val_ref = self.url.get_or_insert_with(|| {
1209                    fidl::new_empty!(
1210                        fidl::encoding::BoundedString<2083>,
1211                        fdomain_client::fidl::FDomainResourceDialect
1212                    )
1213                });
1214                fidl::decode!(
1215                    fidl::encoding::BoundedString<2083>,
1216                    fdomain_client::fidl::FDomainResourceDialect,
1217                    val_ref,
1218                    decoder,
1219                    inner_offset,
1220                    inner_depth
1221                )?;
1222                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1223                {
1224                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1225                }
1226                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1227                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1228                }
1229            }
1230
1231            next_offset += envelope_size;
1232            _next_ordinal_to_read += 1;
1233            if next_offset >= end_offset {
1234                return Ok(());
1235            }
1236
1237            // Decode unknown envelopes for gaps in ordinals.
1238            while _next_ordinal_to_read < 2 {
1239                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1240                _next_ordinal_to_read += 1;
1241                next_offset += envelope_size;
1242            }
1243
1244            let next_out_of_line = decoder.next_out_of_line();
1245            let handles_before = decoder.remaining_handles();
1246            if let Some((inlined, num_bytes, num_handles)) =
1247                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1248            {
1249                let member_inline_size =
1250                    <fdomain_fuchsia_mem::Data as fidl::encoding::TypeMarker>::inline_size(
1251                        decoder.context,
1252                    );
1253                if inlined != (member_inline_size <= 4) {
1254                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1255                }
1256                let inner_offset;
1257                let mut inner_depth = depth.clone();
1258                if inlined {
1259                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1260                    inner_offset = next_offset;
1261                } else {
1262                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1263                    inner_depth.increment()?;
1264                }
1265                let val_ref = self.decl.get_or_insert_with(|| {
1266                    fidl::new_empty!(
1267                        fdomain_fuchsia_mem::Data,
1268                        fdomain_client::fidl::FDomainResourceDialect
1269                    )
1270                });
1271                fidl::decode!(
1272                    fdomain_fuchsia_mem::Data,
1273                    fdomain_client::fidl::FDomainResourceDialect,
1274                    val_ref,
1275                    decoder,
1276                    inner_offset,
1277                    inner_depth
1278                )?;
1279                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1280                {
1281                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1282                }
1283                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1284                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1285                }
1286            }
1287
1288            next_offset += envelope_size;
1289            _next_ordinal_to_read += 1;
1290            if next_offset >= end_offset {
1291                return Ok(());
1292            }
1293
1294            // Decode unknown envelopes for gaps in ordinals.
1295            while _next_ordinal_to_read < 3 {
1296                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1297                _next_ordinal_to_read += 1;
1298                next_offset += envelope_size;
1299            }
1300
1301            let next_out_of_line = decoder.next_out_of_line();
1302            let handles_before = decoder.remaining_handles();
1303            if let Some((inlined, num_bytes, num_handles)) =
1304                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1305            {
1306                let member_inline_size =
1307                    <Package as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1308                if inlined != (member_inline_size <= 4) {
1309                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1310                }
1311                let inner_offset;
1312                let mut inner_depth = depth.clone();
1313                if inlined {
1314                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1315                    inner_offset = next_offset;
1316                } else {
1317                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1318                    inner_depth.increment()?;
1319                }
1320                let val_ref = self.package.get_or_insert_with(|| {
1321                    fidl::new_empty!(Package, fdomain_client::fidl::FDomainResourceDialect)
1322                });
1323                fidl::decode!(
1324                    Package,
1325                    fdomain_client::fidl::FDomainResourceDialect,
1326                    val_ref,
1327                    decoder,
1328                    inner_offset,
1329                    inner_depth
1330                )?;
1331                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1332                {
1333                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1334                }
1335                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1336                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1337                }
1338            }
1339
1340            next_offset += envelope_size;
1341            _next_ordinal_to_read += 1;
1342            if next_offset >= end_offset {
1343                return Ok(());
1344            }
1345
1346            // Decode unknown envelopes for gaps in ordinals.
1347            while _next_ordinal_to_read < 4 {
1348                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1349                _next_ordinal_to_read += 1;
1350                next_offset += envelope_size;
1351            }
1352
1353            let next_out_of_line = decoder.next_out_of_line();
1354            let handles_before = decoder.remaining_handles();
1355            if let Some((inlined, num_bytes, num_handles)) =
1356                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1357            {
1358                let member_inline_size =
1359                    <fdomain_fuchsia_mem::Data as fidl::encoding::TypeMarker>::inline_size(
1360                        decoder.context,
1361                    );
1362                if inlined != (member_inline_size <= 4) {
1363                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1364                }
1365                let inner_offset;
1366                let mut inner_depth = depth.clone();
1367                if inlined {
1368                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1369                    inner_offset = next_offset;
1370                } else {
1371                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1372                    inner_depth.increment()?;
1373                }
1374                let val_ref = self.config_values.get_or_insert_with(|| {
1375                    fidl::new_empty!(
1376                        fdomain_fuchsia_mem::Data,
1377                        fdomain_client::fidl::FDomainResourceDialect
1378                    )
1379                });
1380                fidl::decode!(
1381                    fdomain_fuchsia_mem::Data,
1382                    fdomain_client::fidl::FDomainResourceDialect,
1383                    val_ref,
1384                    decoder,
1385                    inner_offset,
1386                    inner_depth
1387                )?;
1388                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1389                {
1390                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1391                }
1392                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1393                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1394                }
1395            }
1396
1397            next_offset += envelope_size;
1398            _next_ordinal_to_read += 1;
1399            if next_offset >= end_offset {
1400                return Ok(());
1401            }
1402
1403            // Decode unknown envelopes for gaps in ordinals.
1404            while _next_ordinal_to_read < 5 {
1405                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1406                _next_ordinal_to_read += 1;
1407                next_offset += envelope_size;
1408            }
1409
1410            let next_out_of_line = decoder.next_out_of_line();
1411            let handles_before = decoder.remaining_handles();
1412            if let Some((inlined, num_bytes, num_handles)) =
1413                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1414            {
1415                let member_inline_size =
1416                    <Context as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1417                if inlined != (member_inline_size <= 4) {
1418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1419                }
1420                let inner_offset;
1421                let mut inner_depth = depth.clone();
1422                if inlined {
1423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1424                    inner_offset = next_offset;
1425                } else {
1426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1427                    inner_depth.increment()?;
1428                }
1429                let val_ref = self.resolution_context.get_or_insert_with(|| {
1430                    fidl::new_empty!(Context, fdomain_client::fidl::FDomainResourceDialect)
1431                });
1432                fidl::decode!(
1433                    Context,
1434                    fdomain_client::fidl::FDomainResourceDialect,
1435                    val_ref,
1436                    decoder,
1437                    inner_offset,
1438                    inner_depth
1439                )?;
1440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1441                {
1442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1443                }
1444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1446                }
1447            }
1448
1449            next_offset += envelope_size;
1450            _next_ordinal_to_read += 1;
1451            if next_offset >= end_offset {
1452                return Ok(());
1453            }
1454
1455            // Decode unknown envelopes for gaps in ordinals.
1456            while _next_ordinal_to_read < 6 {
1457                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1458                _next_ordinal_to_read += 1;
1459                next_offset += envelope_size;
1460            }
1461
1462            let next_out_of_line = decoder.next_out_of_line();
1463            let handles_before = decoder.remaining_handles();
1464            if let Some((inlined, num_bytes, num_handles)) =
1465                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1466            {
1467                let member_inline_size =
1468                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1469                if inlined != (member_inline_size <= 4) {
1470                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1471                }
1472                let inner_offset;
1473                let mut inner_depth = depth.clone();
1474                if inlined {
1475                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1476                    inner_offset = next_offset;
1477                } else {
1478                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1479                    inner_depth.increment()?;
1480                }
1481                let val_ref = self.abi_revision.get_or_insert_with(|| {
1482                    fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect)
1483                });
1484                fidl::decode!(
1485                    u64,
1486                    fdomain_client::fidl::FDomainResourceDialect,
1487                    val_ref,
1488                    decoder,
1489                    inner_offset,
1490                    inner_depth
1491                )?;
1492                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1493                {
1494                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1495                }
1496                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1497                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1498                }
1499            }
1500
1501            next_offset += envelope_size;
1502
1503            // Decode the remaining unknown envelopes.
1504            while next_offset < end_offset {
1505                _next_ordinal_to_read += 1;
1506                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1507                next_offset += envelope_size;
1508            }
1509
1510            Ok(())
1511        }
1512    }
1513
1514    impl Package {
1515        #[inline(always)]
1516        fn max_ordinal_present(&self) -> u64 {
1517            if let Some(_) = self.directory {
1518                return 2;
1519            }
1520            if let Some(_) = self.url {
1521                return 1;
1522            }
1523            0
1524        }
1525    }
1526
1527    impl fidl::encoding::ResourceTypeMarker for Package {
1528        type Borrowed<'a> = &'a mut Self;
1529        fn take_or_borrow<'a>(
1530            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1531        ) -> Self::Borrowed<'a> {
1532            value
1533        }
1534    }
1535
1536    unsafe impl fidl::encoding::TypeMarker for Package {
1537        type Owned = Self;
1538
1539        #[inline(always)]
1540        fn inline_align(_context: fidl::encoding::Context) -> usize {
1541            8
1542        }
1543
1544        #[inline(always)]
1545        fn inline_size(_context: fidl::encoding::Context) -> usize {
1546            16
1547        }
1548    }
1549
1550    unsafe impl fidl::encoding::Encode<Package, fdomain_client::fidl::FDomainResourceDialect>
1551        for &mut Package
1552    {
1553        unsafe fn encode(
1554            self,
1555            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
1556            offset: usize,
1557            mut depth: fidl::encoding::Depth,
1558        ) -> fidl::Result<()> {
1559            encoder.debug_check_bounds::<Package>(offset);
1560            // Vector header
1561            let max_ordinal: u64 = self.max_ordinal_present();
1562            encoder.write_num(max_ordinal, offset);
1563            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1564            // Calling encoder.out_of_line_offset(0) is not allowed.
1565            if max_ordinal == 0 {
1566                return Ok(());
1567            }
1568            depth.increment()?;
1569            let envelope_size = 8;
1570            let bytes_len = max_ordinal as usize * envelope_size;
1571            #[allow(unused_variables)]
1572            let offset = encoder.out_of_line_offset(bytes_len);
1573            let mut _prev_end_offset: usize = 0;
1574            if 1 > max_ordinal {
1575                return Ok(());
1576            }
1577
1578            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1579            // are envelope_size bytes.
1580            let cur_offset: usize = (1 - 1) * envelope_size;
1581
1582            // Zero reserved fields.
1583            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1584
1585            // Safety:
1586            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1587            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1588            //   envelope_size bytes, there is always sufficient room.
1589            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2083>, fdomain_client::fidl::FDomainResourceDialect>(
1590            self.url.as_ref().map(<fidl::encoding::BoundedString<2083> as fidl::encoding::ValueTypeMarker>::borrow),
1591            encoder, offset + cur_offset, depth
1592        )?;
1593
1594            _prev_end_offset = cur_offset + envelope_size;
1595            if 2 > max_ordinal {
1596                return Ok(());
1597            }
1598
1599            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1600            // are envelope_size bytes.
1601            let cur_offset: usize = (2 - 1) * envelope_size;
1602
1603            // Zero reserved fields.
1604            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1605
1606            // Safety:
1607            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1608            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1609            //   envelope_size bytes, there is always sufficient room.
1610            fidl::encoding::encode_in_envelope_optional::<
1611                fidl::encoding::Endpoint<
1612                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1613                >,
1614                fdomain_client::fidl::FDomainResourceDialect,
1615            >(
1616                self.directory.as_mut().map(
1617                    <fidl::encoding::Endpoint<
1618                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1619                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1620                ),
1621                encoder,
1622                offset + cur_offset,
1623                depth,
1624            )?;
1625
1626            _prev_end_offset = cur_offset + envelope_size;
1627
1628            Ok(())
1629        }
1630    }
1631
1632    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Package {
1633        #[inline(always)]
1634        fn new_empty() -> Self {
1635            Self::default()
1636        }
1637
1638        unsafe fn decode(
1639            &mut self,
1640            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
1641            offset: usize,
1642            mut depth: fidl::encoding::Depth,
1643        ) -> fidl::Result<()> {
1644            decoder.debug_check_bounds::<Self>(offset);
1645            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1646                None => return Err(fidl::Error::NotNullable),
1647                Some(len) => len,
1648            };
1649            // Calling decoder.out_of_line_offset(0) is not allowed.
1650            if len == 0 {
1651                return Ok(());
1652            };
1653            depth.increment()?;
1654            let envelope_size = 8;
1655            let bytes_len = len * envelope_size;
1656            let offset = decoder.out_of_line_offset(bytes_len)?;
1657            // Decode the envelope for each type.
1658            let mut _next_ordinal_to_read = 0;
1659            let mut next_offset = offset;
1660            let end_offset = offset + bytes_len;
1661            _next_ordinal_to_read += 1;
1662            if next_offset >= end_offset {
1663                return Ok(());
1664            }
1665
1666            // Decode unknown envelopes for gaps in ordinals.
1667            while _next_ordinal_to_read < 1 {
1668                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1669                _next_ordinal_to_read += 1;
1670                next_offset += envelope_size;
1671            }
1672
1673            let next_out_of_line = decoder.next_out_of_line();
1674            let handles_before = decoder.remaining_handles();
1675            if let Some((inlined, num_bytes, num_handles)) =
1676                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1677            {
1678                let member_inline_size = <fidl::encoding::BoundedString<2083> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1679                if inlined != (member_inline_size <= 4) {
1680                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1681                }
1682                let inner_offset;
1683                let mut inner_depth = depth.clone();
1684                if inlined {
1685                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1686                    inner_offset = next_offset;
1687                } else {
1688                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1689                    inner_depth.increment()?;
1690                }
1691                let val_ref = self.url.get_or_insert_with(|| {
1692                    fidl::new_empty!(
1693                        fidl::encoding::BoundedString<2083>,
1694                        fdomain_client::fidl::FDomainResourceDialect
1695                    )
1696                });
1697                fidl::decode!(
1698                    fidl::encoding::BoundedString<2083>,
1699                    fdomain_client::fidl::FDomainResourceDialect,
1700                    val_ref,
1701                    decoder,
1702                    inner_offset,
1703                    inner_depth
1704                )?;
1705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1706                {
1707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1708                }
1709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1711                }
1712            }
1713
1714            next_offset += envelope_size;
1715            _next_ordinal_to_read += 1;
1716            if next_offset >= end_offset {
1717                return Ok(());
1718            }
1719
1720            // Decode unknown envelopes for gaps in ordinals.
1721            while _next_ordinal_to_read < 2 {
1722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1723                _next_ordinal_to_read += 1;
1724                next_offset += envelope_size;
1725            }
1726
1727            let next_out_of_line = decoder.next_out_of_line();
1728            let handles_before = decoder.remaining_handles();
1729            if let Some((inlined, num_bytes, num_handles)) =
1730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1731            {
1732                let member_inline_size = <fidl::encoding::Endpoint<
1733                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1734                > as fidl::encoding::TypeMarker>::inline_size(
1735                    decoder.context
1736                );
1737                if inlined != (member_inline_size <= 4) {
1738                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1739                }
1740                let inner_offset;
1741                let mut inner_depth = depth.clone();
1742                if inlined {
1743                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1744                    inner_offset = next_offset;
1745                } else {
1746                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1747                    inner_depth.increment()?;
1748                }
1749                let val_ref = self.directory.get_or_insert_with(|| {
1750                    fidl::new_empty!(
1751                        fidl::encoding::Endpoint<
1752                            fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1753                        >,
1754                        fdomain_client::fidl::FDomainResourceDialect
1755                    )
1756                });
1757                fidl::decode!(
1758                    fidl::encoding::Endpoint<
1759                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
1760                    >,
1761                    fdomain_client::fidl::FDomainResourceDialect,
1762                    val_ref,
1763                    decoder,
1764                    inner_offset,
1765                    inner_depth
1766                )?;
1767                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1768                {
1769                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1770                }
1771                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1772                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1773                }
1774            }
1775
1776            next_offset += envelope_size;
1777
1778            // Decode the remaining unknown envelopes.
1779            while next_offset < end_offset {
1780                _next_ordinal_to_read += 1;
1781                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1782                next_offset += envelope_size;
1783            }
1784
1785            Ok(())
1786        }
1787    }
1788}
fdomain_fuchsia_component_resolution/fdomain_fuchsia_component_resolution.rs

fdomain_fuchsia_component_resolution/
fdomain_fuchsia_component_resolution.rs
