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