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_component_runner__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ComponentControllerOnPublishDiagnosticsRequest {
16 pub payload: ComponentDiagnostics,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20 for ComponentControllerOnPublishDiagnosticsRequest
21{
22}
23
24#[derive(Debug, PartialEq)]
25pub struct ComponentRunnerStartRequest {
26 pub start_info: ComponentStartInfo,
27 pub controller: fidl::endpoints::ServerEnd<ComponentControllerMarker>,
28}
29
30impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
31 for ComponentRunnerStartRequest
32{
33}
34
35#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
36pub struct TaskProviderGetJobResponse {
37 pub job: fidl::Job,
38}
39
40impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
41 for TaskProviderGetJobResponse
42{
43}
44
45#[derive(Debug, Default, PartialEq)]
46pub struct ComponentControllerOnEscrowRequest {
47 pub outgoing_dir: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>>,
51 pub escrowed_dictionary: Option<fidl_fuchsia_component_sandbox::DictionaryRef>,
64 #[doc(hidden)]
65 pub __source_breaking: fidl::marker::SourceBreaking,
66}
67
68impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
69 for ComponentControllerOnEscrowRequest
70{
71}
72
73#[derive(Debug, Default, PartialEq)]
74pub struct ComponentDiagnostics {
75 pub tasks: Option<ComponentTasks>,
76 #[doc(hidden)]
77 pub __source_breaking: fidl::marker::SourceBreaking,
78}
79
80impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentDiagnostics {}
81
82#[derive(Debug, Default, PartialEq)]
86pub struct ComponentNamespaceEntry {
87 pub path: Option<String>,
90 pub directory: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
92 #[doc(hidden)]
93 pub __source_breaking: fidl::marker::SourceBreaking,
94}
95
96impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentNamespaceEntry {}
97
98#[derive(Debug, Default, PartialEq)]
100pub struct ComponentStartInfo {
101 pub resolved_url: Option<String>,
104 pub program: Option<fidl_fuchsia_data::Dictionary>,
107 pub ns: Option<Vec<ComponentNamespaceEntry>>,
128 pub outgoing_dir: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>>,
130 pub runtime_dir: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>>,
134 pub numbered_handles: Option<Vec<fidl_fuchsia_process::HandleInfo>>,
139 pub encoded_config: Option<fidl_fuchsia_mem::Data>,
150 pub break_on_start: Option<fidl::EventPair>,
159 pub component_instance: Option<fidl::Event>,
169 pub escrowed_dictionary: Option<fidl_fuchsia_component_sandbox::DictionaryRef>,
172 #[doc(hidden)]
173 pub __source_breaking: fidl::marker::SourceBreaking,
174}
175
176impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentStartInfo {}
177
178#[derive(Debug, Default, PartialEq)]
179pub struct ComponentStopInfo {
180 pub termination_status: Option<i32>,
185 pub exit_code: Option<i64>,
191 #[doc(hidden)]
192 pub __source_breaking: fidl::marker::SourceBreaking,
193}
194
195impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentStopInfo {}
196
197#[derive(Debug, Default, PartialEq)]
198pub struct ComponentTasks {
199 pub component_task: Option<Task>,
200 pub parent_task: Option<Task>,
201 #[doc(hidden)]
202 pub __source_breaking: fidl::marker::SourceBreaking,
203}
204
205impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentTasks {}
206
207#[derive(Debug)]
208pub enum Task {
209 Job(fidl::Job),
210 Process(fidl::Process),
211 Thread(fidl::Thread),
212 #[doc(hidden)]
213 __SourceBreaking {
214 unknown_ordinal: u64,
215 },
216}
217
218#[macro_export]
220macro_rules! TaskUnknown {
221 () => {
222 _
223 };
224}
225
226impl PartialEq for Task {
228 fn eq(&self, other: &Self) -> bool {
229 match (self, other) {
230 (Self::Job(x), Self::Job(y)) => *x == *y,
231 (Self::Process(x), Self::Process(y)) => *x == *y,
232 (Self::Thread(x), Self::Thread(y)) => *x == *y,
233 _ => false,
234 }
235 }
236}
237
238impl Task {
239 #[inline]
240 pub fn ordinal(&self) -> u64 {
241 match *self {
242 Self::Job(_) => 1,
243 Self::Process(_) => 2,
244 Self::Thread(_) => 3,
245 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
246 }
247 }
248
249 #[inline]
250 pub fn unknown_variant_for_testing() -> Self {
251 Self::__SourceBreaking { unknown_ordinal: 0 }
252 }
253
254 #[inline]
255 pub fn is_unknown(&self) -> bool {
256 match self {
257 Self::__SourceBreaking { .. } => true,
258 _ => false,
259 }
260 }
261}
262
263impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Task {}
264
265#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
266pub struct ComponentControllerMarker;
267
268impl fidl::endpoints::ProtocolMarker for ComponentControllerMarker {
269 type Proxy = ComponentControllerProxy;
270 type RequestStream = ComponentControllerRequestStream;
271 #[cfg(target_os = "fuchsia")]
272 type SynchronousProxy = ComponentControllerSynchronousProxy;
273
274 const DEBUG_NAME: &'static str = "(anonymous) ComponentController";
275}
276
277pub trait ComponentControllerProxyInterface: Send + Sync {
278 fn r#stop(&self) -> Result<(), fidl::Error>;
279 fn r#kill(&self) -> Result<(), fidl::Error>;
280}
281#[derive(Debug)]
282#[cfg(target_os = "fuchsia")]
283pub struct ComponentControllerSynchronousProxy {
284 client: fidl::client::sync::Client,
285}
286
287#[cfg(target_os = "fuchsia")]
288impl fidl::endpoints::SynchronousProxy for ComponentControllerSynchronousProxy {
289 type Proxy = ComponentControllerProxy;
290 type Protocol = ComponentControllerMarker;
291
292 fn from_channel(inner: fidl::Channel) -> Self {
293 Self::new(inner)
294 }
295
296 fn into_channel(self) -> fidl::Channel {
297 self.client.into_channel()
298 }
299
300 fn as_channel(&self) -> &fidl::Channel {
301 self.client.as_channel()
302 }
303}
304
305#[cfg(target_os = "fuchsia")]
306impl ComponentControllerSynchronousProxy {
307 pub fn new(channel: fidl::Channel) -> Self {
308 let protocol_name =
309 <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
310 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
311 }
312
313 pub fn into_channel(self) -> fidl::Channel {
314 self.client.into_channel()
315 }
316
317 pub fn wait_for_event(
320 &self,
321 deadline: zx::MonotonicInstant,
322 ) -> Result<ComponentControllerEvent, fidl::Error> {
323 ComponentControllerEvent::decode(self.client.wait_for_event(deadline)?)
324 }
325
326 pub fn r#stop(&self) -> Result<(), fidl::Error> {
333 self.client.send::<fidl::encoding::EmptyPayload>(
334 (),
335 0x42ad097fa07c1b62,
336 fidl::encoding::DynamicFlags::empty(),
337 )
338 }
339
340 pub fn r#kill(&self) -> Result<(), fidl::Error> {
350 self.client.send::<fidl::encoding::EmptyPayload>(
351 (),
352 0x3ea62e200a45aeb4,
353 fidl::encoding::DynamicFlags::empty(),
354 )
355 }
356}
357
358#[cfg(target_os = "fuchsia")]
359impl From<ComponentControllerSynchronousProxy> for zx::Handle {
360 fn from(value: ComponentControllerSynchronousProxy) -> Self {
361 value.into_channel().into()
362 }
363}
364
365#[cfg(target_os = "fuchsia")]
366impl From<fidl::Channel> for ComponentControllerSynchronousProxy {
367 fn from(value: fidl::Channel) -> Self {
368 Self::new(value)
369 }
370}
371
372#[cfg(target_os = "fuchsia")]
373impl fidl::endpoints::FromClient for ComponentControllerSynchronousProxy {
374 type Protocol = ComponentControllerMarker;
375
376 fn from_client(value: fidl::endpoints::ClientEnd<ComponentControllerMarker>) -> Self {
377 Self::new(value.into_channel())
378 }
379}
380
381#[derive(Debug, Clone)]
382pub struct ComponentControllerProxy {
383 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
384}
385
386impl fidl::endpoints::Proxy for ComponentControllerProxy {
387 type Protocol = ComponentControllerMarker;
388
389 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
390 Self::new(inner)
391 }
392
393 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
394 self.client.into_channel().map_err(|client| Self { client })
395 }
396
397 fn as_channel(&self) -> &::fidl::AsyncChannel {
398 self.client.as_channel()
399 }
400}
401
402impl ComponentControllerProxy {
403 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
405 let protocol_name =
406 <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
407 Self { client: fidl::client::Client::new(channel, protocol_name) }
408 }
409
410 pub fn take_event_stream(&self) -> ComponentControllerEventStream {
416 ComponentControllerEventStream { event_receiver: self.client.take_event_receiver() }
417 }
418
419 pub fn r#stop(&self) -> Result<(), fidl::Error> {
426 ComponentControllerProxyInterface::r#stop(self)
427 }
428
429 pub fn r#kill(&self) -> Result<(), fidl::Error> {
439 ComponentControllerProxyInterface::r#kill(self)
440 }
441}
442
443impl ComponentControllerProxyInterface for ComponentControllerProxy {
444 fn r#stop(&self) -> Result<(), fidl::Error> {
445 self.client.send::<fidl::encoding::EmptyPayload>(
446 (),
447 0x42ad097fa07c1b62,
448 fidl::encoding::DynamicFlags::empty(),
449 )
450 }
451
452 fn r#kill(&self) -> Result<(), fidl::Error> {
453 self.client.send::<fidl::encoding::EmptyPayload>(
454 (),
455 0x3ea62e200a45aeb4,
456 fidl::encoding::DynamicFlags::empty(),
457 )
458 }
459}
460
461pub struct ComponentControllerEventStream {
462 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
463}
464
465impl std::marker::Unpin for ComponentControllerEventStream {}
466
467impl futures::stream::FusedStream for ComponentControllerEventStream {
468 fn is_terminated(&self) -> bool {
469 self.event_receiver.is_terminated()
470 }
471}
472
473impl futures::Stream for ComponentControllerEventStream {
474 type Item = Result<ComponentControllerEvent, fidl::Error>;
475
476 fn poll_next(
477 mut self: std::pin::Pin<&mut Self>,
478 cx: &mut std::task::Context<'_>,
479 ) -> std::task::Poll<Option<Self::Item>> {
480 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
481 &mut self.event_receiver,
482 cx
483 )?) {
484 Some(buf) => std::task::Poll::Ready(Some(ComponentControllerEvent::decode(buf))),
485 None => std::task::Poll::Ready(None),
486 }
487 }
488}
489
490#[derive(Debug)]
491pub enum ComponentControllerEvent {
492 OnPublishDiagnostics {
493 payload: ComponentDiagnostics,
494 },
495 OnEscrow {
496 payload: ComponentControllerOnEscrowRequest,
497 },
498 OnStop {
499 payload: ComponentStopInfo,
500 },
501 #[non_exhaustive]
502 _UnknownEvent {
503 ordinal: u64,
505 },
506}
507
508impl ComponentControllerEvent {
509 #[allow(irrefutable_let_patterns)]
510 pub fn into_on_publish_diagnostics(self) -> Option<ComponentDiagnostics> {
511 if let ComponentControllerEvent::OnPublishDiagnostics { payload } = self {
512 Some((payload))
513 } else {
514 None
515 }
516 }
517 #[allow(irrefutable_let_patterns)]
518 pub fn into_on_escrow(self) -> Option<ComponentControllerOnEscrowRequest> {
519 if let ComponentControllerEvent::OnEscrow { payload } = self {
520 Some((payload))
521 } else {
522 None
523 }
524 }
525 #[allow(irrefutable_let_patterns)]
526 pub fn into_on_stop(self) -> Option<ComponentStopInfo> {
527 if let ComponentControllerEvent::OnStop { payload } = self {
528 Some((payload))
529 } else {
530 None
531 }
532 }
533
534 fn decode(
536 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
537 ) -> Result<ComponentControllerEvent, fidl::Error> {
538 let (bytes, _handles) = buf.split_mut();
539 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
540 debug_assert_eq!(tx_header.tx_id, 0);
541 match tx_header.ordinal {
542 0x1f16d8c3c49c6947 => {
543 let mut out = fidl::new_empty!(
544 ComponentControllerOnPublishDiagnosticsRequest,
545 fidl::encoding::DefaultFuchsiaResourceDialect
546 );
547 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ComponentControllerOnPublishDiagnosticsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
548 Ok((ComponentControllerEvent::OnPublishDiagnostics { payload: out.payload }))
549 }
550 0xa231349355343fc => {
551 let mut out = fidl::new_empty!(
552 ComponentControllerOnEscrowRequest,
553 fidl::encoding::DefaultFuchsiaResourceDialect
554 );
555 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ComponentControllerOnEscrowRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
556 Ok((ComponentControllerEvent::OnEscrow { payload: out }))
557 }
558 0x3bfd24b031878ab2 => {
559 let mut out = fidl::new_empty!(
560 ComponentStopInfo,
561 fidl::encoding::DefaultFuchsiaResourceDialect
562 );
563 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ComponentStopInfo>(&tx_header, _body_bytes, _handles, &mut out)?;
564 Ok((ComponentControllerEvent::OnStop { payload: out }))
565 }
566 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
567 Ok(ComponentControllerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
568 }
569 _ => Err(fidl::Error::UnknownOrdinal {
570 ordinal: tx_header.ordinal,
571 protocol_name:
572 <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
573 }),
574 }
575 }
576}
577
578pub struct ComponentControllerRequestStream {
580 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
581 is_terminated: bool,
582}
583
584impl std::marker::Unpin for ComponentControllerRequestStream {}
585
586impl futures::stream::FusedStream for ComponentControllerRequestStream {
587 fn is_terminated(&self) -> bool {
588 self.is_terminated
589 }
590}
591
592impl fidl::endpoints::RequestStream for ComponentControllerRequestStream {
593 type Protocol = ComponentControllerMarker;
594 type ControlHandle = ComponentControllerControlHandle;
595
596 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
597 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
598 }
599
600 fn control_handle(&self) -> Self::ControlHandle {
601 ComponentControllerControlHandle { inner: self.inner.clone() }
602 }
603
604 fn into_inner(
605 self,
606 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
607 {
608 (self.inner, self.is_terminated)
609 }
610
611 fn from_inner(
612 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
613 is_terminated: bool,
614 ) -> Self {
615 Self { inner, is_terminated }
616 }
617}
618
619impl futures::Stream for ComponentControllerRequestStream {
620 type Item = Result<ComponentControllerRequest, fidl::Error>;
621
622 fn poll_next(
623 mut self: std::pin::Pin<&mut Self>,
624 cx: &mut std::task::Context<'_>,
625 ) -> std::task::Poll<Option<Self::Item>> {
626 let this = &mut *self;
627 if this.inner.check_shutdown(cx) {
628 this.is_terminated = true;
629 return std::task::Poll::Ready(None);
630 }
631 if this.is_terminated {
632 panic!("polled ComponentControllerRequestStream after completion");
633 }
634 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
635 |bytes, handles| {
636 match this.inner.channel().read_etc(cx, bytes, handles) {
637 std::task::Poll::Ready(Ok(())) => {}
638 std::task::Poll::Pending => return std::task::Poll::Pending,
639 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
640 this.is_terminated = true;
641 return std::task::Poll::Ready(None);
642 }
643 std::task::Poll::Ready(Err(e)) => {
644 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
645 e.into(),
646 ))))
647 }
648 }
649
650 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
652
653 std::task::Poll::Ready(Some(match header.ordinal {
654 0x42ad097fa07c1b62 => {
655 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
656 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
657 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
658 let control_handle = ComponentControllerControlHandle {
659 inner: this.inner.clone(),
660 };
661 Ok(ComponentControllerRequest::Stop {
662 control_handle,
663 })
664 }
665 0x3ea62e200a45aeb4 => {
666 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
667 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
668 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
669 let control_handle = ComponentControllerControlHandle {
670 inner: this.inner.clone(),
671 };
672 Ok(ComponentControllerRequest::Kill {
673 control_handle,
674 })
675 }
676 _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
677 Ok(ComponentControllerRequest::_UnknownMethod {
678 ordinal: header.ordinal,
679 control_handle: ComponentControllerControlHandle { inner: this.inner.clone() },
680 method_type: fidl::MethodType::OneWay,
681 })
682 }
683 _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
684 this.inner.send_framework_err(
685 fidl::encoding::FrameworkErr::UnknownMethod,
686 header.tx_id,
687 header.ordinal,
688 header.dynamic_flags(),
689 (bytes, handles),
690 )?;
691 Ok(ComponentControllerRequest::_UnknownMethod {
692 ordinal: header.ordinal,
693 control_handle: ComponentControllerControlHandle { inner: this.inner.clone() },
694 method_type: fidl::MethodType::TwoWay,
695 })
696 }
697 _ => Err(fidl::Error::UnknownOrdinal {
698 ordinal: header.ordinal,
699 protocol_name: <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
700 }),
701 }))
702 },
703 )
704 }
705}
706
707#[derive(Debug)]
786pub enum ComponentControllerRequest {
787 Stop { control_handle: ComponentControllerControlHandle },
794 Kill { control_handle: ComponentControllerControlHandle },
804 #[non_exhaustive]
806 _UnknownMethod {
807 ordinal: u64,
809 control_handle: ComponentControllerControlHandle,
810 method_type: fidl::MethodType,
811 },
812}
813
814impl ComponentControllerRequest {
815 #[allow(irrefutable_let_patterns)]
816 pub fn into_stop(self) -> Option<(ComponentControllerControlHandle)> {
817 if let ComponentControllerRequest::Stop { control_handle } = self {
818 Some((control_handle))
819 } else {
820 None
821 }
822 }
823
824 #[allow(irrefutable_let_patterns)]
825 pub fn into_kill(self) -> Option<(ComponentControllerControlHandle)> {
826 if let ComponentControllerRequest::Kill { control_handle } = self {
827 Some((control_handle))
828 } else {
829 None
830 }
831 }
832
833 pub fn method_name(&self) -> &'static str {
835 match *self {
836 ComponentControllerRequest::Stop { .. } => "stop",
837 ComponentControllerRequest::Kill { .. } => "kill",
838 ComponentControllerRequest::_UnknownMethod {
839 method_type: fidl::MethodType::OneWay,
840 ..
841 } => "unknown one-way method",
842 ComponentControllerRequest::_UnknownMethod {
843 method_type: fidl::MethodType::TwoWay,
844 ..
845 } => "unknown two-way method",
846 }
847 }
848}
849
850#[derive(Debug, Clone)]
851pub struct ComponentControllerControlHandle {
852 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
853}
854
855impl fidl::endpoints::ControlHandle for ComponentControllerControlHandle {
856 fn shutdown(&self) {
857 self.inner.shutdown()
858 }
859 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
860 self.inner.shutdown_with_epitaph(status)
861 }
862
863 fn is_closed(&self) -> bool {
864 self.inner.channel().is_closed()
865 }
866 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
867 self.inner.channel().on_closed()
868 }
869
870 #[cfg(target_os = "fuchsia")]
871 fn signal_peer(
872 &self,
873 clear_mask: zx::Signals,
874 set_mask: zx::Signals,
875 ) -> Result<(), zx_status::Status> {
876 use fidl::Peered;
877 self.inner.channel().signal_peer(clear_mask, set_mask)
878 }
879}
880
881impl ComponentControllerControlHandle {
882 pub fn send_on_publish_diagnostics(
883 &self,
884 mut payload: ComponentDiagnostics,
885 ) -> Result<(), fidl::Error> {
886 self.inner.send::<ComponentControllerOnPublishDiagnosticsRequest>(
887 (&mut payload,),
888 0,
889 0x1f16d8c3c49c6947,
890 fidl::encoding::DynamicFlags::empty(),
891 )
892 }
893
894 pub fn send_on_escrow(
895 &self,
896 mut payload: ComponentControllerOnEscrowRequest,
897 ) -> Result<(), fidl::Error> {
898 self.inner.send::<ComponentControllerOnEscrowRequest>(
899 &mut payload,
900 0,
901 0xa231349355343fc,
902 fidl::encoding::DynamicFlags::FLEXIBLE,
903 )
904 }
905
906 pub fn send_on_stop(&self, mut payload: ComponentStopInfo) -> Result<(), fidl::Error> {
907 self.inner.send::<ComponentStopInfo>(
908 &mut payload,
909 0,
910 0x3bfd24b031878ab2,
911 fidl::encoding::DynamicFlags::FLEXIBLE,
912 )
913 }
914}
915
916#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
917pub struct ComponentRunnerMarker;
918
919impl fidl::endpoints::ProtocolMarker for ComponentRunnerMarker {
920 type Proxy = ComponentRunnerProxy;
921 type RequestStream = ComponentRunnerRequestStream;
922 #[cfg(target_os = "fuchsia")]
923 type SynchronousProxy = ComponentRunnerSynchronousProxy;
924
925 const DEBUG_NAME: &'static str = "fuchsia.component.runner.ComponentRunner";
926}
927impl fidl::endpoints::DiscoverableProtocolMarker for ComponentRunnerMarker {}
928
929pub trait ComponentRunnerProxyInterface: Send + Sync {
930 fn r#start(
931 &self,
932 start_info: ComponentStartInfo,
933 controller: fidl::endpoints::ServerEnd<ComponentControllerMarker>,
934 ) -> Result<(), fidl::Error>;
935}
936#[derive(Debug)]
937#[cfg(target_os = "fuchsia")]
938pub struct ComponentRunnerSynchronousProxy {
939 client: fidl::client::sync::Client,
940}
941
942#[cfg(target_os = "fuchsia")]
943impl fidl::endpoints::SynchronousProxy for ComponentRunnerSynchronousProxy {
944 type Proxy = ComponentRunnerProxy;
945 type Protocol = ComponentRunnerMarker;
946
947 fn from_channel(inner: fidl::Channel) -> Self {
948 Self::new(inner)
949 }
950
951 fn into_channel(self) -> fidl::Channel {
952 self.client.into_channel()
953 }
954
955 fn as_channel(&self) -> &fidl::Channel {
956 self.client.as_channel()
957 }
958}
959
960#[cfg(target_os = "fuchsia")]
961impl ComponentRunnerSynchronousProxy {
962 pub fn new(channel: fidl::Channel) -> Self {
963 let protocol_name = <ComponentRunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
964 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
965 }
966
967 pub fn into_channel(self) -> fidl::Channel {
968 self.client.into_channel()
969 }
970
971 pub fn wait_for_event(
974 &self,
975 deadline: zx::MonotonicInstant,
976 ) -> Result<ComponentRunnerEvent, fidl::Error> {
977 ComponentRunnerEvent::decode(self.client.wait_for_event(deadline)?)
978 }
979
980 pub fn r#start(
989 &self,
990 mut start_info: ComponentStartInfo,
991 mut controller: fidl::endpoints::ServerEnd<ComponentControllerMarker>,
992 ) -> Result<(), fidl::Error> {
993 self.client.send::<ComponentRunnerStartRequest>(
994 (&mut start_info, controller),
995 0xad5a8c19f25ee09,
996 fidl::encoding::DynamicFlags::empty(),
997 )
998 }
999}
1000
1001#[cfg(target_os = "fuchsia")]
1002impl From<ComponentRunnerSynchronousProxy> for zx::Handle {
1003 fn from(value: ComponentRunnerSynchronousProxy) -> Self {
1004 value.into_channel().into()
1005 }
1006}
1007
1008#[cfg(target_os = "fuchsia")]
1009impl From<fidl::Channel> for ComponentRunnerSynchronousProxy {
1010 fn from(value: fidl::Channel) -> Self {
1011 Self::new(value)
1012 }
1013}
1014
1015#[cfg(target_os = "fuchsia")]
1016impl fidl::endpoints::FromClient for ComponentRunnerSynchronousProxy {
1017 type Protocol = ComponentRunnerMarker;
1018
1019 fn from_client(value: fidl::endpoints::ClientEnd<ComponentRunnerMarker>) -> Self {
1020 Self::new(value.into_channel())
1021 }
1022}
1023
1024#[derive(Debug, Clone)]
1025pub struct ComponentRunnerProxy {
1026 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1027}
1028
1029impl fidl::endpoints::Proxy for ComponentRunnerProxy {
1030 type Protocol = ComponentRunnerMarker;
1031
1032 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1033 Self::new(inner)
1034 }
1035
1036 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1037 self.client.into_channel().map_err(|client| Self { client })
1038 }
1039
1040 fn as_channel(&self) -> &::fidl::AsyncChannel {
1041 self.client.as_channel()
1042 }
1043}
1044
1045impl ComponentRunnerProxy {
1046 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1048 let protocol_name = <ComponentRunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1049 Self { client: fidl::client::Client::new(channel, protocol_name) }
1050 }
1051
1052 pub fn take_event_stream(&self) -> ComponentRunnerEventStream {
1058 ComponentRunnerEventStream { event_receiver: self.client.take_event_receiver() }
1059 }
1060
1061 pub fn r#start(
1070 &self,
1071 mut start_info: ComponentStartInfo,
1072 mut controller: fidl::endpoints::ServerEnd<ComponentControllerMarker>,
1073 ) -> Result<(), fidl::Error> {
1074 ComponentRunnerProxyInterface::r#start(self, start_info, controller)
1075 }
1076}
1077
1078impl ComponentRunnerProxyInterface for ComponentRunnerProxy {
1079 fn r#start(
1080 &self,
1081 mut start_info: ComponentStartInfo,
1082 mut controller: fidl::endpoints::ServerEnd<ComponentControllerMarker>,
1083 ) -> Result<(), fidl::Error> {
1084 self.client.send::<ComponentRunnerStartRequest>(
1085 (&mut start_info, controller),
1086 0xad5a8c19f25ee09,
1087 fidl::encoding::DynamicFlags::empty(),
1088 )
1089 }
1090}
1091
1092pub struct ComponentRunnerEventStream {
1093 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1094}
1095
1096impl std::marker::Unpin for ComponentRunnerEventStream {}
1097
1098impl futures::stream::FusedStream for ComponentRunnerEventStream {
1099 fn is_terminated(&self) -> bool {
1100 self.event_receiver.is_terminated()
1101 }
1102}
1103
1104impl futures::Stream for ComponentRunnerEventStream {
1105 type Item = Result<ComponentRunnerEvent, fidl::Error>;
1106
1107 fn poll_next(
1108 mut self: std::pin::Pin<&mut Self>,
1109 cx: &mut std::task::Context<'_>,
1110 ) -> std::task::Poll<Option<Self::Item>> {
1111 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1112 &mut self.event_receiver,
1113 cx
1114 )?) {
1115 Some(buf) => std::task::Poll::Ready(Some(ComponentRunnerEvent::decode(buf))),
1116 None => std::task::Poll::Ready(None),
1117 }
1118 }
1119}
1120
1121#[derive(Debug)]
1122pub enum ComponentRunnerEvent {
1123 #[non_exhaustive]
1124 _UnknownEvent {
1125 ordinal: u64,
1127 },
1128}
1129
1130impl ComponentRunnerEvent {
1131 fn decode(
1133 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1134 ) -> Result<ComponentRunnerEvent, fidl::Error> {
1135 let (bytes, _handles) = buf.split_mut();
1136 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1137 debug_assert_eq!(tx_header.tx_id, 0);
1138 match tx_header.ordinal {
1139 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
1140 Ok(ComponentRunnerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
1141 }
1142 _ => Err(fidl::Error::UnknownOrdinal {
1143 ordinal: tx_header.ordinal,
1144 protocol_name:
1145 <ComponentRunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1146 }),
1147 }
1148 }
1149}
1150
1151pub struct ComponentRunnerRequestStream {
1153 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1154 is_terminated: bool,
1155}
1156
1157impl std::marker::Unpin for ComponentRunnerRequestStream {}
1158
1159impl futures::stream::FusedStream for ComponentRunnerRequestStream {
1160 fn is_terminated(&self) -> bool {
1161 self.is_terminated
1162 }
1163}
1164
1165impl fidl::endpoints::RequestStream for ComponentRunnerRequestStream {
1166 type Protocol = ComponentRunnerMarker;
1167 type ControlHandle = ComponentRunnerControlHandle;
1168
1169 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1170 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1171 }
1172
1173 fn control_handle(&self) -> Self::ControlHandle {
1174 ComponentRunnerControlHandle { inner: self.inner.clone() }
1175 }
1176
1177 fn into_inner(
1178 self,
1179 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1180 {
1181 (self.inner, self.is_terminated)
1182 }
1183
1184 fn from_inner(
1185 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1186 is_terminated: bool,
1187 ) -> Self {
1188 Self { inner, is_terminated }
1189 }
1190}
1191
1192impl futures::Stream for ComponentRunnerRequestStream {
1193 type Item = Result<ComponentRunnerRequest, fidl::Error>;
1194
1195 fn poll_next(
1196 mut self: std::pin::Pin<&mut Self>,
1197 cx: &mut std::task::Context<'_>,
1198 ) -> std::task::Poll<Option<Self::Item>> {
1199 let this = &mut *self;
1200 if this.inner.check_shutdown(cx) {
1201 this.is_terminated = true;
1202 return std::task::Poll::Ready(None);
1203 }
1204 if this.is_terminated {
1205 panic!("polled ComponentRunnerRequestStream after completion");
1206 }
1207 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1208 |bytes, handles| {
1209 match this.inner.channel().read_etc(cx, bytes, handles) {
1210 std::task::Poll::Ready(Ok(())) => {}
1211 std::task::Poll::Pending => return std::task::Poll::Pending,
1212 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1213 this.is_terminated = true;
1214 return std::task::Poll::Ready(None);
1215 }
1216 std::task::Poll::Ready(Err(e)) => {
1217 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1218 e.into(),
1219 ))))
1220 }
1221 }
1222
1223 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1225
1226 std::task::Poll::Ready(Some(match header.ordinal {
1227 0xad5a8c19f25ee09 => {
1228 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1229 let mut req = fidl::new_empty!(
1230 ComponentRunnerStartRequest,
1231 fidl::encoding::DefaultFuchsiaResourceDialect
1232 );
1233 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ComponentRunnerStartRequest>(&header, _body_bytes, handles, &mut req)?;
1234 let control_handle =
1235 ComponentRunnerControlHandle { inner: this.inner.clone() };
1236 Ok(ComponentRunnerRequest::Start {
1237 start_info: req.start_info,
1238 controller: req.controller,
1239
1240 control_handle,
1241 })
1242 }
1243 _ if header.tx_id == 0
1244 && header
1245 .dynamic_flags()
1246 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1247 {
1248 Ok(ComponentRunnerRequest::_UnknownMethod {
1249 ordinal: header.ordinal,
1250 control_handle: ComponentRunnerControlHandle {
1251 inner: this.inner.clone(),
1252 },
1253 method_type: fidl::MethodType::OneWay,
1254 })
1255 }
1256 _ if header
1257 .dynamic_flags()
1258 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1259 {
1260 this.inner.send_framework_err(
1261 fidl::encoding::FrameworkErr::UnknownMethod,
1262 header.tx_id,
1263 header.ordinal,
1264 header.dynamic_flags(),
1265 (bytes, handles),
1266 )?;
1267 Ok(ComponentRunnerRequest::_UnknownMethod {
1268 ordinal: header.ordinal,
1269 control_handle: ComponentRunnerControlHandle {
1270 inner: this.inner.clone(),
1271 },
1272 method_type: fidl::MethodType::TwoWay,
1273 })
1274 }
1275 _ => Err(fidl::Error::UnknownOrdinal {
1276 ordinal: header.ordinal,
1277 protocol_name:
1278 <ComponentRunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1279 }),
1280 }))
1281 },
1282 )
1283 }
1284}
1285
1286#[derive(Debug)]
1294pub enum ComponentRunnerRequest {
1295 Start {
1304 start_info: ComponentStartInfo,
1305 controller: fidl::endpoints::ServerEnd<ComponentControllerMarker>,
1306 control_handle: ComponentRunnerControlHandle,
1307 },
1308 #[non_exhaustive]
1310 _UnknownMethod {
1311 ordinal: u64,
1313 control_handle: ComponentRunnerControlHandle,
1314 method_type: fidl::MethodType,
1315 },
1316}
1317
1318impl ComponentRunnerRequest {
1319 #[allow(irrefutable_let_patterns)]
1320 pub fn into_start(
1321 self,
1322 ) -> Option<(
1323 ComponentStartInfo,
1324 fidl::endpoints::ServerEnd<ComponentControllerMarker>,
1325 ComponentRunnerControlHandle,
1326 )> {
1327 if let ComponentRunnerRequest::Start { start_info, controller, control_handle } = self {
1328 Some((start_info, controller, control_handle))
1329 } else {
1330 None
1331 }
1332 }
1333
1334 pub fn method_name(&self) -> &'static str {
1336 match *self {
1337 ComponentRunnerRequest::Start { .. } => "start",
1338 ComponentRunnerRequest::_UnknownMethod {
1339 method_type: fidl::MethodType::OneWay,
1340 ..
1341 } => "unknown one-way method",
1342 ComponentRunnerRequest::_UnknownMethod {
1343 method_type: fidl::MethodType::TwoWay,
1344 ..
1345 } => "unknown two-way method",
1346 }
1347 }
1348}
1349
1350#[derive(Debug, Clone)]
1351pub struct ComponentRunnerControlHandle {
1352 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1353}
1354
1355impl fidl::endpoints::ControlHandle for ComponentRunnerControlHandle {
1356 fn shutdown(&self) {
1357 self.inner.shutdown()
1358 }
1359 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1360 self.inner.shutdown_with_epitaph(status)
1361 }
1362
1363 fn is_closed(&self) -> bool {
1364 self.inner.channel().is_closed()
1365 }
1366 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1367 self.inner.channel().on_closed()
1368 }
1369
1370 #[cfg(target_os = "fuchsia")]
1371 fn signal_peer(
1372 &self,
1373 clear_mask: zx::Signals,
1374 set_mask: zx::Signals,
1375 ) -> Result<(), zx_status::Status> {
1376 use fidl::Peered;
1377 self.inner.channel().signal_peer(clear_mask, set_mask)
1378 }
1379}
1380
1381impl ComponentRunnerControlHandle {}
1382
1383#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1384pub struct TaskProviderMarker;
1385
1386impl fidl::endpoints::ProtocolMarker for TaskProviderMarker {
1387 type Proxy = TaskProviderProxy;
1388 type RequestStream = TaskProviderRequestStream;
1389 #[cfg(target_os = "fuchsia")]
1390 type SynchronousProxy = TaskProviderSynchronousProxy;
1391
1392 const DEBUG_NAME: &'static str = "fuchsia.component.runner.TaskProvider";
1393}
1394impl fidl::endpoints::DiscoverableProtocolMarker for TaskProviderMarker {}
1395pub type TaskProviderGetJobResult = Result<fidl::Job, i32>;
1396
1397pub trait TaskProviderProxyInterface: Send + Sync {
1398 type GetJobResponseFut: std::future::Future<Output = Result<TaskProviderGetJobResult, fidl::Error>>
1399 + Send;
1400 fn r#get_job(&self) -> Self::GetJobResponseFut;
1401}
1402#[derive(Debug)]
1403#[cfg(target_os = "fuchsia")]
1404pub struct TaskProviderSynchronousProxy {
1405 client: fidl::client::sync::Client,
1406}
1407
1408#[cfg(target_os = "fuchsia")]
1409impl fidl::endpoints::SynchronousProxy for TaskProviderSynchronousProxy {
1410 type Proxy = TaskProviderProxy;
1411 type Protocol = TaskProviderMarker;
1412
1413 fn from_channel(inner: fidl::Channel) -> Self {
1414 Self::new(inner)
1415 }
1416
1417 fn into_channel(self) -> fidl::Channel {
1418 self.client.into_channel()
1419 }
1420
1421 fn as_channel(&self) -> &fidl::Channel {
1422 self.client.as_channel()
1423 }
1424}
1425
1426#[cfg(target_os = "fuchsia")]
1427impl TaskProviderSynchronousProxy {
1428 pub fn new(channel: fidl::Channel) -> Self {
1429 let protocol_name = <TaskProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1430 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1431 }
1432
1433 pub fn into_channel(self) -> fidl::Channel {
1434 self.client.into_channel()
1435 }
1436
1437 pub fn wait_for_event(
1440 &self,
1441 deadline: zx::MonotonicInstant,
1442 ) -> Result<TaskProviderEvent, fidl::Error> {
1443 TaskProviderEvent::decode(self.client.wait_for_event(deadline)?)
1444 }
1445
1446 pub fn r#get_job(
1450 &self,
1451 ___deadline: zx::MonotonicInstant,
1452 ) -> Result<TaskProviderGetJobResult, fidl::Error> {
1453 let _response = self.client.send_query::<
1454 fidl::encoding::EmptyPayload,
1455 fidl::encoding::ResultType<TaskProviderGetJobResponse, i32>,
1456 >(
1457 (),
1458 0x4c9ca4f4fdece3ad,
1459 fidl::encoding::DynamicFlags::empty(),
1460 ___deadline,
1461 )?;
1462 Ok(_response.map(|x| x.job))
1463 }
1464}
1465
1466#[cfg(target_os = "fuchsia")]
1467impl From<TaskProviderSynchronousProxy> for zx::Handle {
1468 fn from(value: TaskProviderSynchronousProxy) -> Self {
1469 value.into_channel().into()
1470 }
1471}
1472
1473#[cfg(target_os = "fuchsia")]
1474impl From<fidl::Channel> for TaskProviderSynchronousProxy {
1475 fn from(value: fidl::Channel) -> Self {
1476 Self::new(value)
1477 }
1478}
1479
1480#[cfg(target_os = "fuchsia")]
1481impl fidl::endpoints::FromClient for TaskProviderSynchronousProxy {
1482 type Protocol = TaskProviderMarker;
1483
1484 fn from_client(value: fidl::endpoints::ClientEnd<TaskProviderMarker>) -> Self {
1485 Self::new(value.into_channel())
1486 }
1487}
1488
1489#[derive(Debug, Clone)]
1490pub struct TaskProviderProxy {
1491 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1492}
1493
1494impl fidl::endpoints::Proxy for TaskProviderProxy {
1495 type Protocol = TaskProviderMarker;
1496
1497 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1498 Self::new(inner)
1499 }
1500
1501 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1502 self.client.into_channel().map_err(|client| Self { client })
1503 }
1504
1505 fn as_channel(&self) -> &::fidl::AsyncChannel {
1506 self.client.as_channel()
1507 }
1508}
1509
1510impl TaskProviderProxy {
1511 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1513 let protocol_name = <TaskProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1514 Self { client: fidl::client::Client::new(channel, protocol_name) }
1515 }
1516
1517 pub fn take_event_stream(&self) -> TaskProviderEventStream {
1523 TaskProviderEventStream { event_receiver: self.client.take_event_receiver() }
1524 }
1525
1526 pub fn r#get_job(
1530 &self,
1531 ) -> fidl::client::QueryResponseFut<
1532 TaskProviderGetJobResult,
1533 fidl::encoding::DefaultFuchsiaResourceDialect,
1534 > {
1535 TaskProviderProxyInterface::r#get_job(self)
1536 }
1537}
1538
1539impl TaskProviderProxyInterface for TaskProviderProxy {
1540 type GetJobResponseFut = fidl::client::QueryResponseFut<
1541 TaskProviderGetJobResult,
1542 fidl::encoding::DefaultFuchsiaResourceDialect,
1543 >;
1544 fn r#get_job(&self) -> Self::GetJobResponseFut {
1545 fn _decode(
1546 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1547 ) -> Result<TaskProviderGetJobResult, fidl::Error> {
1548 let _response = fidl::client::decode_transaction_body::<
1549 fidl::encoding::ResultType<TaskProviderGetJobResponse, i32>,
1550 fidl::encoding::DefaultFuchsiaResourceDialect,
1551 0x4c9ca4f4fdece3ad,
1552 >(_buf?)?;
1553 Ok(_response.map(|x| x.job))
1554 }
1555 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, TaskProviderGetJobResult>(
1556 (),
1557 0x4c9ca4f4fdece3ad,
1558 fidl::encoding::DynamicFlags::empty(),
1559 _decode,
1560 )
1561 }
1562}
1563
1564pub struct TaskProviderEventStream {
1565 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1566}
1567
1568impl std::marker::Unpin for TaskProviderEventStream {}
1569
1570impl futures::stream::FusedStream for TaskProviderEventStream {
1571 fn is_terminated(&self) -> bool {
1572 self.event_receiver.is_terminated()
1573 }
1574}
1575
1576impl futures::Stream for TaskProviderEventStream {
1577 type Item = Result<TaskProviderEvent, fidl::Error>;
1578
1579 fn poll_next(
1580 mut self: std::pin::Pin<&mut Self>,
1581 cx: &mut std::task::Context<'_>,
1582 ) -> std::task::Poll<Option<Self::Item>> {
1583 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1584 &mut self.event_receiver,
1585 cx
1586 )?) {
1587 Some(buf) => std::task::Poll::Ready(Some(TaskProviderEvent::decode(buf))),
1588 None => std::task::Poll::Ready(None),
1589 }
1590 }
1591}
1592
1593#[derive(Debug)]
1594pub enum TaskProviderEvent {
1595 #[non_exhaustive]
1596 _UnknownEvent {
1597 ordinal: u64,
1599 },
1600}
1601
1602impl TaskProviderEvent {
1603 fn decode(
1605 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1606 ) -> Result<TaskProviderEvent, fidl::Error> {
1607 let (bytes, _handles) = buf.split_mut();
1608 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1609 debug_assert_eq!(tx_header.tx_id, 0);
1610 match tx_header.ordinal {
1611 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
1612 Ok(TaskProviderEvent::_UnknownEvent { ordinal: tx_header.ordinal })
1613 }
1614 _ => Err(fidl::Error::UnknownOrdinal {
1615 ordinal: tx_header.ordinal,
1616 protocol_name: <TaskProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1617 }),
1618 }
1619 }
1620}
1621
1622pub struct TaskProviderRequestStream {
1624 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1625 is_terminated: bool,
1626}
1627
1628impl std::marker::Unpin for TaskProviderRequestStream {}
1629
1630impl futures::stream::FusedStream for TaskProviderRequestStream {
1631 fn is_terminated(&self) -> bool {
1632 self.is_terminated
1633 }
1634}
1635
1636impl fidl::endpoints::RequestStream for TaskProviderRequestStream {
1637 type Protocol = TaskProviderMarker;
1638 type ControlHandle = TaskProviderControlHandle;
1639
1640 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1641 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1642 }
1643
1644 fn control_handle(&self) -> Self::ControlHandle {
1645 TaskProviderControlHandle { inner: self.inner.clone() }
1646 }
1647
1648 fn into_inner(
1649 self,
1650 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1651 {
1652 (self.inner, self.is_terminated)
1653 }
1654
1655 fn from_inner(
1656 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1657 is_terminated: bool,
1658 ) -> Self {
1659 Self { inner, is_terminated }
1660 }
1661}
1662
1663impl futures::Stream for TaskProviderRequestStream {
1664 type Item = Result<TaskProviderRequest, fidl::Error>;
1665
1666 fn poll_next(
1667 mut self: std::pin::Pin<&mut Self>,
1668 cx: &mut std::task::Context<'_>,
1669 ) -> std::task::Poll<Option<Self::Item>> {
1670 let this = &mut *self;
1671 if this.inner.check_shutdown(cx) {
1672 this.is_terminated = true;
1673 return std::task::Poll::Ready(None);
1674 }
1675 if this.is_terminated {
1676 panic!("polled TaskProviderRequestStream after completion");
1677 }
1678 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1679 |bytes, handles| {
1680 match this.inner.channel().read_etc(cx, bytes, handles) {
1681 std::task::Poll::Ready(Ok(())) => {}
1682 std::task::Poll::Pending => return std::task::Poll::Pending,
1683 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1684 this.is_terminated = true;
1685 return std::task::Poll::Ready(None);
1686 }
1687 std::task::Poll::Ready(Err(e)) => {
1688 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1689 e.into(),
1690 ))))
1691 }
1692 }
1693
1694 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1696
1697 std::task::Poll::Ready(Some(match header.ordinal {
1698 0x4c9ca4f4fdece3ad => {
1699 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1700 let mut req = fidl::new_empty!(
1701 fidl::encoding::EmptyPayload,
1702 fidl::encoding::DefaultFuchsiaResourceDialect
1703 );
1704 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1705 let control_handle =
1706 TaskProviderControlHandle { inner: this.inner.clone() };
1707 Ok(TaskProviderRequest::GetJob {
1708 responder: TaskProviderGetJobResponder {
1709 control_handle: std::mem::ManuallyDrop::new(control_handle),
1710 tx_id: header.tx_id,
1711 },
1712 })
1713 }
1714 _ if header.tx_id == 0
1715 && header
1716 .dynamic_flags()
1717 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1718 {
1719 Ok(TaskProviderRequest::_UnknownMethod {
1720 ordinal: header.ordinal,
1721 control_handle: TaskProviderControlHandle { inner: this.inner.clone() },
1722 method_type: fidl::MethodType::OneWay,
1723 })
1724 }
1725 _ if header
1726 .dynamic_flags()
1727 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1728 {
1729 this.inner.send_framework_err(
1730 fidl::encoding::FrameworkErr::UnknownMethod,
1731 header.tx_id,
1732 header.ordinal,
1733 header.dynamic_flags(),
1734 (bytes, handles),
1735 )?;
1736 Ok(TaskProviderRequest::_UnknownMethod {
1737 ordinal: header.ordinal,
1738 control_handle: TaskProviderControlHandle { inner: this.inner.clone() },
1739 method_type: fidl::MethodType::TwoWay,
1740 })
1741 }
1742 _ => Err(fidl::Error::UnknownOrdinal {
1743 ordinal: header.ordinal,
1744 protocol_name:
1745 <TaskProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1746 }),
1747 }))
1748 },
1749 )
1750 }
1751}
1752
1753#[derive(Debug)]
1755pub enum TaskProviderRequest {
1756 GetJob { responder: TaskProviderGetJobResponder },
1760 #[non_exhaustive]
1762 _UnknownMethod {
1763 ordinal: u64,
1765 control_handle: TaskProviderControlHandle,
1766 method_type: fidl::MethodType,
1767 },
1768}
1769
1770impl TaskProviderRequest {
1771 #[allow(irrefutable_let_patterns)]
1772 pub fn into_get_job(self) -> Option<(TaskProviderGetJobResponder)> {
1773 if let TaskProviderRequest::GetJob { responder } = self {
1774 Some((responder))
1775 } else {
1776 None
1777 }
1778 }
1779
1780 pub fn method_name(&self) -> &'static str {
1782 match *self {
1783 TaskProviderRequest::GetJob { .. } => "get_job",
1784 TaskProviderRequest::_UnknownMethod {
1785 method_type: fidl::MethodType::OneWay, ..
1786 } => "unknown one-way method",
1787 TaskProviderRequest::_UnknownMethod {
1788 method_type: fidl::MethodType::TwoWay, ..
1789 } => "unknown two-way method",
1790 }
1791 }
1792}
1793
1794#[derive(Debug, Clone)]
1795pub struct TaskProviderControlHandle {
1796 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1797}
1798
1799impl fidl::endpoints::ControlHandle for TaskProviderControlHandle {
1800 fn shutdown(&self) {
1801 self.inner.shutdown()
1802 }
1803 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1804 self.inner.shutdown_with_epitaph(status)
1805 }
1806
1807 fn is_closed(&self) -> bool {
1808 self.inner.channel().is_closed()
1809 }
1810 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1811 self.inner.channel().on_closed()
1812 }
1813
1814 #[cfg(target_os = "fuchsia")]
1815 fn signal_peer(
1816 &self,
1817 clear_mask: zx::Signals,
1818 set_mask: zx::Signals,
1819 ) -> Result<(), zx_status::Status> {
1820 use fidl::Peered;
1821 self.inner.channel().signal_peer(clear_mask, set_mask)
1822 }
1823}
1824
1825impl TaskProviderControlHandle {}
1826
1827#[must_use = "FIDL methods require a response to be sent"]
1828#[derive(Debug)]
1829pub struct TaskProviderGetJobResponder {
1830 control_handle: std::mem::ManuallyDrop<TaskProviderControlHandle>,
1831 tx_id: u32,
1832}
1833
1834impl std::ops::Drop for TaskProviderGetJobResponder {
1838 fn drop(&mut self) {
1839 self.control_handle.shutdown();
1840 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1842 }
1843}
1844
1845impl fidl::endpoints::Responder for TaskProviderGetJobResponder {
1846 type ControlHandle = TaskProviderControlHandle;
1847
1848 fn control_handle(&self) -> &TaskProviderControlHandle {
1849 &self.control_handle
1850 }
1851
1852 fn drop_without_shutdown(mut self) {
1853 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1855 std::mem::forget(self);
1857 }
1858}
1859
1860impl TaskProviderGetJobResponder {
1861 pub fn send(self, mut result: Result<fidl::Job, i32>) -> Result<(), fidl::Error> {
1865 let _result = self.send_raw(result);
1866 if _result.is_err() {
1867 self.control_handle.shutdown();
1868 }
1869 self.drop_without_shutdown();
1870 _result
1871 }
1872
1873 pub fn send_no_shutdown_on_err(
1875 self,
1876 mut result: Result<fidl::Job, i32>,
1877 ) -> Result<(), fidl::Error> {
1878 let _result = self.send_raw(result);
1879 self.drop_without_shutdown();
1880 _result
1881 }
1882
1883 fn send_raw(&self, mut result: Result<fidl::Job, i32>) -> Result<(), fidl::Error> {
1884 self.control_handle
1885 .inner
1886 .send::<fidl::encoding::ResultType<TaskProviderGetJobResponse, i32>>(
1887 result.map(|job| (job,)),
1888 self.tx_id,
1889 0x4c9ca4f4fdece3ad,
1890 fidl::encoding::DynamicFlags::empty(),
1891 )
1892 }
1893}
1894
1895mod internal {
1896 use super::*;
1897
1898 impl fidl::encoding::ResourceTypeMarker for ComponentControllerOnPublishDiagnosticsRequest {
1899 type Borrowed<'a> = &'a mut Self;
1900 fn take_or_borrow<'a>(
1901 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1902 ) -> Self::Borrowed<'a> {
1903 value
1904 }
1905 }
1906
1907 unsafe impl fidl::encoding::TypeMarker for ComponentControllerOnPublishDiagnosticsRequest {
1908 type Owned = Self;
1909
1910 #[inline(always)]
1911 fn inline_align(_context: fidl::encoding::Context) -> usize {
1912 8
1913 }
1914
1915 #[inline(always)]
1916 fn inline_size(_context: fidl::encoding::Context) -> usize {
1917 16
1918 }
1919 }
1920
1921 unsafe impl
1922 fidl::encoding::Encode<
1923 ComponentControllerOnPublishDiagnosticsRequest,
1924 fidl::encoding::DefaultFuchsiaResourceDialect,
1925 > for &mut ComponentControllerOnPublishDiagnosticsRequest
1926 {
1927 #[inline]
1928 unsafe fn encode(
1929 self,
1930 encoder: &mut fidl::encoding::Encoder<
1931 '_,
1932 fidl::encoding::DefaultFuchsiaResourceDialect,
1933 >,
1934 offset: usize,
1935 _depth: fidl::encoding::Depth,
1936 ) -> fidl::Result<()> {
1937 encoder.debug_check_bounds::<ComponentControllerOnPublishDiagnosticsRequest>(offset);
1938 fidl::encoding::Encode::<
1940 ComponentControllerOnPublishDiagnosticsRequest,
1941 fidl::encoding::DefaultFuchsiaResourceDialect,
1942 >::encode(
1943 (<ComponentDiagnostics as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1944 &mut self.payload,
1945 ),),
1946 encoder,
1947 offset,
1948 _depth,
1949 )
1950 }
1951 }
1952 unsafe impl<
1953 T0: fidl::encoding::Encode<
1954 ComponentDiagnostics,
1955 fidl::encoding::DefaultFuchsiaResourceDialect,
1956 >,
1957 >
1958 fidl::encoding::Encode<
1959 ComponentControllerOnPublishDiagnosticsRequest,
1960 fidl::encoding::DefaultFuchsiaResourceDialect,
1961 > for (T0,)
1962 {
1963 #[inline]
1964 unsafe fn encode(
1965 self,
1966 encoder: &mut fidl::encoding::Encoder<
1967 '_,
1968 fidl::encoding::DefaultFuchsiaResourceDialect,
1969 >,
1970 offset: usize,
1971 depth: fidl::encoding::Depth,
1972 ) -> fidl::Result<()> {
1973 encoder.debug_check_bounds::<ComponentControllerOnPublishDiagnosticsRequest>(offset);
1974 self.0.encode(encoder, offset + 0, depth)?;
1978 Ok(())
1979 }
1980 }
1981
1982 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1983 for ComponentControllerOnPublishDiagnosticsRequest
1984 {
1985 #[inline(always)]
1986 fn new_empty() -> Self {
1987 Self {
1988 payload: fidl::new_empty!(
1989 ComponentDiagnostics,
1990 fidl::encoding::DefaultFuchsiaResourceDialect
1991 ),
1992 }
1993 }
1994
1995 #[inline]
1996 unsafe fn decode(
1997 &mut self,
1998 decoder: &mut fidl::encoding::Decoder<
1999 '_,
2000 fidl::encoding::DefaultFuchsiaResourceDialect,
2001 >,
2002 offset: usize,
2003 _depth: fidl::encoding::Depth,
2004 ) -> fidl::Result<()> {
2005 decoder.debug_check_bounds::<Self>(offset);
2006 fidl::decode!(
2008 ComponentDiagnostics,
2009 fidl::encoding::DefaultFuchsiaResourceDialect,
2010 &mut self.payload,
2011 decoder,
2012 offset + 0,
2013 _depth
2014 )?;
2015 Ok(())
2016 }
2017 }
2018
2019 impl fidl::encoding::ResourceTypeMarker for ComponentRunnerStartRequest {
2020 type Borrowed<'a> = &'a mut Self;
2021 fn take_or_borrow<'a>(
2022 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2023 ) -> Self::Borrowed<'a> {
2024 value
2025 }
2026 }
2027
2028 unsafe impl fidl::encoding::TypeMarker for ComponentRunnerStartRequest {
2029 type Owned = Self;
2030
2031 #[inline(always)]
2032 fn inline_align(_context: fidl::encoding::Context) -> usize {
2033 8
2034 }
2035
2036 #[inline(always)]
2037 fn inline_size(_context: fidl::encoding::Context) -> usize {
2038 24
2039 }
2040 }
2041
2042 unsafe impl
2043 fidl::encoding::Encode<
2044 ComponentRunnerStartRequest,
2045 fidl::encoding::DefaultFuchsiaResourceDialect,
2046 > for &mut ComponentRunnerStartRequest
2047 {
2048 #[inline]
2049 unsafe fn encode(
2050 self,
2051 encoder: &mut fidl::encoding::Encoder<
2052 '_,
2053 fidl::encoding::DefaultFuchsiaResourceDialect,
2054 >,
2055 offset: usize,
2056 _depth: fidl::encoding::Depth,
2057 ) -> fidl::Result<()> {
2058 encoder.debug_check_bounds::<ComponentRunnerStartRequest>(offset);
2059 fidl::encoding::Encode::<ComponentRunnerStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
2061 (
2062 <ComponentStartInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.start_info),
2063 <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ComponentControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
2064 ),
2065 encoder, offset, _depth
2066 )
2067 }
2068 }
2069 unsafe impl<
2070 T0: fidl::encoding::Encode<
2071 ComponentStartInfo,
2072 fidl::encoding::DefaultFuchsiaResourceDialect,
2073 >,
2074 T1: fidl::encoding::Encode<
2075 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ComponentControllerMarker>>,
2076 fidl::encoding::DefaultFuchsiaResourceDialect,
2077 >,
2078 >
2079 fidl::encoding::Encode<
2080 ComponentRunnerStartRequest,
2081 fidl::encoding::DefaultFuchsiaResourceDialect,
2082 > for (T0, T1)
2083 {
2084 #[inline]
2085 unsafe fn encode(
2086 self,
2087 encoder: &mut fidl::encoding::Encoder<
2088 '_,
2089 fidl::encoding::DefaultFuchsiaResourceDialect,
2090 >,
2091 offset: usize,
2092 depth: fidl::encoding::Depth,
2093 ) -> fidl::Result<()> {
2094 encoder.debug_check_bounds::<ComponentRunnerStartRequest>(offset);
2095 unsafe {
2098 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
2099 (ptr as *mut u64).write_unaligned(0);
2100 }
2101 self.0.encode(encoder, offset + 0, depth)?;
2103 self.1.encode(encoder, offset + 16, depth)?;
2104 Ok(())
2105 }
2106 }
2107
2108 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2109 for ComponentRunnerStartRequest
2110 {
2111 #[inline(always)]
2112 fn new_empty() -> Self {
2113 Self {
2114 start_info: fidl::new_empty!(
2115 ComponentStartInfo,
2116 fidl::encoding::DefaultFuchsiaResourceDialect
2117 ),
2118 controller: fidl::new_empty!(
2119 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ComponentControllerMarker>>,
2120 fidl::encoding::DefaultFuchsiaResourceDialect
2121 ),
2122 }
2123 }
2124
2125 #[inline]
2126 unsafe fn decode(
2127 &mut self,
2128 decoder: &mut fidl::encoding::Decoder<
2129 '_,
2130 fidl::encoding::DefaultFuchsiaResourceDialect,
2131 >,
2132 offset: usize,
2133 _depth: fidl::encoding::Depth,
2134 ) -> fidl::Result<()> {
2135 decoder.debug_check_bounds::<Self>(offset);
2136 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
2138 let padval = unsafe { (ptr as *const u64).read_unaligned() };
2139 let mask = 0xffffffff00000000u64;
2140 let maskedval = padval & mask;
2141 if maskedval != 0 {
2142 return Err(fidl::Error::NonZeroPadding {
2143 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
2144 });
2145 }
2146 fidl::decode!(
2147 ComponentStartInfo,
2148 fidl::encoding::DefaultFuchsiaResourceDialect,
2149 &mut self.start_info,
2150 decoder,
2151 offset + 0,
2152 _depth
2153 )?;
2154 fidl::decode!(
2155 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ComponentControllerMarker>>,
2156 fidl::encoding::DefaultFuchsiaResourceDialect,
2157 &mut self.controller,
2158 decoder,
2159 offset + 16,
2160 _depth
2161 )?;
2162 Ok(())
2163 }
2164 }
2165
2166 impl fidl::encoding::ResourceTypeMarker for TaskProviderGetJobResponse {
2167 type Borrowed<'a> = &'a mut Self;
2168 fn take_or_borrow<'a>(
2169 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2170 ) -> Self::Borrowed<'a> {
2171 value
2172 }
2173 }
2174
2175 unsafe impl fidl::encoding::TypeMarker for TaskProviderGetJobResponse {
2176 type Owned = Self;
2177
2178 #[inline(always)]
2179 fn inline_align(_context: fidl::encoding::Context) -> usize {
2180 4
2181 }
2182
2183 #[inline(always)]
2184 fn inline_size(_context: fidl::encoding::Context) -> usize {
2185 4
2186 }
2187 }
2188
2189 unsafe impl
2190 fidl::encoding::Encode<
2191 TaskProviderGetJobResponse,
2192 fidl::encoding::DefaultFuchsiaResourceDialect,
2193 > for &mut TaskProviderGetJobResponse
2194 {
2195 #[inline]
2196 unsafe fn encode(
2197 self,
2198 encoder: &mut fidl::encoding::Encoder<
2199 '_,
2200 fidl::encoding::DefaultFuchsiaResourceDialect,
2201 >,
2202 offset: usize,
2203 _depth: fidl::encoding::Depth,
2204 ) -> fidl::Result<()> {
2205 encoder.debug_check_bounds::<TaskProviderGetJobResponse>(offset);
2206 fidl::encoding::Encode::<
2208 TaskProviderGetJobResponse,
2209 fidl::encoding::DefaultFuchsiaResourceDialect,
2210 >::encode(
2211 (<fidl::encoding::HandleType<
2212 fidl::Job,
2213 { fidl::ObjectType::JOB.into_raw() },
2214 2147483648,
2215 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
2216 &mut self.job
2217 ),),
2218 encoder,
2219 offset,
2220 _depth,
2221 )
2222 }
2223 }
2224 unsafe impl<
2225 T0: fidl::encoding::Encode<
2226 fidl::encoding::HandleType<
2227 fidl::Job,
2228 { fidl::ObjectType::JOB.into_raw() },
2229 2147483648,
2230 >,
2231 fidl::encoding::DefaultFuchsiaResourceDialect,
2232 >,
2233 >
2234 fidl::encoding::Encode<
2235 TaskProviderGetJobResponse,
2236 fidl::encoding::DefaultFuchsiaResourceDialect,
2237 > for (T0,)
2238 {
2239 #[inline]
2240 unsafe fn encode(
2241 self,
2242 encoder: &mut fidl::encoding::Encoder<
2243 '_,
2244 fidl::encoding::DefaultFuchsiaResourceDialect,
2245 >,
2246 offset: usize,
2247 depth: fidl::encoding::Depth,
2248 ) -> fidl::Result<()> {
2249 encoder.debug_check_bounds::<TaskProviderGetJobResponse>(offset);
2250 self.0.encode(encoder, offset + 0, depth)?;
2254 Ok(())
2255 }
2256 }
2257
2258 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2259 for TaskProviderGetJobResponse
2260 {
2261 #[inline(always)]
2262 fn new_empty() -> Self {
2263 Self {
2264 job: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
2265 }
2266 }
2267
2268 #[inline]
2269 unsafe fn decode(
2270 &mut self,
2271 decoder: &mut fidl::encoding::Decoder<
2272 '_,
2273 fidl::encoding::DefaultFuchsiaResourceDialect,
2274 >,
2275 offset: usize,
2276 _depth: fidl::encoding::Depth,
2277 ) -> fidl::Result<()> {
2278 decoder.debug_check_bounds::<Self>(offset);
2279 fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job, decoder, offset + 0, _depth)?;
2281 Ok(())
2282 }
2283 }
2284
2285 impl ComponentControllerOnEscrowRequest {
2286 #[inline(always)]
2287 fn max_ordinal_present(&self) -> u64 {
2288 if let Some(_) = self.escrowed_dictionary {
2289 return 2;
2290 }
2291 if let Some(_) = self.outgoing_dir {
2292 return 1;
2293 }
2294 0
2295 }
2296 }
2297
2298 impl fidl::encoding::ResourceTypeMarker for ComponentControllerOnEscrowRequest {
2299 type Borrowed<'a> = &'a mut Self;
2300 fn take_or_borrow<'a>(
2301 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2302 ) -> Self::Borrowed<'a> {
2303 value
2304 }
2305 }
2306
2307 unsafe impl fidl::encoding::TypeMarker for ComponentControllerOnEscrowRequest {
2308 type Owned = Self;
2309
2310 #[inline(always)]
2311 fn inline_align(_context: fidl::encoding::Context) -> usize {
2312 8
2313 }
2314
2315 #[inline(always)]
2316 fn inline_size(_context: fidl::encoding::Context) -> usize {
2317 16
2318 }
2319 }
2320
2321 unsafe impl
2322 fidl::encoding::Encode<
2323 ComponentControllerOnEscrowRequest,
2324 fidl::encoding::DefaultFuchsiaResourceDialect,
2325 > for &mut ComponentControllerOnEscrowRequest
2326 {
2327 unsafe fn encode(
2328 self,
2329 encoder: &mut fidl::encoding::Encoder<
2330 '_,
2331 fidl::encoding::DefaultFuchsiaResourceDialect,
2332 >,
2333 offset: usize,
2334 mut depth: fidl::encoding::Depth,
2335 ) -> fidl::Result<()> {
2336 encoder.debug_check_bounds::<ComponentControllerOnEscrowRequest>(offset);
2337 let max_ordinal: u64 = self.max_ordinal_present();
2339 encoder.write_num(max_ordinal, offset);
2340 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2341 if max_ordinal == 0 {
2343 return Ok(());
2344 }
2345 depth.increment()?;
2346 let envelope_size = 8;
2347 let bytes_len = max_ordinal as usize * envelope_size;
2348 #[allow(unused_variables)]
2349 let offset = encoder.out_of_line_offset(bytes_len);
2350 let mut _prev_end_offset: usize = 0;
2351 if 1 > max_ordinal {
2352 return Ok(());
2353 }
2354
2355 let cur_offset: usize = (1 - 1) * envelope_size;
2358
2359 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2361
2362 fidl::encoding::encode_in_envelope_optional::<
2367 fidl::encoding::Endpoint<
2368 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2369 >,
2370 fidl::encoding::DefaultFuchsiaResourceDialect,
2371 >(
2372 self.outgoing_dir.as_mut().map(
2373 <fidl::encoding::Endpoint<
2374 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2375 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2376 ),
2377 encoder,
2378 offset + cur_offset,
2379 depth,
2380 )?;
2381
2382 _prev_end_offset = cur_offset + envelope_size;
2383 if 2 > max_ordinal {
2384 return Ok(());
2385 }
2386
2387 let cur_offset: usize = (2 - 1) * envelope_size;
2390
2391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2393
2394 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_sandbox::DictionaryRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
2399 self.escrowed_dictionary.as_mut().map(<fidl_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
2400 encoder, offset + cur_offset, depth
2401 )?;
2402
2403 _prev_end_offset = cur_offset + envelope_size;
2404
2405 Ok(())
2406 }
2407 }
2408
2409 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2410 for ComponentControllerOnEscrowRequest
2411 {
2412 #[inline(always)]
2413 fn new_empty() -> Self {
2414 Self::default()
2415 }
2416
2417 unsafe fn decode(
2418 &mut self,
2419 decoder: &mut fidl::encoding::Decoder<
2420 '_,
2421 fidl::encoding::DefaultFuchsiaResourceDialect,
2422 >,
2423 offset: usize,
2424 mut depth: fidl::encoding::Depth,
2425 ) -> fidl::Result<()> {
2426 decoder.debug_check_bounds::<Self>(offset);
2427 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2428 None => return Err(fidl::Error::NotNullable),
2429 Some(len) => len,
2430 };
2431 if len == 0 {
2433 return Ok(());
2434 };
2435 depth.increment()?;
2436 let envelope_size = 8;
2437 let bytes_len = len * envelope_size;
2438 let offset = decoder.out_of_line_offset(bytes_len)?;
2439 let mut _next_ordinal_to_read = 0;
2441 let mut next_offset = offset;
2442 let end_offset = offset + bytes_len;
2443 _next_ordinal_to_read += 1;
2444 if next_offset >= end_offset {
2445 return Ok(());
2446 }
2447
2448 while _next_ordinal_to_read < 1 {
2450 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2451 _next_ordinal_to_read += 1;
2452 next_offset += envelope_size;
2453 }
2454
2455 let next_out_of_line = decoder.next_out_of_line();
2456 let handles_before = decoder.remaining_handles();
2457 if let Some((inlined, num_bytes, num_handles)) =
2458 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2459 {
2460 let member_inline_size = <fidl::encoding::Endpoint<
2461 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2462 > as fidl::encoding::TypeMarker>::inline_size(
2463 decoder.context
2464 );
2465 if inlined != (member_inline_size <= 4) {
2466 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2467 }
2468 let inner_offset;
2469 let mut inner_depth = depth.clone();
2470 if inlined {
2471 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2472 inner_offset = next_offset;
2473 } else {
2474 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2475 inner_depth.increment()?;
2476 }
2477 let val_ref = self.outgoing_dir.get_or_insert_with(|| {
2478 fidl::new_empty!(
2479 fidl::encoding::Endpoint<
2480 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2481 >,
2482 fidl::encoding::DefaultFuchsiaResourceDialect
2483 )
2484 });
2485 fidl::decode!(
2486 fidl::encoding::Endpoint<
2487 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
2488 >,
2489 fidl::encoding::DefaultFuchsiaResourceDialect,
2490 val_ref,
2491 decoder,
2492 inner_offset,
2493 inner_depth
2494 )?;
2495 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2496 {
2497 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2498 }
2499 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2500 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2501 }
2502 }
2503
2504 next_offset += envelope_size;
2505 _next_ordinal_to_read += 1;
2506 if next_offset >= end_offset {
2507 return Ok(());
2508 }
2509
2510 while _next_ordinal_to_read < 2 {
2512 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2513 _next_ordinal_to_read += 1;
2514 next_offset += envelope_size;
2515 }
2516
2517 let next_out_of_line = decoder.next_out_of_line();
2518 let handles_before = decoder.remaining_handles();
2519 if let Some((inlined, num_bytes, num_handles)) =
2520 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2521 {
2522 let member_inline_size = <fidl_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2523 if inlined != (member_inline_size <= 4) {
2524 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2525 }
2526 let inner_offset;
2527 let mut inner_depth = depth.clone();
2528 if inlined {
2529 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2530 inner_offset = next_offset;
2531 } else {
2532 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2533 inner_depth.increment()?;
2534 }
2535 let val_ref = self.escrowed_dictionary.get_or_insert_with(|| {
2536 fidl::new_empty!(
2537 fidl_fuchsia_component_sandbox::DictionaryRef,
2538 fidl::encoding::DefaultFuchsiaResourceDialect
2539 )
2540 });
2541 fidl::decode!(
2542 fidl_fuchsia_component_sandbox::DictionaryRef,
2543 fidl::encoding::DefaultFuchsiaResourceDialect,
2544 val_ref,
2545 decoder,
2546 inner_offset,
2547 inner_depth
2548 )?;
2549 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2550 {
2551 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2552 }
2553 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2554 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2555 }
2556 }
2557
2558 next_offset += envelope_size;
2559
2560 while next_offset < end_offset {
2562 _next_ordinal_to_read += 1;
2563 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2564 next_offset += envelope_size;
2565 }
2566
2567 Ok(())
2568 }
2569 }
2570
2571 impl ComponentDiagnostics {
2572 #[inline(always)]
2573 fn max_ordinal_present(&self) -> u64 {
2574 if let Some(_) = self.tasks {
2575 return 1;
2576 }
2577 0
2578 }
2579 }
2580
2581 impl fidl::encoding::ResourceTypeMarker for ComponentDiagnostics {
2582 type Borrowed<'a> = &'a mut Self;
2583 fn take_or_borrow<'a>(
2584 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2585 ) -> Self::Borrowed<'a> {
2586 value
2587 }
2588 }
2589
2590 unsafe impl fidl::encoding::TypeMarker for ComponentDiagnostics {
2591 type Owned = Self;
2592
2593 #[inline(always)]
2594 fn inline_align(_context: fidl::encoding::Context) -> usize {
2595 8
2596 }
2597
2598 #[inline(always)]
2599 fn inline_size(_context: fidl::encoding::Context) -> usize {
2600 16
2601 }
2602 }
2603
2604 unsafe impl
2605 fidl::encoding::Encode<ComponentDiagnostics, fidl::encoding::DefaultFuchsiaResourceDialect>
2606 for &mut ComponentDiagnostics
2607 {
2608 unsafe fn encode(
2609 self,
2610 encoder: &mut fidl::encoding::Encoder<
2611 '_,
2612 fidl::encoding::DefaultFuchsiaResourceDialect,
2613 >,
2614 offset: usize,
2615 mut depth: fidl::encoding::Depth,
2616 ) -> fidl::Result<()> {
2617 encoder.debug_check_bounds::<ComponentDiagnostics>(offset);
2618 let max_ordinal: u64 = self.max_ordinal_present();
2620 encoder.write_num(max_ordinal, offset);
2621 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2622 if max_ordinal == 0 {
2624 return Ok(());
2625 }
2626 depth.increment()?;
2627 let envelope_size = 8;
2628 let bytes_len = max_ordinal as usize * envelope_size;
2629 #[allow(unused_variables)]
2630 let offset = encoder.out_of_line_offset(bytes_len);
2631 let mut _prev_end_offset: usize = 0;
2632 if 1 > max_ordinal {
2633 return Ok(());
2634 }
2635
2636 let cur_offset: usize = (1 - 1) * envelope_size;
2639
2640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2642
2643 fidl::encoding::encode_in_envelope_optional::<
2648 ComponentTasks,
2649 fidl::encoding::DefaultFuchsiaResourceDialect,
2650 >(
2651 self.tasks
2652 .as_mut()
2653 .map(<ComponentTasks as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
2654 encoder,
2655 offset + cur_offset,
2656 depth,
2657 )?;
2658
2659 _prev_end_offset = cur_offset + envelope_size;
2660
2661 Ok(())
2662 }
2663 }
2664
2665 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2666 for ComponentDiagnostics
2667 {
2668 #[inline(always)]
2669 fn new_empty() -> Self {
2670 Self::default()
2671 }
2672
2673 unsafe fn decode(
2674 &mut self,
2675 decoder: &mut fidl::encoding::Decoder<
2676 '_,
2677 fidl::encoding::DefaultFuchsiaResourceDialect,
2678 >,
2679 offset: usize,
2680 mut depth: fidl::encoding::Depth,
2681 ) -> fidl::Result<()> {
2682 decoder.debug_check_bounds::<Self>(offset);
2683 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2684 None => return Err(fidl::Error::NotNullable),
2685 Some(len) => len,
2686 };
2687 if len == 0 {
2689 return Ok(());
2690 };
2691 depth.increment()?;
2692 let envelope_size = 8;
2693 let bytes_len = len * envelope_size;
2694 let offset = decoder.out_of_line_offset(bytes_len)?;
2695 let mut _next_ordinal_to_read = 0;
2697 let mut next_offset = offset;
2698 let end_offset = offset + bytes_len;
2699 _next_ordinal_to_read += 1;
2700 if next_offset >= end_offset {
2701 return Ok(());
2702 }
2703
2704 while _next_ordinal_to_read < 1 {
2706 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2707 _next_ordinal_to_read += 1;
2708 next_offset += envelope_size;
2709 }
2710
2711 let next_out_of_line = decoder.next_out_of_line();
2712 let handles_before = decoder.remaining_handles();
2713 if let Some((inlined, num_bytes, num_handles)) =
2714 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2715 {
2716 let member_inline_size =
2717 <ComponentTasks as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2718 if inlined != (member_inline_size <= 4) {
2719 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2720 }
2721 let inner_offset;
2722 let mut inner_depth = depth.clone();
2723 if inlined {
2724 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2725 inner_offset = next_offset;
2726 } else {
2727 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2728 inner_depth.increment()?;
2729 }
2730 let val_ref = self.tasks.get_or_insert_with(|| {
2731 fidl::new_empty!(ComponentTasks, fidl::encoding::DefaultFuchsiaResourceDialect)
2732 });
2733 fidl::decode!(
2734 ComponentTasks,
2735 fidl::encoding::DefaultFuchsiaResourceDialect,
2736 val_ref,
2737 decoder,
2738 inner_offset,
2739 inner_depth
2740 )?;
2741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2742 {
2743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2744 }
2745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2747 }
2748 }
2749
2750 next_offset += envelope_size;
2751
2752 while next_offset < end_offset {
2754 _next_ordinal_to_read += 1;
2755 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2756 next_offset += envelope_size;
2757 }
2758
2759 Ok(())
2760 }
2761 }
2762
2763 impl ComponentNamespaceEntry {
2764 #[inline(always)]
2765 fn max_ordinal_present(&self) -> u64 {
2766 if let Some(_) = self.directory {
2767 return 2;
2768 }
2769 if let Some(_) = self.path {
2770 return 1;
2771 }
2772 0
2773 }
2774 }
2775
2776 impl fidl::encoding::ResourceTypeMarker for ComponentNamespaceEntry {
2777 type Borrowed<'a> = &'a mut Self;
2778 fn take_or_borrow<'a>(
2779 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2780 ) -> Self::Borrowed<'a> {
2781 value
2782 }
2783 }
2784
2785 unsafe impl fidl::encoding::TypeMarker for ComponentNamespaceEntry {
2786 type Owned = Self;
2787
2788 #[inline(always)]
2789 fn inline_align(_context: fidl::encoding::Context) -> usize {
2790 8
2791 }
2792
2793 #[inline(always)]
2794 fn inline_size(_context: fidl::encoding::Context) -> usize {
2795 16
2796 }
2797 }
2798
2799 unsafe impl
2800 fidl::encoding::Encode<
2801 ComponentNamespaceEntry,
2802 fidl::encoding::DefaultFuchsiaResourceDialect,
2803 > for &mut ComponentNamespaceEntry
2804 {
2805 unsafe fn encode(
2806 self,
2807 encoder: &mut fidl::encoding::Encoder<
2808 '_,
2809 fidl::encoding::DefaultFuchsiaResourceDialect,
2810 >,
2811 offset: usize,
2812 mut depth: fidl::encoding::Depth,
2813 ) -> fidl::Result<()> {
2814 encoder.debug_check_bounds::<ComponentNamespaceEntry>(offset);
2815 let max_ordinal: u64 = self.max_ordinal_present();
2817 encoder.write_num(max_ordinal, offset);
2818 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2819 if max_ordinal == 0 {
2821 return Ok(());
2822 }
2823 depth.increment()?;
2824 let envelope_size = 8;
2825 let bytes_len = max_ordinal as usize * envelope_size;
2826 #[allow(unused_variables)]
2827 let offset = encoder.out_of_line_offset(bytes_len);
2828 let mut _prev_end_offset: usize = 0;
2829 if 1 > max_ordinal {
2830 return Ok(());
2831 }
2832
2833 let cur_offset: usize = (1 - 1) * envelope_size;
2836
2837 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2839
2840 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, fidl::encoding::DefaultFuchsiaResourceDialect>(
2845 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
2846 encoder, offset + cur_offset, depth
2847 )?;
2848
2849 _prev_end_offset = cur_offset + envelope_size;
2850 if 2 > max_ordinal {
2851 return Ok(());
2852 }
2853
2854 let cur_offset: usize = (2 - 1) * envelope_size;
2857
2858 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2860
2861 fidl::encoding::encode_in_envelope_optional::<
2866 fidl::encoding::Endpoint<
2867 fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
2868 >,
2869 fidl::encoding::DefaultFuchsiaResourceDialect,
2870 >(
2871 self.directory.as_mut().map(
2872 <fidl::encoding::Endpoint<
2873 fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
2874 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2875 ),
2876 encoder,
2877 offset + cur_offset,
2878 depth,
2879 )?;
2880
2881 _prev_end_offset = cur_offset + envelope_size;
2882
2883 Ok(())
2884 }
2885 }
2886
2887 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2888 for ComponentNamespaceEntry
2889 {
2890 #[inline(always)]
2891 fn new_empty() -> Self {
2892 Self::default()
2893 }
2894
2895 unsafe fn decode(
2896 &mut self,
2897 decoder: &mut fidl::encoding::Decoder<
2898 '_,
2899 fidl::encoding::DefaultFuchsiaResourceDialect,
2900 >,
2901 offset: usize,
2902 mut depth: fidl::encoding::Depth,
2903 ) -> fidl::Result<()> {
2904 decoder.debug_check_bounds::<Self>(offset);
2905 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2906 None => return Err(fidl::Error::NotNullable),
2907 Some(len) => len,
2908 };
2909 if len == 0 {
2911 return Ok(());
2912 };
2913 depth.increment()?;
2914 let envelope_size = 8;
2915 let bytes_len = len * envelope_size;
2916 let offset = decoder.out_of_line_offset(bytes_len)?;
2917 let mut _next_ordinal_to_read = 0;
2919 let mut next_offset = offset;
2920 let end_offset = offset + bytes_len;
2921 _next_ordinal_to_read += 1;
2922 if next_offset >= end_offset {
2923 return Ok(());
2924 }
2925
2926 while _next_ordinal_to_read < 1 {
2928 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2929 _next_ordinal_to_read += 1;
2930 next_offset += envelope_size;
2931 }
2932
2933 let next_out_of_line = decoder.next_out_of_line();
2934 let handles_before = decoder.remaining_handles();
2935 if let Some((inlined, num_bytes, num_handles)) =
2936 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2937 {
2938 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2939 if inlined != (member_inline_size <= 4) {
2940 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2941 }
2942 let inner_offset;
2943 let mut inner_depth = depth.clone();
2944 if inlined {
2945 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2946 inner_offset = next_offset;
2947 } else {
2948 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2949 inner_depth.increment()?;
2950 }
2951 let val_ref = self.path.get_or_insert_with(|| {
2952 fidl::new_empty!(
2953 fidl::encoding::BoundedString<4095>,
2954 fidl::encoding::DefaultFuchsiaResourceDialect
2955 )
2956 });
2957 fidl::decode!(
2958 fidl::encoding::BoundedString<4095>,
2959 fidl::encoding::DefaultFuchsiaResourceDialect,
2960 val_ref,
2961 decoder,
2962 inner_offset,
2963 inner_depth
2964 )?;
2965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2966 {
2967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2968 }
2969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2971 }
2972 }
2973
2974 next_offset += envelope_size;
2975 _next_ordinal_to_read += 1;
2976 if next_offset >= end_offset {
2977 return Ok(());
2978 }
2979
2980 while _next_ordinal_to_read < 2 {
2982 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2983 _next_ordinal_to_read += 1;
2984 next_offset += envelope_size;
2985 }
2986
2987 let next_out_of_line = decoder.next_out_of_line();
2988 let handles_before = decoder.remaining_handles();
2989 if let Some((inlined, num_bytes, num_handles)) =
2990 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2991 {
2992 let member_inline_size = <fidl::encoding::Endpoint<
2993 fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
2994 > as fidl::encoding::TypeMarker>::inline_size(
2995 decoder.context
2996 );
2997 if inlined != (member_inline_size <= 4) {
2998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2999 }
3000 let inner_offset;
3001 let mut inner_depth = depth.clone();
3002 if inlined {
3003 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3004 inner_offset = next_offset;
3005 } else {
3006 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3007 inner_depth.increment()?;
3008 }
3009 let val_ref = self.directory.get_or_insert_with(|| {
3010 fidl::new_empty!(
3011 fidl::encoding::Endpoint<
3012 fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
3013 >,
3014 fidl::encoding::DefaultFuchsiaResourceDialect
3015 )
3016 });
3017 fidl::decode!(
3018 fidl::encoding::Endpoint<
3019 fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
3020 >,
3021 fidl::encoding::DefaultFuchsiaResourceDialect,
3022 val_ref,
3023 decoder,
3024 inner_offset,
3025 inner_depth
3026 )?;
3027 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3028 {
3029 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3030 }
3031 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3032 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3033 }
3034 }
3035
3036 next_offset += envelope_size;
3037
3038 while next_offset < end_offset {
3040 _next_ordinal_to_read += 1;
3041 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3042 next_offset += envelope_size;
3043 }
3044
3045 Ok(())
3046 }
3047 }
3048
3049 impl ComponentStartInfo {
3050 #[inline(always)]
3051 fn max_ordinal_present(&self) -> u64 {
3052 if let Some(_) = self.escrowed_dictionary {
3053 return 10;
3054 }
3055 if let Some(_) = self.component_instance {
3056 return 9;
3057 }
3058 if let Some(_) = self.break_on_start {
3059 return 8;
3060 }
3061 if let Some(_) = self.encoded_config {
3062 return 7;
3063 }
3064 if let Some(_) = self.numbered_handles {
3065 return 6;
3066 }
3067 if let Some(_) = self.runtime_dir {
3068 return 5;
3069 }
3070 if let Some(_) = self.outgoing_dir {
3071 return 4;
3072 }
3073 if let Some(_) = self.ns {
3074 return 3;
3075 }
3076 if let Some(_) = self.program {
3077 return 2;
3078 }
3079 if let Some(_) = self.resolved_url {
3080 return 1;
3081 }
3082 0
3083 }
3084 }
3085
3086 impl fidl::encoding::ResourceTypeMarker for ComponentStartInfo {
3087 type Borrowed<'a> = &'a mut Self;
3088 fn take_or_borrow<'a>(
3089 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
3090 ) -> Self::Borrowed<'a> {
3091 value
3092 }
3093 }
3094
3095 unsafe impl fidl::encoding::TypeMarker for ComponentStartInfo {
3096 type Owned = Self;
3097
3098 #[inline(always)]
3099 fn inline_align(_context: fidl::encoding::Context) -> usize {
3100 8
3101 }
3102
3103 #[inline(always)]
3104 fn inline_size(_context: fidl::encoding::Context) -> usize {
3105 16
3106 }
3107 }
3108
3109 unsafe impl
3110 fidl::encoding::Encode<ComponentStartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
3111 for &mut ComponentStartInfo
3112 {
3113 unsafe fn encode(
3114 self,
3115 encoder: &mut fidl::encoding::Encoder<
3116 '_,
3117 fidl::encoding::DefaultFuchsiaResourceDialect,
3118 >,
3119 offset: usize,
3120 mut depth: fidl::encoding::Depth,
3121 ) -> fidl::Result<()> {
3122 encoder.debug_check_bounds::<ComponentStartInfo>(offset);
3123 let max_ordinal: u64 = self.max_ordinal_present();
3125 encoder.write_num(max_ordinal, offset);
3126 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3127 if max_ordinal == 0 {
3129 return Ok(());
3130 }
3131 depth.increment()?;
3132 let envelope_size = 8;
3133 let bytes_len = max_ordinal as usize * envelope_size;
3134 #[allow(unused_variables)]
3135 let offset = encoder.out_of_line_offset(bytes_len);
3136 let mut _prev_end_offset: usize = 0;
3137 if 1 > max_ordinal {
3138 return Ok(());
3139 }
3140
3141 let cur_offset: usize = (1 - 1) * envelope_size;
3144
3145 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3147
3148 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, fidl::encoding::DefaultFuchsiaResourceDialect>(
3153 self.resolved_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3154 encoder, offset + cur_offset, depth
3155 )?;
3156
3157 _prev_end_offset = cur_offset + envelope_size;
3158 if 2 > max_ordinal {
3159 return Ok(());
3160 }
3161
3162 let cur_offset: usize = (2 - 1) * envelope_size;
3165
3166 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3168
3169 fidl::encoding::encode_in_envelope_optional::<
3174 fidl_fuchsia_data::Dictionary,
3175 fidl::encoding::DefaultFuchsiaResourceDialect,
3176 >(
3177 self.program.as_ref().map(
3178 <fidl_fuchsia_data::Dictionary as fidl::encoding::ValueTypeMarker>::borrow,
3179 ),
3180 encoder,
3181 offset + cur_offset,
3182 depth,
3183 )?;
3184
3185 _prev_end_offset = cur_offset + envelope_size;
3186 if 3 > max_ordinal {
3187 return Ok(());
3188 }
3189
3190 let cur_offset: usize = (3 - 1) * envelope_size;
3193
3194 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3196
3197 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ComponentNamespaceEntry, 32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
3202 self.ns.as_mut().map(<fidl::encoding::Vector<ComponentNamespaceEntry, 32> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
3203 encoder, offset + cur_offset, depth
3204 )?;
3205
3206 _prev_end_offset = cur_offset + envelope_size;
3207 if 4 > max_ordinal {
3208 return Ok(());
3209 }
3210
3211 let cur_offset: usize = (4 - 1) * envelope_size;
3214
3215 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3217
3218 fidl::encoding::encode_in_envelope_optional::<
3223 fidl::encoding::Endpoint<
3224 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3225 >,
3226 fidl::encoding::DefaultFuchsiaResourceDialect,
3227 >(
3228 self.outgoing_dir.as_mut().map(
3229 <fidl::encoding::Endpoint<
3230 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3231 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3232 ),
3233 encoder,
3234 offset + cur_offset,
3235 depth,
3236 )?;
3237
3238 _prev_end_offset = cur_offset + envelope_size;
3239 if 5 > max_ordinal {
3240 return Ok(());
3241 }
3242
3243 let cur_offset: usize = (5 - 1) * envelope_size;
3246
3247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3249
3250 fidl::encoding::encode_in_envelope_optional::<
3255 fidl::encoding::Endpoint<
3256 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3257 >,
3258 fidl::encoding::DefaultFuchsiaResourceDialect,
3259 >(
3260 self.runtime_dir.as_mut().map(
3261 <fidl::encoding::Endpoint<
3262 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3263 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3264 ),
3265 encoder,
3266 offset + cur_offset,
3267 depth,
3268 )?;
3269
3270 _prev_end_offset = cur_offset + envelope_size;
3271 if 6 > max_ordinal {
3272 return Ok(());
3273 }
3274
3275 let cur_offset: usize = (6 - 1) * envelope_size;
3278
3279 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3281
3282 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect>(
3287 self.numbered_handles.as_mut().map(<fidl::encoding::Vector<fidl_fuchsia_process::HandleInfo, 128> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
3288 encoder, offset + cur_offset, depth
3289 )?;
3290
3291 _prev_end_offset = cur_offset + envelope_size;
3292 if 7 > max_ordinal {
3293 return Ok(());
3294 }
3295
3296 let cur_offset: usize = (7 - 1) * envelope_size;
3299
3300 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3302
3303 fidl::encoding::encode_in_envelope_optional::<
3308 fidl_fuchsia_mem::Data,
3309 fidl::encoding::DefaultFuchsiaResourceDialect,
3310 >(
3311 self.encoded_config.as_mut().map(
3312 <fidl_fuchsia_mem::Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3313 ),
3314 encoder,
3315 offset + cur_offset,
3316 depth,
3317 )?;
3318
3319 _prev_end_offset = cur_offset + envelope_size;
3320 if 8 > max_ordinal {
3321 return Ok(());
3322 }
3323
3324 let cur_offset: usize = (8 - 1) * envelope_size;
3327
3328 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3330
3331 fidl::encoding::encode_in_envelope_optional::<
3336 fidl::encoding::HandleType<
3337 fidl::EventPair,
3338 { fidl::ObjectType::EVENTPAIR.into_raw() },
3339 2147483648,
3340 >,
3341 fidl::encoding::DefaultFuchsiaResourceDialect,
3342 >(
3343 self.break_on_start.as_mut().map(
3344 <fidl::encoding::HandleType<
3345 fidl::EventPair,
3346 { fidl::ObjectType::EVENTPAIR.into_raw() },
3347 2147483648,
3348 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3349 ),
3350 encoder,
3351 offset + cur_offset,
3352 depth,
3353 )?;
3354
3355 _prev_end_offset = cur_offset + envelope_size;
3356 if 9 > max_ordinal {
3357 return Ok(());
3358 }
3359
3360 let cur_offset: usize = (9 - 1) * envelope_size;
3363
3364 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3366
3367 fidl::encoding::encode_in_envelope_optional::<
3372 fidl::encoding::HandleType<
3373 fidl::Event,
3374 { fidl::ObjectType::EVENT.into_raw() },
3375 2147483648,
3376 >,
3377 fidl::encoding::DefaultFuchsiaResourceDialect,
3378 >(
3379 self.component_instance.as_mut().map(
3380 <fidl::encoding::HandleType<
3381 fidl::Event,
3382 { fidl::ObjectType::EVENT.into_raw() },
3383 2147483648,
3384 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3385 ),
3386 encoder,
3387 offset + cur_offset,
3388 depth,
3389 )?;
3390
3391 _prev_end_offset = cur_offset + envelope_size;
3392 if 10 > max_ordinal {
3393 return Ok(());
3394 }
3395
3396 let cur_offset: usize = (10 - 1) * envelope_size;
3399
3400 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3402
3403 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_sandbox::DictionaryRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
3408 self.escrowed_dictionary.as_mut().map(<fidl_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
3409 encoder, offset + cur_offset, depth
3410 )?;
3411
3412 _prev_end_offset = cur_offset + envelope_size;
3413
3414 Ok(())
3415 }
3416 }
3417
3418 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
3419 for ComponentStartInfo
3420 {
3421 #[inline(always)]
3422 fn new_empty() -> Self {
3423 Self::default()
3424 }
3425
3426 unsafe fn decode(
3427 &mut self,
3428 decoder: &mut fidl::encoding::Decoder<
3429 '_,
3430 fidl::encoding::DefaultFuchsiaResourceDialect,
3431 >,
3432 offset: usize,
3433 mut depth: fidl::encoding::Depth,
3434 ) -> fidl::Result<()> {
3435 decoder.debug_check_bounds::<Self>(offset);
3436 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3437 None => return Err(fidl::Error::NotNullable),
3438 Some(len) => len,
3439 };
3440 if len == 0 {
3442 return Ok(());
3443 };
3444 depth.increment()?;
3445 let envelope_size = 8;
3446 let bytes_len = len * envelope_size;
3447 let offset = decoder.out_of_line_offset(bytes_len)?;
3448 let mut _next_ordinal_to_read = 0;
3450 let mut next_offset = offset;
3451 let end_offset = offset + bytes_len;
3452 _next_ordinal_to_read += 1;
3453 if next_offset >= end_offset {
3454 return Ok(());
3455 }
3456
3457 while _next_ordinal_to_read < 1 {
3459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3460 _next_ordinal_to_read += 1;
3461 next_offset += envelope_size;
3462 }
3463
3464 let next_out_of_line = decoder.next_out_of_line();
3465 let handles_before = decoder.remaining_handles();
3466 if let Some((inlined, num_bytes, num_handles)) =
3467 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3468 {
3469 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3470 if inlined != (member_inline_size <= 4) {
3471 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3472 }
3473 let inner_offset;
3474 let mut inner_depth = depth.clone();
3475 if inlined {
3476 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3477 inner_offset = next_offset;
3478 } else {
3479 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3480 inner_depth.increment()?;
3481 }
3482 let val_ref = self.resolved_url.get_or_insert_with(|| {
3483 fidl::new_empty!(
3484 fidl::encoding::BoundedString<4096>,
3485 fidl::encoding::DefaultFuchsiaResourceDialect
3486 )
3487 });
3488 fidl::decode!(
3489 fidl::encoding::BoundedString<4096>,
3490 fidl::encoding::DefaultFuchsiaResourceDialect,
3491 val_ref,
3492 decoder,
3493 inner_offset,
3494 inner_depth
3495 )?;
3496 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3497 {
3498 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3499 }
3500 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3501 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3502 }
3503 }
3504
3505 next_offset += envelope_size;
3506 _next_ordinal_to_read += 1;
3507 if next_offset >= end_offset {
3508 return Ok(());
3509 }
3510
3511 while _next_ordinal_to_read < 2 {
3513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3514 _next_ordinal_to_read += 1;
3515 next_offset += envelope_size;
3516 }
3517
3518 let next_out_of_line = decoder.next_out_of_line();
3519 let handles_before = decoder.remaining_handles();
3520 if let Some((inlined, num_bytes, num_handles)) =
3521 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3522 {
3523 let member_inline_size =
3524 <fidl_fuchsia_data::Dictionary as fidl::encoding::TypeMarker>::inline_size(
3525 decoder.context,
3526 );
3527 if inlined != (member_inline_size <= 4) {
3528 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3529 }
3530 let inner_offset;
3531 let mut inner_depth = depth.clone();
3532 if inlined {
3533 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3534 inner_offset = next_offset;
3535 } else {
3536 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3537 inner_depth.increment()?;
3538 }
3539 let val_ref = self.program.get_or_insert_with(|| {
3540 fidl::new_empty!(
3541 fidl_fuchsia_data::Dictionary,
3542 fidl::encoding::DefaultFuchsiaResourceDialect
3543 )
3544 });
3545 fidl::decode!(
3546 fidl_fuchsia_data::Dictionary,
3547 fidl::encoding::DefaultFuchsiaResourceDialect,
3548 val_ref,
3549 decoder,
3550 inner_offset,
3551 inner_depth
3552 )?;
3553 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3554 {
3555 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3556 }
3557 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3558 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3559 }
3560 }
3561
3562 next_offset += envelope_size;
3563 _next_ordinal_to_read += 1;
3564 if next_offset >= end_offset {
3565 return Ok(());
3566 }
3567
3568 while _next_ordinal_to_read < 3 {
3570 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3571 _next_ordinal_to_read += 1;
3572 next_offset += envelope_size;
3573 }
3574
3575 let next_out_of_line = decoder.next_out_of_line();
3576 let handles_before = decoder.remaining_handles();
3577 if let Some((inlined, num_bytes, num_handles)) =
3578 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3579 {
3580 let member_inline_size = <fidl::encoding::Vector<ComponentNamespaceEntry, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3581 if inlined != (member_inline_size <= 4) {
3582 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3583 }
3584 let inner_offset;
3585 let mut inner_depth = depth.clone();
3586 if inlined {
3587 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3588 inner_offset = next_offset;
3589 } else {
3590 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3591 inner_depth.increment()?;
3592 }
3593 let val_ref =
3594 self.ns.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<ComponentNamespaceEntry, 32>, fidl::encoding::DefaultFuchsiaResourceDialect));
3595 fidl::decode!(fidl::encoding::Vector<ComponentNamespaceEntry, 32>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
3596 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3597 {
3598 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3599 }
3600 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3601 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3602 }
3603 }
3604
3605 next_offset += envelope_size;
3606 _next_ordinal_to_read += 1;
3607 if next_offset >= end_offset {
3608 return Ok(());
3609 }
3610
3611 while _next_ordinal_to_read < 4 {
3613 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3614 _next_ordinal_to_read += 1;
3615 next_offset += envelope_size;
3616 }
3617
3618 let next_out_of_line = decoder.next_out_of_line();
3619 let handles_before = decoder.remaining_handles();
3620 if let Some((inlined, num_bytes, num_handles)) =
3621 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3622 {
3623 let member_inline_size = <fidl::encoding::Endpoint<
3624 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3625 > as fidl::encoding::TypeMarker>::inline_size(
3626 decoder.context
3627 );
3628 if inlined != (member_inline_size <= 4) {
3629 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3630 }
3631 let inner_offset;
3632 let mut inner_depth = depth.clone();
3633 if inlined {
3634 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3635 inner_offset = next_offset;
3636 } else {
3637 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3638 inner_depth.increment()?;
3639 }
3640 let val_ref = self.outgoing_dir.get_or_insert_with(|| {
3641 fidl::new_empty!(
3642 fidl::encoding::Endpoint<
3643 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3644 >,
3645 fidl::encoding::DefaultFuchsiaResourceDialect
3646 )
3647 });
3648 fidl::decode!(
3649 fidl::encoding::Endpoint<
3650 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3651 >,
3652 fidl::encoding::DefaultFuchsiaResourceDialect,
3653 val_ref,
3654 decoder,
3655 inner_offset,
3656 inner_depth
3657 )?;
3658 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3659 {
3660 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3661 }
3662 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3663 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3664 }
3665 }
3666
3667 next_offset += envelope_size;
3668 _next_ordinal_to_read += 1;
3669 if next_offset >= end_offset {
3670 return Ok(());
3671 }
3672
3673 while _next_ordinal_to_read < 5 {
3675 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3676 _next_ordinal_to_read += 1;
3677 next_offset += envelope_size;
3678 }
3679
3680 let next_out_of_line = decoder.next_out_of_line();
3681 let handles_before = decoder.remaining_handles();
3682 if let Some((inlined, num_bytes, num_handles)) =
3683 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3684 {
3685 let member_inline_size = <fidl::encoding::Endpoint<
3686 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3687 > as fidl::encoding::TypeMarker>::inline_size(
3688 decoder.context
3689 );
3690 if inlined != (member_inline_size <= 4) {
3691 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3692 }
3693 let inner_offset;
3694 let mut inner_depth = depth.clone();
3695 if inlined {
3696 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3697 inner_offset = next_offset;
3698 } else {
3699 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3700 inner_depth.increment()?;
3701 }
3702 let val_ref = self.runtime_dir.get_or_insert_with(|| {
3703 fidl::new_empty!(
3704 fidl::encoding::Endpoint<
3705 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3706 >,
3707 fidl::encoding::DefaultFuchsiaResourceDialect
3708 )
3709 });
3710 fidl::decode!(
3711 fidl::encoding::Endpoint<
3712 fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
3713 >,
3714 fidl::encoding::DefaultFuchsiaResourceDialect,
3715 val_ref,
3716 decoder,
3717 inner_offset,
3718 inner_depth
3719 )?;
3720 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3721 {
3722 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3723 }
3724 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3725 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3726 }
3727 }
3728
3729 next_offset += envelope_size;
3730 _next_ordinal_to_read += 1;
3731 if next_offset >= end_offset {
3732 return Ok(());
3733 }
3734
3735 while _next_ordinal_to_read < 6 {
3737 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3738 _next_ordinal_to_read += 1;
3739 next_offset += envelope_size;
3740 }
3741
3742 let next_out_of_line = decoder.next_out_of_line();
3743 let handles_before = decoder.remaining_handles();
3744 if let Some((inlined, num_bytes, num_handles)) =
3745 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3746 {
3747 let member_inline_size = <fidl::encoding::Vector<
3748 fidl_fuchsia_process::HandleInfo,
3749 128,
3750 > as fidl::encoding::TypeMarker>::inline_size(
3751 decoder.context
3752 );
3753 if inlined != (member_inline_size <= 4) {
3754 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3755 }
3756 let inner_offset;
3757 let mut inner_depth = depth.clone();
3758 if inlined {
3759 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3760 inner_offset = next_offset;
3761 } else {
3762 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3763 inner_depth.increment()?;
3764 }
3765 let val_ref =
3766 self.numbered_handles.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect));
3767 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
3768 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3769 {
3770 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3771 }
3772 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3773 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3774 }
3775 }
3776
3777 next_offset += envelope_size;
3778 _next_ordinal_to_read += 1;
3779 if next_offset >= end_offset {
3780 return Ok(());
3781 }
3782
3783 while _next_ordinal_to_read < 7 {
3785 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3786 _next_ordinal_to_read += 1;
3787 next_offset += envelope_size;
3788 }
3789
3790 let next_out_of_line = decoder.next_out_of_line();
3791 let handles_before = decoder.remaining_handles();
3792 if let Some((inlined, num_bytes, num_handles)) =
3793 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3794 {
3795 let member_inline_size =
3796 <fidl_fuchsia_mem::Data as fidl::encoding::TypeMarker>::inline_size(
3797 decoder.context,
3798 );
3799 if inlined != (member_inline_size <= 4) {
3800 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3801 }
3802 let inner_offset;
3803 let mut inner_depth = depth.clone();
3804 if inlined {
3805 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3806 inner_offset = next_offset;
3807 } else {
3808 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3809 inner_depth.increment()?;
3810 }
3811 let val_ref = self.encoded_config.get_or_insert_with(|| {
3812 fidl::new_empty!(
3813 fidl_fuchsia_mem::Data,
3814 fidl::encoding::DefaultFuchsiaResourceDialect
3815 )
3816 });
3817 fidl::decode!(
3818 fidl_fuchsia_mem::Data,
3819 fidl::encoding::DefaultFuchsiaResourceDialect,
3820 val_ref,
3821 decoder,
3822 inner_offset,
3823 inner_depth
3824 )?;
3825 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3826 {
3827 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3828 }
3829 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3830 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3831 }
3832 }
3833
3834 next_offset += envelope_size;
3835 _next_ordinal_to_read += 1;
3836 if next_offset >= end_offset {
3837 return Ok(());
3838 }
3839
3840 while _next_ordinal_to_read < 8 {
3842 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3843 _next_ordinal_to_read += 1;
3844 next_offset += envelope_size;
3845 }
3846
3847 let next_out_of_line = decoder.next_out_of_line();
3848 let handles_before = decoder.remaining_handles();
3849 if let Some((inlined, num_bytes, num_handles)) =
3850 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3851 {
3852 let member_inline_size = <fidl::encoding::HandleType<
3853 fidl::EventPair,
3854 { fidl::ObjectType::EVENTPAIR.into_raw() },
3855 2147483648,
3856 > as fidl::encoding::TypeMarker>::inline_size(
3857 decoder.context
3858 );
3859 if inlined != (member_inline_size <= 4) {
3860 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3861 }
3862 let inner_offset;
3863 let mut inner_depth = depth.clone();
3864 if inlined {
3865 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3866 inner_offset = next_offset;
3867 } else {
3868 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3869 inner_depth.increment()?;
3870 }
3871 let val_ref =
3872 self.break_on_start.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
3873 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
3874 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3875 {
3876 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3877 }
3878 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3879 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3880 }
3881 }
3882
3883 next_offset += envelope_size;
3884 _next_ordinal_to_read += 1;
3885 if next_offset >= end_offset {
3886 return Ok(());
3887 }
3888
3889 while _next_ordinal_to_read < 9 {
3891 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3892 _next_ordinal_to_read += 1;
3893 next_offset += envelope_size;
3894 }
3895
3896 let next_out_of_line = decoder.next_out_of_line();
3897 let handles_before = decoder.remaining_handles();
3898 if let Some((inlined, num_bytes, num_handles)) =
3899 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3900 {
3901 let member_inline_size = <fidl::encoding::HandleType<
3902 fidl::Event,
3903 { fidl::ObjectType::EVENT.into_raw() },
3904 2147483648,
3905 > as fidl::encoding::TypeMarker>::inline_size(
3906 decoder.context
3907 );
3908 if inlined != (member_inline_size <= 4) {
3909 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3910 }
3911 let inner_offset;
3912 let mut inner_depth = depth.clone();
3913 if inlined {
3914 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3915 inner_offset = next_offset;
3916 } else {
3917 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3918 inner_depth.increment()?;
3919 }
3920 let val_ref =
3921 self.component_instance.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
3922 fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
3923 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3924 {
3925 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3926 }
3927 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3928 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3929 }
3930 }
3931
3932 next_offset += envelope_size;
3933 _next_ordinal_to_read += 1;
3934 if next_offset >= end_offset {
3935 return Ok(());
3936 }
3937
3938 while _next_ordinal_to_read < 10 {
3940 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3941 _next_ordinal_to_read += 1;
3942 next_offset += envelope_size;
3943 }
3944
3945 let next_out_of_line = decoder.next_out_of_line();
3946 let handles_before = decoder.remaining_handles();
3947 if let Some((inlined, num_bytes, num_handles)) =
3948 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3949 {
3950 let member_inline_size = <fidl_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3951 if inlined != (member_inline_size <= 4) {
3952 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3953 }
3954 let inner_offset;
3955 let mut inner_depth = depth.clone();
3956 if inlined {
3957 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3958 inner_offset = next_offset;
3959 } else {
3960 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3961 inner_depth.increment()?;
3962 }
3963 let val_ref = self.escrowed_dictionary.get_or_insert_with(|| {
3964 fidl::new_empty!(
3965 fidl_fuchsia_component_sandbox::DictionaryRef,
3966 fidl::encoding::DefaultFuchsiaResourceDialect
3967 )
3968 });
3969 fidl::decode!(
3970 fidl_fuchsia_component_sandbox::DictionaryRef,
3971 fidl::encoding::DefaultFuchsiaResourceDialect,
3972 val_ref,
3973 decoder,
3974 inner_offset,
3975 inner_depth
3976 )?;
3977 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3978 {
3979 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3980 }
3981 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3982 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3983 }
3984 }
3985
3986 next_offset += envelope_size;
3987
3988 while next_offset < end_offset {
3990 _next_ordinal_to_read += 1;
3991 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3992 next_offset += envelope_size;
3993 }
3994
3995 Ok(())
3996 }
3997 }
3998
3999 impl ComponentStopInfo {
4000 #[inline(always)]
4001 fn max_ordinal_present(&self) -> u64 {
4002 if let Some(_) = self.exit_code {
4003 return 2;
4004 }
4005 if let Some(_) = self.termination_status {
4006 return 1;
4007 }
4008 0
4009 }
4010 }
4011
4012 impl fidl::encoding::ResourceTypeMarker for ComponentStopInfo {
4013 type Borrowed<'a> = &'a mut Self;
4014 fn take_or_borrow<'a>(
4015 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4016 ) -> Self::Borrowed<'a> {
4017 value
4018 }
4019 }
4020
4021 unsafe impl fidl::encoding::TypeMarker for ComponentStopInfo {
4022 type Owned = Self;
4023
4024 #[inline(always)]
4025 fn inline_align(_context: fidl::encoding::Context) -> usize {
4026 8
4027 }
4028
4029 #[inline(always)]
4030 fn inline_size(_context: fidl::encoding::Context) -> usize {
4031 16
4032 }
4033 }
4034
4035 unsafe impl
4036 fidl::encoding::Encode<ComponentStopInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
4037 for &mut ComponentStopInfo
4038 {
4039 unsafe fn encode(
4040 self,
4041 encoder: &mut fidl::encoding::Encoder<
4042 '_,
4043 fidl::encoding::DefaultFuchsiaResourceDialect,
4044 >,
4045 offset: usize,
4046 mut depth: fidl::encoding::Depth,
4047 ) -> fidl::Result<()> {
4048 encoder.debug_check_bounds::<ComponentStopInfo>(offset);
4049 let max_ordinal: u64 = self.max_ordinal_present();
4051 encoder.write_num(max_ordinal, offset);
4052 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4053 if max_ordinal == 0 {
4055 return Ok(());
4056 }
4057 depth.increment()?;
4058 let envelope_size = 8;
4059 let bytes_len = max_ordinal as usize * envelope_size;
4060 #[allow(unused_variables)]
4061 let offset = encoder.out_of_line_offset(bytes_len);
4062 let mut _prev_end_offset: usize = 0;
4063 if 1 > max_ordinal {
4064 return Ok(());
4065 }
4066
4067 let cur_offset: usize = (1 - 1) * envelope_size;
4070
4071 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4073
4074 fidl::encoding::encode_in_envelope_optional::<
4079 i32,
4080 fidl::encoding::DefaultFuchsiaResourceDialect,
4081 >(
4082 self.termination_status
4083 .as_ref()
4084 .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
4085 encoder,
4086 offset + cur_offset,
4087 depth,
4088 )?;
4089
4090 _prev_end_offset = cur_offset + envelope_size;
4091 if 2 > max_ordinal {
4092 return Ok(());
4093 }
4094
4095 let cur_offset: usize = (2 - 1) * envelope_size;
4098
4099 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4101
4102 fidl::encoding::encode_in_envelope_optional::<
4107 i64,
4108 fidl::encoding::DefaultFuchsiaResourceDialect,
4109 >(
4110 self.exit_code.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4111 encoder,
4112 offset + cur_offset,
4113 depth,
4114 )?;
4115
4116 _prev_end_offset = cur_offset + envelope_size;
4117
4118 Ok(())
4119 }
4120 }
4121
4122 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
4123 for ComponentStopInfo
4124 {
4125 #[inline(always)]
4126 fn new_empty() -> Self {
4127 Self::default()
4128 }
4129
4130 unsafe fn decode(
4131 &mut self,
4132 decoder: &mut fidl::encoding::Decoder<
4133 '_,
4134 fidl::encoding::DefaultFuchsiaResourceDialect,
4135 >,
4136 offset: usize,
4137 mut depth: fidl::encoding::Depth,
4138 ) -> fidl::Result<()> {
4139 decoder.debug_check_bounds::<Self>(offset);
4140 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4141 None => return Err(fidl::Error::NotNullable),
4142 Some(len) => len,
4143 };
4144 if len == 0 {
4146 return Ok(());
4147 };
4148 depth.increment()?;
4149 let envelope_size = 8;
4150 let bytes_len = len * envelope_size;
4151 let offset = decoder.out_of_line_offset(bytes_len)?;
4152 let mut _next_ordinal_to_read = 0;
4154 let mut next_offset = offset;
4155 let end_offset = offset + bytes_len;
4156 _next_ordinal_to_read += 1;
4157 if next_offset >= end_offset {
4158 return Ok(());
4159 }
4160
4161 while _next_ordinal_to_read < 1 {
4163 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4164 _next_ordinal_to_read += 1;
4165 next_offset += envelope_size;
4166 }
4167
4168 let next_out_of_line = decoder.next_out_of_line();
4169 let handles_before = decoder.remaining_handles();
4170 if let Some((inlined, num_bytes, num_handles)) =
4171 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4172 {
4173 let member_inline_size =
4174 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4175 if inlined != (member_inline_size <= 4) {
4176 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4177 }
4178 let inner_offset;
4179 let mut inner_depth = depth.clone();
4180 if inlined {
4181 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4182 inner_offset = next_offset;
4183 } else {
4184 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4185 inner_depth.increment()?;
4186 }
4187 let val_ref = self.termination_status.get_or_insert_with(|| {
4188 fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
4189 });
4190 fidl::decode!(
4191 i32,
4192 fidl::encoding::DefaultFuchsiaResourceDialect,
4193 val_ref,
4194 decoder,
4195 inner_offset,
4196 inner_depth
4197 )?;
4198 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4199 {
4200 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4201 }
4202 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4203 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4204 }
4205 }
4206
4207 next_offset += envelope_size;
4208 _next_ordinal_to_read += 1;
4209 if next_offset >= end_offset {
4210 return Ok(());
4211 }
4212
4213 while _next_ordinal_to_read < 2 {
4215 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4216 _next_ordinal_to_read += 1;
4217 next_offset += envelope_size;
4218 }
4219
4220 let next_out_of_line = decoder.next_out_of_line();
4221 let handles_before = decoder.remaining_handles();
4222 if let Some((inlined, num_bytes, num_handles)) =
4223 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4224 {
4225 let member_inline_size =
4226 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4227 if inlined != (member_inline_size <= 4) {
4228 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4229 }
4230 let inner_offset;
4231 let mut inner_depth = depth.clone();
4232 if inlined {
4233 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4234 inner_offset = next_offset;
4235 } else {
4236 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4237 inner_depth.increment()?;
4238 }
4239 let val_ref = self.exit_code.get_or_insert_with(|| {
4240 fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
4241 });
4242 fidl::decode!(
4243 i64,
4244 fidl::encoding::DefaultFuchsiaResourceDialect,
4245 val_ref,
4246 decoder,
4247 inner_offset,
4248 inner_depth
4249 )?;
4250 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4251 {
4252 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4253 }
4254 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4255 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4256 }
4257 }
4258
4259 next_offset += envelope_size;
4260
4261 while next_offset < end_offset {
4263 _next_ordinal_to_read += 1;
4264 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4265 next_offset += envelope_size;
4266 }
4267
4268 Ok(())
4269 }
4270 }
4271
4272 impl ComponentTasks {
4273 #[inline(always)]
4274 fn max_ordinal_present(&self) -> u64 {
4275 if let Some(_) = self.parent_task {
4276 return 2;
4277 }
4278 if let Some(_) = self.component_task {
4279 return 1;
4280 }
4281 0
4282 }
4283 }
4284
4285 impl fidl::encoding::ResourceTypeMarker for ComponentTasks {
4286 type Borrowed<'a> = &'a mut Self;
4287 fn take_or_borrow<'a>(
4288 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4289 ) -> Self::Borrowed<'a> {
4290 value
4291 }
4292 }
4293
4294 unsafe impl fidl::encoding::TypeMarker for ComponentTasks {
4295 type Owned = Self;
4296
4297 #[inline(always)]
4298 fn inline_align(_context: fidl::encoding::Context) -> usize {
4299 8
4300 }
4301
4302 #[inline(always)]
4303 fn inline_size(_context: fidl::encoding::Context) -> usize {
4304 16
4305 }
4306 }
4307
4308 unsafe impl
4309 fidl::encoding::Encode<ComponentTasks, fidl::encoding::DefaultFuchsiaResourceDialect>
4310 for &mut ComponentTasks
4311 {
4312 unsafe fn encode(
4313 self,
4314 encoder: &mut fidl::encoding::Encoder<
4315 '_,
4316 fidl::encoding::DefaultFuchsiaResourceDialect,
4317 >,
4318 offset: usize,
4319 mut depth: fidl::encoding::Depth,
4320 ) -> fidl::Result<()> {
4321 encoder.debug_check_bounds::<ComponentTasks>(offset);
4322 let max_ordinal: u64 = self.max_ordinal_present();
4324 encoder.write_num(max_ordinal, offset);
4325 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4326 if max_ordinal == 0 {
4328 return Ok(());
4329 }
4330 depth.increment()?;
4331 let envelope_size = 8;
4332 let bytes_len = max_ordinal as usize * envelope_size;
4333 #[allow(unused_variables)]
4334 let offset = encoder.out_of_line_offset(bytes_len);
4335 let mut _prev_end_offset: usize = 0;
4336 if 1 > max_ordinal {
4337 return Ok(());
4338 }
4339
4340 let cur_offset: usize = (1 - 1) * envelope_size;
4343
4344 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4346
4347 fidl::encoding::encode_in_envelope_optional::<
4352 Task,
4353 fidl::encoding::DefaultFuchsiaResourceDialect,
4354 >(
4355 self.component_task
4356 .as_mut()
4357 .map(<Task as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
4358 encoder,
4359 offset + cur_offset,
4360 depth,
4361 )?;
4362
4363 _prev_end_offset = cur_offset + envelope_size;
4364 if 2 > max_ordinal {
4365 return Ok(());
4366 }
4367
4368 let cur_offset: usize = (2 - 1) * envelope_size;
4371
4372 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4374
4375 fidl::encoding::encode_in_envelope_optional::<
4380 Task,
4381 fidl::encoding::DefaultFuchsiaResourceDialect,
4382 >(
4383 self.parent_task
4384 .as_mut()
4385 .map(<Task as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
4386 encoder,
4387 offset + cur_offset,
4388 depth,
4389 )?;
4390
4391 _prev_end_offset = cur_offset + envelope_size;
4392
4393 Ok(())
4394 }
4395 }
4396
4397 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
4398 for ComponentTasks
4399 {
4400 #[inline(always)]
4401 fn new_empty() -> Self {
4402 Self::default()
4403 }
4404
4405 unsafe fn decode(
4406 &mut self,
4407 decoder: &mut fidl::encoding::Decoder<
4408 '_,
4409 fidl::encoding::DefaultFuchsiaResourceDialect,
4410 >,
4411 offset: usize,
4412 mut depth: fidl::encoding::Depth,
4413 ) -> fidl::Result<()> {
4414 decoder.debug_check_bounds::<Self>(offset);
4415 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4416 None => return Err(fidl::Error::NotNullable),
4417 Some(len) => len,
4418 };
4419 if len == 0 {
4421 return Ok(());
4422 };
4423 depth.increment()?;
4424 let envelope_size = 8;
4425 let bytes_len = len * envelope_size;
4426 let offset = decoder.out_of_line_offset(bytes_len)?;
4427 let mut _next_ordinal_to_read = 0;
4429 let mut next_offset = offset;
4430 let end_offset = offset + bytes_len;
4431 _next_ordinal_to_read += 1;
4432 if next_offset >= end_offset {
4433 return Ok(());
4434 }
4435
4436 while _next_ordinal_to_read < 1 {
4438 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4439 _next_ordinal_to_read += 1;
4440 next_offset += envelope_size;
4441 }
4442
4443 let next_out_of_line = decoder.next_out_of_line();
4444 let handles_before = decoder.remaining_handles();
4445 if let Some((inlined, num_bytes, num_handles)) =
4446 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4447 {
4448 let member_inline_size =
4449 <Task as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4450 if inlined != (member_inline_size <= 4) {
4451 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4452 }
4453 let inner_offset;
4454 let mut inner_depth = depth.clone();
4455 if inlined {
4456 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4457 inner_offset = next_offset;
4458 } else {
4459 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4460 inner_depth.increment()?;
4461 }
4462 let val_ref = self.component_task.get_or_insert_with(|| {
4463 fidl::new_empty!(Task, fidl::encoding::DefaultFuchsiaResourceDialect)
4464 });
4465 fidl::decode!(
4466 Task,
4467 fidl::encoding::DefaultFuchsiaResourceDialect,
4468 val_ref,
4469 decoder,
4470 inner_offset,
4471 inner_depth
4472 )?;
4473 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4474 {
4475 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4476 }
4477 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4478 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4479 }
4480 }
4481
4482 next_offset += envelope_size;
4483 _next_ordinal_to_read += 1;
4484 if next_offset >= end_offset {
4485 return Ok(());
4486 }
4487
4488 while _next_ordinal_to_read < 2 {
4490 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4491 _next_ordinal_to_read += 1;
4492 next_offset += envelope_size;
4493 }
4494
4495 let next_out_of_line = decoder.next_out_of_line();
4496 let handles_before = decoder.remaining_handles();
4497 if let Some((inlined, num_bytes, num_handles)) =
4498 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4499 {
4500 let member_inline_size =
4501 <Task as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4502 if inlined != (member_inline_size <= 4) {
4503 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4504 }
4505 let inner_offset;
4506 let mut inner_depth = depth.clone();
4507 if inlined {
4508 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4509 inner_offset = next_offset;
4510 } else {
4511 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4512 inner_depth.increment()?;
4513 }
4514 let val_ref = self.parent_task.get_or_insert_with(|| {
4515 fidl::new_empty!(Task, fidl::encoding::DefaultFuchsiaResourceDialect)
4516 });
4517 fidl::decode!(
4518 Task,
4519 fidl::encoding::DefaultFuchsiaResourceDialect,
4520 val_ref,
4521 decoder,
4522 inner_offset,
4523 inner_depth
4524 )?;
4525 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4526 {
4527 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4528 }
4529 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4530 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4531 }
4532 }
4533
4534 next_offset += envelope_size;
4535
4536 while next_offset < end_offset {
4538 _next_ordinal_to_read += 1;
4539 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4540 next_offset += envelope_size;
4541 }
4542
4543 Ok(())
4544 }
4545 }
4546
4547 impl fidl::encoding::ResourceTypeMarker for Task {
4548 type Borrowed<'a> = &'a mut Self;
4549 fn take_or_borrow<'a>(
4550 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4551 ) -> Self::Borrowed<'a> {
4552 value
4553 }
4554 }
4555
4556 unsafe impl fidl::encoding::TypeMarker for Task {
4557 type Owned = Self;
4558
4559 #[inline(always)]
4560 fn inline_align(_context: fidl::encoding::Context) -> usize {
4561 8
4562 }
4563
4564 #[inline(always)]
4565 fn inline_size(_context: fidl::encoding::Context) -> usize {
4566 16
4567 }
4568 }
4569
4570 unsafe impl fidl::encoding::Encode<Task, fidl::encoding::DefaultFuchsiaResourceDialect>
4571 for &mut Task
4572 {
4573 #[inline]
4574 unsafe fn encode(
4575 self,
4576 encoder: &mut fidl::encoding::Encoder<
4577 '_,
4578 fidl::encoding::DefaultFuchsiaResourceDialect,
4579 >,
4580 offset: usize,
4581 _depth: fidl::encoding::Depth,
4582 ) -> fidl::Result<()> {
4583 encoder.debug_check_bounds::<Task>(offset);
4584 encoder.write_num::<u64>(self.ordinal(), offset);
4585 match self {
4586 Task::Job(ref mut val) => fidl::encoding::encode_in_envelope::<
4587 fidl::encoding::HandleType<
4588 fidl::Job,
4589 { fidl::ObjectType::JOB.into_raw() },
4590 2147483648,
4591 >,
4592 fidl::encoding::DefaultFuchsiaResourceDialect,
4593 >(
4594 <fidl::encoding::HandleType<
4595 fidl::Job,
4596 { fidl::ObjectType::JOB.into_raw() },
4597 2147483648,
4598 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
4599 val
4600 ),
4601 encoder,
4602 offset + 8,
4603 _depth,
4604 ),
4605 Task::Process(ref mut val) => fidl::encoding::encode_in_envelope::<
4606 fidl::encoding::HandleType<
4607 fidl::Process,
4608 { fidl::ObjectType::PROCESS.into_raw() },
4609 2147483648,
4610 >,
4611 fidl::encoding::DefaultFuchsiaResourceDialect,
4612 >(
4613 <fidl::encoding::HandleType<
4614 fidl::Process,
4615 { fidl::ObjectType::PROCESS.into_raw() },
4616 2147483648,
4617 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
4618 val
4619 ),
4620 encoder,
4621 offset + 8,
4622 _depth,
4623 ),
4624 Task::Thread(ref mut val) => fidl::encoding::encode_in_envelope::<
4625 fidl::encoding::HandleType<
4626 fidl::Thread,
4627 { fidl::ObjectType::THREAD.into_raw() },
4628 2147483648,
4629 >,
4630 fidl::encoding::DefaultFuchsiaResourceDialect,
4631 >(
4632 <fidl::encoding::HandleType<
4633 fidl::Thread,
4634 { fidl::ObjectType::THREAD.into_raw() },
4635 2147483648,
4636 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
4637 val
4638 ),
4639 encoder,
4640 offset + 8,
4641 _depth,
4642 ),
4643 Task::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4644 }
4645 }
4646 }
4647
4648 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Task {
4649 #[inline(always)]
4650 fn new_empty() -> Self {
4651 Self::__SourceBreaking { unknown_ordinal: 0 }
4652 }
4653
4654 #[inline]
4655 unsafe fn decode(
4656 &mut self,
4657 decoder: &mut fidl::encoding::Decoder<
4658 '_,
4659 fidl::encoding::DefaultFuchsiaResourceDialect,
4660 >,
4661 offset: usize,
4662 mut depth: fidl::encoding::Depth,
4663 ) -> fidl::Result<()> {
4664 decoder.debug_check_bounds::<Self>(offset);
4665 #[allow(unused_variables)]
4666 let next_out_of_line = decoder.next_out_of_line();
4667 let handles_before = decoder.remaining_handles();
4668 let (ordinal, inlined, num_bytes, num_handles) =
4669 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4670
4671 let member_inline_size = match ordinal {
4672 1 => <fidl::encoding::HandleType<
4673 fidl::Job,
4674 { fidl::ObjectType::JOB.into_raw() },
4675 2147483648,
4676 > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4677 2 => <fidl::encoding::HandleType<
4678 fidl::Process,
4679 { fidl::ObjectType::PROCESS.into_raw() },
4680 2147483648,
4681 > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4682 3 => <fidl::encoding::HandleType<
4683 fidl::Thread,
4684 { fidl::ObjectType::THREAD.into_raw() },
4685 2147483648,
4686 > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4687 0 => return Err(fidl::Error::UnknownUnionTag),
4688 _ => num_bytes as usize,
4689 };
4690
4691 if inlined != (member_inline_size <= 4) {
4692 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4693 }
4694 let _inner_offset;
4695 if inlined {
4696 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4697 _inner_offset = offset + 8;
4698 } else {
4699 depth.increment()?;
4700 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4701 }
4702 match ordinal {
4703 1 => {
4704 #[allow(irrefutable_let_patterns)]
4705 if let Task::Job(_) = self {
4706 } else {
4708 *self = Task::Job(
4710 fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
4711 );
4712 }
4713 #[allow(irrefutable_let_patterns)]
4714 if let Task::Job(ref mut val) = self {
4715 fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
4716 } else {
4717 unreachable!()
4718 }
4719 }
4720 2 => {
4721 #[allow(irrefutable_let_patterns)]
4722 if let Task::Process(_) = self {
4723 } else {
4725 *self = Task::Process(
4727 fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
4728 );
4729 }
4730 #[allow(irrefutable_let_patterns)]
4731 if let Task::Process(ref mut val) = self {
4732 fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
4733 } else {
4734 unreachable!()
4735 }
4736 }
4737 3 => {
4738 #[allow(irrefutable_let_patterns)]
4739 if let Task::Thread(_) = self {
4740 } else {
4742 *self = Task::Thread(
4744 fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
4745 );
4746 }
4747 #[allow(irrefutable_let_patterns)]
4748 if let Task::Thread(ref mut val) = self {
4749 fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
4750 } else {
4751 unreachable!()
4752 }
4753 }
4754 #[allow(deprecated)]
4755 ordinal => {
4756 for _ in 0..num_handles {
4757 decoder.drop_next_handle()?;
4758 }
4759 *self = Task::__SourceBreaking { unknown_ordinal: ordinal };
4760 }
4761 }
4762 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4763 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4764 }
4765 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4766 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4767 }
4768 Ok(())
4769 }
4770 }
4771}