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

fdomain_fuchsia_component_resolution/
fdomain_fuchsia_component_resolution.rs
