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

fdomain_fuchsia_component_resolution/
fdomain_fuchsia_component_resolution.rs
