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_starnix_runner__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct ManagerCreatePagerRequest {
16 pub backing_vmo: Option<fidl::Vmo>,
18 pub block_size: Option<u64>,
20 pub pager: Option<fidl::endpoints::ServerEnd<PagerMarker>>,
22 #[doc(hidden)]
23 pub __source_breaking: fidl::marker::SourceBreaking,
24}
25
26impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ManagerCreatePagerRequest {}
27
28#[derive(Debug, Default, PartialEq)]
29pub struct ManagerProxyWakeChannelRequest {
30 pub container_job: Option<fidl::Job>,
32 pub container_channel: Option<fidl::Channel>,
34 pub remote_channel: Option<fidl::Channel>,
36 pub name: Option<String>,
38 pub counter: Option<fidl::Counter>,
46 #[doc(hidden)]
47 pub __source_breaking: fidl::marker::SourceBreaking,
48}
49
50impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
51 for ManagerProxyWakeChannelRequest
52{
53}
54
55#[derive(Debug, Default, PartialEq)]
56pub struct ManagerRegisterWakeWatcherRequest {
57 pub watcher: Option<fidl::EventPair>,
59 #[doc(hidden)]
60 pub __source_breaking: fidl::marker::SourceBreaking,
61}
62
63impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
64 for ManagerRegisterWakeWatcherRequest
65{
66}
67
68#[derive(Debug, Default, PartialEq)]
69pub struct ManagerSuspendContainerRequest {
70 pub container_job: Option<fidl::Job>,
72 pub wake_locks: Option<fidl::EventPair>,
75 #[doc(hidden)]
76 pub __source_breaking: fidl::marker::SourceBreaking,
77}
78
79impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
80 for ManagerSuspendContainerRequest
81{
82}
83
84#[derive(Debug, Default, PartialEq)]
85pub struct PagerRegisterFileResponse {
86 pub vmo: Option<fidl::Vmo>,
88 #[doc(hidden)]
89 pub __source_breaking: fidl::marker::SourceBreaking,
90}
91
92impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for PagerRegisterFileResponse {}
93
94#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
95pub struct ManagerMarker;
96
97impl fidl::endpoints::ProtocolMarker for ManagerMarker {
98 type Proxy = ManagerProxy;
99 type RequestStream = ManagerRequestStream;
100 #[cfg(target_os = "fuchsia")]
101 type SynchronousProxy = ManagerSynchronousProxy;
102
103 const DEBUG_NAME: &'static str = "fuchsia.starnix.runner.Manager";
104}
105impl fidl::endpoints::DiscoverableProtocolMarker for ManagerMarker {}
106pub type ManagerSuspendContainerResult = Result<ManagerSuspendContainerResponse, SuspendError>;
107
108pub trait ManagerProxyInterface: Send + Sync {
109 type SuspendContainerResponseFut: std::future::Future<Output = Result<ManagerSuspendContainerResult, fidl::Error>>
110 + Send;
111 fn r#suspend_container(
112 &self,
113 payload: ManagerSuspendContainerRequest,
114 ) -> Self::SuspendContainerResponseFut;
115 fn r#proxy_wake_channel(
116 &self,
117 payload: ManagerProxyWakeChannelRequest,
118 ) -> Result<(), fidl::Error>;
119 type RegisterWakeWatcherResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
120 + Send;
121 fn r#register_wake_watcher(
122 &self,
123 payload: ManagerRegisterWakeWatcherRequest,
124 ) -> Self::RegisterWakeWatcherResponseFut;
125 fn r#create_pager(&self, payload: ManagerCreatePagerRequest) -> Result<(), fidl::Error>;
126}
127#[derive(Debug)]
128#[cfg(target_os = "fuchsia")]
129pub struct ManagerSynchronousProxy {
130 client: fidl::client::sync::Client,
131}
132
133#[cfg(target_os = "fuchsia")]
134impl fidl::endpoints::SynchronousProxy for ManagerSynchronousProxy {
135 type Proxy = ManagerProxy;
136 type Protocol = ManagerMarker;
137
138 fn from_channel(inner: fidl::Channel) -> Self {
139 Self::new(inner)
140 }
141
142 fn into_channel(self) -> fidl::Channel {
143 self.client.into_channel()
144 }
145
146 fn as_channel(&self) -> &fidl::Channel {
147 self.client.as_channel()
148 }
149}
150
151#[cfg(target_os = "fuchsia")]
152impl ManagerSynchronousProxy {
153 pub fn new(channel: fidl::Channel) -> Self {
154 let protocol_name = <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
155 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
156 }
157
158 pub fn into_channel(self) -> fidl::Channel {
159 self.client.into_channel()
160 }
161
162 pub fn wait_for_event(
165 &self,
166 deadline: zx::MonotonicInstant,
167 ) -> Result<ManagerEvent, fidl::Error> {
168 ManagerEvent::decode(self.client.wait_for_event(deadline)?)
169 }
170
171 pub fn r#suspend_container(
177 &self,
178 mut payload: ManagerSuspendContainerRequest,
179 ___deadline: zx::MonotonicInstant,
180 ) -> Result<ManagerSuspendContainerResult, fidl::Error> {
181 let _response = self.client.send_query::<
182 ManagerSuspendContainerRequest,
183 fidl::encoding::FlexibleResultType<ManagerSuspendContainerResponse, SuspendError>,
184 >(
185 &mut payload,
186 0x928527927c9f2a7,
187 fidl::encoding::DynamicFlags::FLEXIBLE,
188 ___deadline,
189 )?
190 .into_result::<ManagerMarker>("suspend_container")?;
191 Ok(_response.map(|x| x))
192 }
193
194 pub fn r#proxy_wake_channel(
203 &self,
204 mut payload: ManagerProxyWakeChannelRequest,
205 ) -> Result<(), fidl::Error> {
206 self.client.send::<ManagerProxyWakeChannelRequest>(
207 &mut payload,
208 0x46a374ab73b23714,
209 fidl::encoding::DynamicFlags::FLEXIBLE,
210 )
211 }
212
213 pub fn r#register_wake_watcher(
218 &self,
219 mut payload: ManagerRegisterWakeWatcherRequest,
220 ___deadline: zx::MonotonicInstant,
221 ) -> Result<(), fidl::Error> {
222 let _response = self.client.send_query::<
223 ManagerRegisterWakeWatcherRequest,
224 fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
225 >(
226 &mut payload,
227 0x456d74519eb65b41,
228 fidl::encoding::DynamicFlags::FLEXIBLE,
229 ___deadline,
230 )?
231 .into_result::<ManagerMarker>("register_wake_watcher")?;
232 Ok(_response)
233 }
234
235 pub fn r#create_pager(
237 &self,
238 mut payload: ManagerCreatePagerRequest,
239 ) -> Result<(), fidl::Error> {
240 self.client.send::<ManagerCreatePagerRequest>(
241 &mut payload,
242 0x49d14958b736198b,
243 fidl::encoding::DynamicFlags::FLEXIBLE,
244 )
245 }
246}
247
248#[cfg(target_os = "fuchsia")]
249impl From<ManagerSynchronousProxy> for zx::Handle {
250 fn from(value: ManagerSynchronousProxy) -> Self {
251 value.into_channel().into()
252 }
253}
254
255#[cfg(target_os = "fuchsia")]
256impl From<fidl::Channel> for ManagerSynchronousProxy {
257 fn from(value: fidl::Channel) -> Self {
258 Self::new(value)
259 }
260}
261
262#[derive(Debug, Clone)]
263pub struct ManagerProxy {
264 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
265}
266
267impl fidl::endpoints::Proxy for ManagerProxy {
268 type Protocol = ManagerMarker;
269
270 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
271 Self::new(inner)
272 }
273
274 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
275 self.client.into_channel().map_err(|client| Self { client })
276 }
277
278 fn as_channel(&self) -> &::fidl::AsyncChannel {
279 self.client.as_channel()
280 }
281}
282
283impl ManagerProxy {
284 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
286 let protocol_name = <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
287 Self { client: fidl::client::Client::new(channel, protocol_name) }
288 }
289
290 pub fn take_event_stream(&self) -> ManagerEventStream {
296 ManagerEventStream { event_receiver: self.client.take_event_receiver() }
297 }
298
299 pub fn r#suspend_container(
305 &self,
306 mut payload: ManagerSuspendContainerRequest,
307 ) -> fidl::client::QueryResponseFut<
308 ManagerSuspendContainerResult,
309 fidl::encoding::DefaultFuchsiaResourceDialect,
310 > {
311 ManagerProxyInterface::r#suspend_container(self, payload)
312 }
313
314 pub fn r#proxy_wake_channel(
323 &self,
324 mut payload: ManagerProxyWakeChannelRequest,
325 ) -> Result<(), fidl::Error> {
326 ManagerProxyInterface::r#proxy_wake_channel(self, payload)
327 }
328
329 pub fn r#register_wake_watcher(
334 &self,
335 mut payload: ManagerRegisterWakeWatcherRequest,
336 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
337 ManagerProxyInterface::r#register_wake_watcher(self, payload)
338 }
339
340 pub fn r#create_pager(
342 &self,
343 mut payload: ManagerCreatePagerRequest,
344 ) -> Result<(), fidl::Error> {
345 ManagerProxyInterface::r#create_pager(self, payload)
346 }
347}
348
349impl ManagerProxyInterface for ManagerProxy {
350 type SuspendContainerResponseFut = fidl::client::QueryResponseFut<
351 ManagerSuspendContainerResult,
352 fidl::encoding::DefaultFuchsiaResourceDialect,
353 >;
354 fn r#suspend_container(
355 &self,
356 mut payload: ManagerSuspendContainerRequest,
357 ) -> Self::SuspendContainerResponseFut {
358 fn _decode(
359 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
360 ) -> Result<ManagerSuspendContainerResult, fidl::Error> {
361 let _response = fidl::client::decode_transaction_body::<
362 fidl::encoding::FlexibleResultType<ManagerSuspendContainerResponse, SuspendError>,
363 fidl::encoding::DefaultFuchsiaResourceDialect,
364 0x928527927c9f2a7,
365 >(_buf?)?
366 .into_result::<ManagerMarker>("suspend_container")?;
367 Ok(_response.map(|x| x))
368 }
369 self.client
370 .send_query_and_decode::<ManagerSuspendContainerRequest, ManagerSuspendContainerResult>(
371 &mut payload,
372 0x928527927c9f2a7,
373 fidl::encoding::DynamicFlags::FLEXIBLE,
374 _decode,
375 )
376 }
377
378 fn r#proxy_wake_channel(
379 &self,
380 mut payload: ManagerProxyWakeChannelRequest,
381 ) -> Result<(), fidl::Error> {
382 self.client.send::<ManagerProxyWakeChannelRequest>(
383 &mut payload,
384 0x46a374ab73b23714,
385 fidl::encoding::DynamicFlags::FLEXIBLE,
386 )
387 }
388
389 type RegisterWakeWatcherResponseFut =
390 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
391 fn r#register_wake_watcher(
392 &self,
393 mut payload: ManagerRegisterWakeWatcherRequest,
394 ) -> Self::RegisterWakeWatcherResponseFut {
395 fn _decode(
396 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
397 ) -> Result<(), fidl::Error> {
398 let _response = fidl::client::decode_transaction_body::<
399 fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
400 fidl::encoding::DefaultFuchsiaResourceDialect,
401 0x456d74519eb65b41,
402 >(_buf?)?
403 .into_result::<ManagerMarker>("register_wake_watcher")?;
404 Ok(_response)
405 }
406 self.client.send_query_and_decode::<ManagerRegisterWakeWatcherRequest, ()>(
407 &mut payload,
408 0x456d74519eb65b41,
409 fidl::encoding::DynamicFlags::FLEXIBLE,
410 _decode,
411 )
412 }
413
414 fn r#create_pager(&self, mut payload: ManagerCreatePagerRequest) -> Result<(), fidl::Error> {
415 self.client.send::<ManagerCreatePagerRequest>(
416 &mut payload,
417 0x49d14958b736198b,
418 fidl::encoding::DynamicFlags::FLEXIBLE,
419 )
420 }
421}
422
423pub struct ManagerEventStream {
424 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
425}
426
427impl std::marker::Unpin for ManagerEventStream {}
428
429impl futures::stream::FusedStream for ManagerEventStream {
430 fn is_terminated(&self) -> bool {
431 self.event_receiver.is_terminated()
432 }
433}
434
435impl futures::Stream for ManagerEventStream {
436 type Item = Result<ManagerEvent, fidl::Error>;
437
438 fn poll_next(
439 mut self: std::pin::Pin<&mut Self>,
440 cx: &mut std::task::Context<'_>,
441 ) -> std::task::Poll<Option<Self::Item>> {
442 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
443 &mut self.event_receiver,
444 cx
445 )?) {
446 Some(buf) => std::task::Poll::Ready(Some(ManagerEvent::decode(buf))),
447 None => std::task::Poll::Ready(None),
448 }
449 }
450}
451
452#[derive(Debug)]
453pub enum ManagerEvent {
454 #[non_exhaustive]
455 _UnknownEvent {
456 ordinal: u64,
458 },
459}
460
461impl ManagerEvent {
462 fn decode(
464 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
465 ) -> Result<ManagerEvent, fidl::Error> {
466 let (bytes, _handles) = buf.split_mut();
467 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
468 debug_assert_eq!(tx_header.tx_id, 0);
469 match tx_header.ordinal {
470 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
471 Ok(ManagerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
472 }
473 _ => Err(fidl::Error::UnknownOrdinal {
474 ordinal: tx_header.ordinal,
475 protocol_name: <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
476 }),
477 }
478 }
479}
480
481pub struct ManagerRequestStream {
483 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
484 is_terminated: bool,
485}
486
487impl std::marker::Unpin for ManagerRequestStream {}
488
489impl futures::stream::FusedStream for ManagerRequestStream {
490 fn is_terminated(&self) -> bool {
491 self.is_terminated
492 }
493}
494
495impl fidl::endpoints::RequestStream for ManagerRequestStream {
496 type Protocol = ManagerMarker;
497 type ControlHandle = ManagerControlHandle;
498
499 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
500 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
501 }
502
503 fn control_handle(&self) -> Self::ControlHandle {
504 ManagerControlHandle { inner: self.inner.clone() }
505 }
506
507 fn into_inner(
508 self,
509 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
510 {
511 (self.inner, self.is_terminated)
512 }
513
514 fn from_inner(
515 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
516 is_terminated: bool,
517 ) -> Self {
518 Self { inner, is_terminated }
519 }
520}
521
522impl futures::Stream for ManagerRequestStream {
523 type Item = Result<ManagerRequest, fidl::Error>;
524
525 fn poll_next(
526 mut self: std::pin::Pin<&mut Self>,
527 cx: &mut std::task::Context<'_>,
528 ) -> std::task::Poll<Option<Self::Item>> {
529 let this = &mut *self;
530 if this.inner.check_shutdown(cx) {
531 this.is_terminated = true;
532 return std::task::Poll::Ready(None);
533 }
534 if this.is_terminated {
535 panic!("polled ManagerRequestStream after completion");
536 }
537 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
538 |bytes, handles| {
539 match this.inner.channel().read_etc(cx, bytes, handles) {
540 std::task::Poll::Ready(Ok(())) => {}
541 std::task::Poll::Pending => return std::task::Poll::Pending,
542 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
543 this.is_terminated = true;
544 return std::task::Poll::Ready(None);
545 }
546 std::task::Poll::Ready(Err(e)) => {
547 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
548 e.into(),
549 ))))
550 }
551 }
552
553 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
555
556 std::task::Poll::Ready(Some(match header.ordinal {
557 0x928527927c9f2a7 => {
558 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
559 let mut req = fidl::new_empty!(
560 ManagerSuspendContainerRequest,
561 fidl::encoding::DefaultFuchsiaResourceDialect
562 );
563 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerSuspendContainerRequest>(&header, _body_bytes, handles, &mut req)?;
564 let control_handle = ManagerControlHandle { inner: this.inner.clone() };
565 Ok(ManagerRequest::SuspendContainer {
566 payload: req,
567 responder: ManagerSuspendContainerResponder {
568 control_handle: std::mem::ManuallyDrop::new(control_handle),
569 tx_id: header.tx_id,
570 },
571 })
572 }
573 0x46a374ab73b23714 => {
574 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
575 let mut req = fidl::new_empty!(
576 ManagerProxyWakeChannelRequest,
577 fidl::encoding::DefaultFuchsiaResourceDialect
578 );
579 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerProxyWakeChannelRequest>(&header, _body_bytes, handles, &mut req)?;
580 let control_handle = ManagerControlHandle { inner: this.inner.clone() };
581 Ok(ManagerRequest::ProxyWakeChannel { payload: req, control_handle })
582 }
583 0x456d74519eb65b41 => {
584 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
585 let mut req = fidl::new_empty!(
586 ManagerRegisterWakeWatcherRequest,
587 fidl::encoding::DefaultFuchsiaResourceDialect
588 );
589 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerRegisterWakeWatcherRequest>(&header, _body_bytes, handles, &mut req)?;
590 let control_handle = ManagerControlHandle { inner: this.inner.clone() };
591 Ok(ManagerRequest::RegisterWakeWatcher {
592 payload: req,
593 responder: ManagerRegisterWakeWatcherResponder {
594 control_handle: std::mem::ManuallyDrop::new(control_handle),
595 tx_id: header.tx_id,
596 },
597 })
598 }
599 0x49d14958b736198b => {
600 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
601 let mut req = fidl::new_empty!(
602 ManagerCreatePagerRequest,
603 fidl::encoding::DefaultFuchsiaResourceDialect
604 );
605 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerCreatePagerRequest>(&header, _body_bytes, handles, &mut req)?;
606 let control_handle = ManagerControlHandle { inner: this.inner.clone() };
607 Ok(ManagerRequest::CreatePager { payload: req, control_handle })
608 }
609 _ if header.tx_id == 0
610 && header
611 .dynamic_flags()
612 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
613 {
614 Ok(ManagerRequest::_UnknownMethod {
615 ordinal: header.ordinal,
616 control_handle: ManagerControlHandle { inner: this.inner.clone() },
617 method_type: fidl::MethodType::OneWay,
618 })
619 }
620 _ if header
621 .dynamic_flags()
622 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
623 {
624 this.inner.send_framework_err(
625 fidl::encoding::FrameworkErr::UnknownMethod,
626 header.tx_id,
627 header.ordinal,
628 header.dynamic_flags(),
629 (bytes, handles),
630 )?;
631 Ok(ManagerRequest::_UnknownMethod {
632 ordinal: header.ordinal,
633 control_handle: ManagerControlHandle { inner: this.inner.clone() },
634 method_type: fidl::MethodType::TwoWay,
635 })
636 }
637 _ => Err(fidl::Error::UnknownOrdinal {
638 ordinal: header.ordinal,
639 protocol_name:
640 <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
641 }),
642 }))
643 },
644 )
645 }
646}
647
648#[derive(Debug)]
649pub enum ManagerRequest {
650 SuspendContainer {
656 payload: ManagerSuspendContainerRequest,
657 responder: ManagerSuspendContainerResponder,
658 },
659 ProxyWakeChannel {
668 payload: ManagerProxyWakeChannelRequest,
669 control_handle: ManagerControlHandle,
670 },
671 RegisterWakeWatcher {
676 payload: ManagerRegisterWakeWatcherRequest,
677 responder: ManagerRegisterWakeWatcherResponder,
678 },
679 CreatePager { payload: ManagerCreatePagerRequest, control_handle: ManagerControlHandle },
681 #[non_exhaustive]
683 _UnknownMethod {
684 ordinal: u64,
686 control_handle: ManagerControlHandle,
687 method_type: fidl::MethodType,
688 },
689}
690
691impl ManagerRequest {
692 #[allow(irrefutable_let_patterns)]
693 pub fn into_suspend_container(
694 self,
695 ) -> Option<(ManagerSuspendContainerRequest, ManagerSuspendContainerResponder)> {
696 if let ManagerRequest::SuspendContainer { payload, responder } = self {
697 Some((payload, responder))
698 } else {
699 None
700 }
701 }
702
703 #[allow(irrefutable_let_patterns)]
704 pub fn into_proxy_wake_channel(
705 self,
706 ) -> Option<(ManagerProxyWakeChannelRequest, ManagerControlHandle)> {
707 if let ManagerRequest::ProxyWakeChannel { payload, control_handle } = self {
708 Some((payload, control_handle))
709 } else {
710 None
711 }
712 }
713
714 #[allow(irrefutable_let_patterns)]
715 pub fn into_register_wake_watcher(
716 self,
717 ) -> Option<(ManagerRegisterWakeWatcherRequest, ManagerRegisterWakeWatcherResponder)> {
718 if let ManagerRequest::RegisterWakeWatcher { payload, responder } = self {
719 Some((payload, responder))
720 } else {
721 None
722 }
723 }
724
725 #[allow(irrefutable_let_patterns)]
726 pub fn into_create_pager(self) -> Option<(ManagerCreatePagerRequest, ManagerControlHandle)> {
727 if let ManagerRequest::CreatePager { payload, control_handle } = self {
728 Some((payload, control_handle))
729 } else {
730 None
731 }
732 }
733
734 pub fn method_name(&self) -> &'static str {
736 match *self {
737 ManagerRequest::SuspendContainer { .. } => "suspend_container",
738 ManagerRequest::ProxyWakeChannel { .. } => "proxy_wake_channel",
739 ManagerRequest::RegisterWakeWatcher { .. } => "register_wake_watcher",
740 ManagerRequest::CreatePager { .. } => "create_pager",
741 ManagerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
742 "unknown one-way method"
743 }
744 ManagerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
745 "unknown two-way method"
746 }
747 }
748 }
749}
750
751#[derive(Debug, Clone)]
752pub struct ManagerControlHandle {
753 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
754}
755
756impl fidl::endpoints::ControlHandle for ManagerControlHandle {
757 fn shutdown(&self) {
758 self.inner.shutdown()
759 }
760 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
761 self.inner.shutdown_with_epitaph(status)
762 }
763
764 fn is_closed(&self) -> bool {
765 self.inner.channel().is_closed()
766 }
767 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
768 self.inner.channel().on_closed()
769 }
770
771 #[cfg(target_os = "fuchsia")]
772 fn signal_peer(
773 &self,
774 clear_mask: zx::Signals,
775 set_mask: zx::Signals,
776 ) -> Result<(), zx_status::Status> {
777 use fidl::Peered;
778 self.inner.channel().signal_peer(clear_mask, set_mask)
779 }
780}
781
782impl ManagerControlHandle {}
783
784#[must_use = "FIDL methods require a response to be sent"]
785#[derive(Debug)]
786pub struct ManagerSuspendContainerResponder {
787 control_handle: std::mem::ManuallyDrop<ManagerControlHandle>,
788 tx_id: u32,
789}
790
791impl std::ops::Drop for ManagerSuspendContainerResponder {
795 fn drop(&mut self) {
796 self.control_handle.shutdown();
797 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
799 }
800}
801
802impl fidl::endpoints::Responder for ManagerSuspendContainerResponder {
803 type ControlHandle = ManagerControlHandle;
804
805 fn control_handle(&self) -> &ManagerControlHandle {
806 &self.control_handle
807 }
808
809 fn drop_without_shutdown(mut self) {
810 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
812 std::mem::forget(self);
814 }
815}
816
817impl ManagerSuspendContainerResponder {
818 pub fn send(
822 self,
823 mut result: Result<&ManagerSuspendContainerResponse, SuspendError>,
824 ) -> Result<(), fidl::Error> {
825 let _result = self.send_raw(result);
826 if _result.is_err() {
827 self.control_handle.shutdown();
828 }
829 self.drop_without_shutdown();
830 _result
831 }
832
833 pub fn send_no_shutdown_on_err(
835 self,
836 mut result: Result<&ManagerSuspendContainerResponse, SuspendError>,
837 ) -> Result<(), fidl::Error> {
838 let _result = self.send_raw(result);
839 self.drop_without_shutdown();
840 _result
841 }
842
843 fn send_raw(
844 &self,
845 mut result: Result<&ManagerSuspendContainerResponse, SuspendError>,
846 ) -> Result<(), fidl::Error> {
847 self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
848 ManagerSuspendContainerResponse,
849 SuspendError,
850 >>(
851 fidl::encoding::FlexibleResult::new(result),
852 self.tx_id,
853 0x928527927c9f2a7,
854 fidl::encoding::DynamicFlags::FLEXIBLE,
855 )
856 }
857}
858
859#[must_use = "FIDL methods require a response to be sent"]
860#[derive(Debug)]
861pub struct ManagerRegisterWakeWatcherResponder {
862 control_handle: std::mem::ManuallyDrop<ManagerControlHandle>,
863 tx_id: u32,
864}
865
866impl std::ops::Drop for ManagerRegisterWakeWatcherResponder {
870 fn drop(&mut self) {
871 self.control_handle.shutdown();
872 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
874 }
875}
876
877impl fidl::endpoints::Responder for ManagerRegisterWakeWatcherResponder {
878 type ControlHandle = ManagerControlHandle;
879
880 fn control_handle(&self) -> &ManagerControlHandle {
881 &self.control_handle
882 }
883
884 fn drop_without_shutdown(mut self) {
885 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
887 std::mem::forget(self);
889 }
890}
891
892impl ManagerRegisterWakeWatcherResponder {
893 pub fn send(self) -> Result<(), fidl::Error> {
897 let _result = self.send_raw();
898 if _result.is_err() {
899 self.control_handle.shutdown();
900 }
901 self.drop_without_shutdown();
902 _result
903 }
904
905 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
907 let _result = self.send_raw();
908 self.drop_without_shutdown();
909 _result
910 }
911
912 fn send_raw(&self) -> Result<(), fidl::Error> {
913 self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
914 fidl::encoding::Flexible::new(()),
915 self.tx_id,
916 0x456d74519eb65b41,
917 fidl::encoding::DynamicFlags::FLEXIBLE,
918 )
919 }
920}
921
922#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
923pub struct PagerMarker;
924
925impl fidl::endpoints::ProtocolMarker for PagerMarker {
926 type Proxy = PagerProxy;
927 type RequestStream = PagerRequestStream;
928 #[cfg(target_os = "fuchsia")]
929 type SynchronousProxy = PagerSynchronousProxy;
930
931 const DEBUG_NAME: &'static str = "(anonymous) Pager";
932}
933pub type PagerRegisterFileResult = Result<PagerRegisterFileResponse, i32>;
934
935pub trait PagerProxyInterface: Send + Sync {
936 type RegisterFileResponseFut: std::future::Future<Output = Result<PagerRegisterFileResult, fidl::Error>>
937 + Send;
938 fn r#register_file(&self, payload: &PagerRegisterFileRequest) -> Self::RegisterFileResponseFut;
939}
940#[derive(Debug)]
941#[cfg(target_os = "fuchsia")]
942pub struct PagerSynchronousProxy {
943 client: fidl::client::sync::Client,
944}
945
946#[cfg(target_os = "fuchsia")]
947impl fidl::endpoints::SynchronousProxy for PagerSynchronousProxy {
948 type Proxy = PagerProxy;
949 type Protocol = PagerMarker;
950
951 fn from_channel(inner: fidl::Channel) -> Self {
952 Self::new(inner)
953 }
954
955 fn into_channel(self) -> fidl::Channel {
956 self.client.into_channel()
957 }
958
959 fn as_channel(&self) -> &fidl::Channel {
960 self.client.as_channel()
961 }
962}
963
964#[cfg(target_os = "fuchsia")]
965impl PagerSynchronousProxy {
966 pub fn new(channel: fidl::Channel) -> Self {
967 let protocol_name = <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
968 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
969 }
970
971 pub fn into_channel(self) -> fidl::Channel {
972 self.client.into_channel()
973 }
974
975 pub fn wait_for_event(
978 &self,
979 deadline: zx::MonotonicInstant,
980 ) -> Result<PagerEvent, fidl::Error> {
981 PagerEvent::decode(self.client.wait_for_event(deadline)?)
982 }
983
984 pub fn r#register_file(
986 &self,
987 mut payload: &PagerRegisterFileRequest,
988 ___deadline: zx::MonotonicInstant,
989 ) -> Result<PagerRegisterFileResult, fidl::Error> {
990 let _response = self.client.send_query::<
991 PagerRegisterFileRequest,
992 fidl::encoding::FlexibleResultType<PagerRegisterFileResponse, i32>,
993 >(
994 payload,
995 0x4f85a2ce6cae4aed,
996 fidl::encoding::DynamicFlags::FLEXIBLE,
997 ___deadline,
998 )?
999 .into_result::<PagerMarker>("register_file")?;
1000 Ok(_response.map(|x| x))
1001 }
1002}
1003
1004#[cfg(target_os = "fuchsia")]
1005impl From<PagerSynchronousProxy> for zx::Handle {
1006 fn from(value: PagerSynchronousProxy) -> Self {
1007 value.into_channel().into()
1008 }
1009}
1010
1011#[cfg(target_os = "fuchsia")]
1012impl From<fidl::Channel> for PagerSynchronousProxy {
1013 fn from(value: fidl::Channel) -> Self {
1014 Self::new(value)
1015 }
1016}
1017
1018#[derive(Debug, Clone)]
1019pub struct PagerProxy {
1020 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1021}
1022
1023impl fidl::endpoints::Proxy for PagerProxy {
1024 type Protocol = PagerMarker;
1025
1026 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1027 Self::new(inner)
1028 }
1029
1030 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1031 self.client.into_channel().map_err(|client| Self { client })
1032 }
1033
1034 fn as_channel(&self) -> &::fidl::AsyncChannel {
1035 self.client.as_channel()
1036 }
1037}
1038
1039impl PagerProxy {
1040 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1042 let protocol_name = <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1043 Self { client: fidl::client::Client::new(channel, protocol_name) }
1044 }
1045
1046 pub fn take_event_stream(&self) -> PagerEventStream {
1052 PagerEventStream { event_receiver: self.client.take_event_receiver() }
1053 }
1054
1055 pub fn r#register_file(
1057 &self,
1058 mut payload: &PagerRegisterFileRequest,
1059 ) -> fidl::client::QueryResponseFut<
1060 PagerRegisterFileResult,
1061 fidl::encoding::DefaultFuchsiaResourceDialect,
1062 > {
1063 PagerProxyInterface::r#register_file(self, payload)
1064 }
1065}
1066
1067impl PagerProxyInterface for PagerProxy {
1068 type RegisterFileResponseFut = fidl::client::QueryResponseFut<
1069 PagerRegisterFileResult,
1070 fidl::encoding::DefaultFuchsiaResourceDialect,
1071 >;
1072 fn r#register_file(
1073 &self,
1074 mut payload: &PagerRegisterFileRequest,
1075 ) -> Self::RegisterFileResponseFut {
1076 fn _decode(
1077 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1078 ) -> Result<PagerRegisterFileResult, fidl::Error> {
1079 let _response = fidl::client::decode_transaction_body::<
1080 fidl::encoding::FlexibleResultType<PagerRegisterFileResponse, i32>,
1081 fidl::encoding::DefaultFuchsiaResourceDialect,
1082 0x4f85a2ce6cae4aed,
1083 >(_buf?)?
1084 .into_result::<PagerMarker>("register_file")?;
1085 Ok(_response.map(|x| x))
1086 }
1087 self.client.send_query_and_decode::<PagerRegisterFileRequest, PagerRegisterFileResult>(
1088 payload,
1089 0x4f85a2ce6cae4aed,
1090 fidl::encoding::DynamicFlags::FLEXIBLE,
1091 _decode,
1092 )
1093 }
1094}
1095
1096pub struct PagerEventStream {
1097 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1098}
1099
1100impl std::marker::Unpin for PagerEventStream {}
1101
1102impl futures::stream::FusedStream for PagerEventStream {
1103 fn is_terminated(&self) -> bool {
1104 self.event_receiver.is_terminated()
1105 }
1106}
1107
1108impl futures::Stream for PagerEventStream {
1109 type Item = Result<PagerEvent, fidl::Error>;
1110
1111 fn poll_next(
1112 mut self: std::pin::Pin<&mut Self>,
1113 cx: &mut std::task::Context<'_>,
1114 ) -> std::task::Poll<Option<Self::Item>> {
1115 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1116 &mut self.event_receiver,
1117 cx
1118 )?) {
1119 Some(buf) => std::task::Poll::Ready(Some(PagerEvent::decode(buf))),
1120 None => std::task::Poll::Ready(None),
1121 }
1122 }
1123}
1124
1125#[derive(Debug)]
1126pub enum PagerEvent {
1127 #[non_exhaustive]
1128 _UnknownEvent {
1129 ordinal: u64,
1131 },
1132}
1133
1134impl PagerEvent {
1135 fn decode(
1137 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1138 ) -> Result<PagerEvent, fidl::Error> {
1139 let (bytes, _handles) = buf.split_mut();
1140 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1141 debug_assert_eq!(tx_header.tx_id, 0);
1142 match tx_header.ordinal {
1143 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
1144 Ok(PagerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
1145 }
1146 _ => Err(fidl::Error::UnknownOrdinal {
1147 ordinal: tx_header.ordinal,
1148 protocol_name: <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1149 }),
1150 }
1151 }
1152}
1153
1154pub struct PagerRequestStream {
1156 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1157 is_terminated: bool,
1158}
1159
1160impl std::marker::Unpin for PagerRequestStream {}
1161
1162impl futures::stream::FusedStream for PagerRequestStream {
1163 fn is_terminated(&self) -> bool {
1164 self.is_terminated
1165 }
1166}
1167
1168impl fidl::endpoints::RequestStream for PagerRequestStream {
1169 type Protocol = PagerMarker;
1170 type ControlHandle = PagerControlHandle;
1171
1172 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1173 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1174 }
1175
1176 fn control_handle(&self) -> Self::ControlHandle {
1177 PagerControlHandle { inner: self.inner.clone() }
1178 }
1179
1180 fn into_inner(
1181 self,
1182 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1183 {
1184 (self.inner, self.is_terminated)
1185 }
1186
1187 fn from_inner(
1188 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1189 is_terminated: bool,
1190 ) -> Self {
1191 Self { inner, is_terminated }
1192 }
1193}
1194
1195impl futures::Stream for PagerRequestStream {
1196 type Item = Result<PagerRequest, fidl::Error>;
1197
1198 fn poll_next(
1199 mut self: std::pin::Pin<&mut Self>,
1200 cx: &mut std::task::Context<'_>,
1201 ) -> std::task::Poll<Option<Self::Item>> {
1202 let this = &mut *self;
1203 if this.inner.check_shutdown(cx) {
1204 this.is_terminated = true;
1205 return std::task::Poll::Ready(None);
1206 }
1207 if this.is_terminated {
1208 panic!("polled PagerRequestStream after completion");
1209 }
1210 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1211 |bytes, handles| {
1212 match this.inner.channel().read_etc(cx, bytes, handles) {
1213 std::task::Poll::Ready(Ok(())) => {}
1214 std::task::Poll::Pending => return std::task::Poll::Pending,
1215 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1216 this.is_terminated = true;
1217 return std::task::Poll::Ready(None);
1218 }
1219 std::task::Poll::Ready(Err(e)) => {
1220 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1221 e.into(),
1222 ))))
1223 }
1224 }
1225
1226 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1228
1229 std::task::Poll::Ready(Some(match header.ordinal {
1230 0x4f85a2ce6cae4aed => {
1231 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1232 let mut req = fidl::new_empty!(
1233 PagerRegisterFileRequest,
1234 fidl::encoding::DefaultFuchsiaResourceDialect
1235 );
1236 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PagerRegisterFileRequest>(&header, _body_bytes, handles, &mut req)?;
1237 let control_handle = PagerControlHandle { inner: this.inner.clone() };
1238 Ok(PagerRequest::RegisterFile {
1239 payload: req,
1240 responder: PagerRegisterFileResponder {
1241 control_handle: std::mem::ManuallyDrop::new(control_handle),
1242 tx_id: header.tx_id,
1243 },
1244 })
1245 }
1246 _ if header.tx_id == 0
1247 && header
1248 .dynamic_flags()
1249 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1250 {
1251 Ok(PagerRequest::_UnknownMethod {
1252 ordinal: header.ordinal,
1253 control_handle: PagerControlHandle { inner: this.inner.clone() },
1254 method_type: fidl::MethodType::OneWay,
1255 })
1256 }
1257 _ if header
1258 .dynamic_flags()
1259 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1260 {
1261 this.inner.send_framework_err(
1262 fidl::encoding::FrameworkErr::UnknownMethod,
1263 header.tx_id,
1264 header.ordinal,
1265 header.dynamic_flags(),
1266 (bytes, handles),
1267 )?;
1268 Ok(PagerRequest::_UnknownMethod {
1269 ordinal: header.ordinal,
1270 control_handle: PagerControlHandle { inner: this.inner.clone() },
1271 method_type: fidl::MethodType::TwoWay,
1272 })
1273 }
1274 _ => Err(fidl::Error::UnknownOrdinal {
1275 ordinal: header.ordinal,
1276 protocol_name: <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1277 }),
1278 }))
1279 },
1280 )
1281 }
1282}
1283
1284#[derive(Debug)]
1285pub enum PagerRequest {
1286 RegisterFile { payload: PagerRegisterFileRequest, responder: PagerRegisterFileResponder },
1288 #[non_exhaustive]
1290 _UnknownMethod {
1291 ordinal: u64,
1293 control_handle: PagerControlHandle,
1294 method_type: fidl::MethodType,
1295 },
1296}
1297
1298impl PagerRequest {
1299 #[allow(irrefutable_let_patterns)]
1300 pub fn into_register_file(
1301 self,
1302 ) -> Option<(PagerRegisterFileRequest, PagerRegisterFileResponder)> {
1303 if let PagerRequest::RegisterFile { payload, responder } = self {
1304 Some((payload, responder))
1305 } else {
1306 None
1307 }
1308 }
1309
1310 pub fn method_name(&self) -> &'static str {
1312 match *self {
1313 PagerRequest::RegisterFile { .. } => "register_file",
1314 PagerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
1315 "unknown one-way method"
1316 }
1317 PagerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
1318 "unknown two-way method"
1319 }
1320 }
1321 }
1322}
1323
1324#[derive(Debug, Clone)]
1325pub struct PagerControlHandle {
1326 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1327}
1328
1329impl fidl::endpoints::ControlHandle for PagerControlHandle {
1330 fn shutdown(&self) {
1331 self.inner.shutdown()
1332 }
1333 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1334 self.inner.shutdown_with_epitaph(status)
1335 }
1336
1337 fn is_closed(&self) -> bool {
1338 self.inner.channel().is_closed()
1339 }
1340 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1341 self.inner.channel().on_closed()
1342 }
1343
1344 #[cfg(target_os = "fuchsia")]
1345 fn signal_peer(
1346 &self,
1347 clear_mask: zx::Signals,
1348 set_mask: zx::Signals,
1349 ) -> Result<(), zx_status::Status> {
1350 use fidl::Peered;
1351 self.inner.channel().signal_peer(clear_mask, set_mask)
1352 }
1353}
1354
1355impl PagerControlHandle {}
1356
1357#[must_use = "FIDL methods require a response to be sent"]
1358#[derive(Debug)]
1359pub struct PagerRegisterFileResponder {
1360 control_handle: std::mem::ManuallyDrop<PagerControlHandle>,
1361 tx_id: u32,
1362}
1363
1364impl std::ops::Drop for PagerRegisterFileResponder {
1368 fn drop(&mut self) {
1369 self.control_handle.shutdown();
1370 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1372 }
1373}
1374
1375impl fidl::endpoints::Responder for PagerRegisterFileResponder {
1376 type ControlHandle = PagerControlHandle;
1377
1378 fn control_handle(&self) -> &PagerControlHandle {
1379 &self.control_handle
1380 }
1381
1382 fn drop_without_shutdown(mut self) {
1383 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1385 std::mem::forget(self);
1387 }
1388}
1389
1390impl PagerRegisterFileResponder {
1391 pub fn send(
1395 self,
1396 mut result: Result<PagerRegisterFileResponse, i32>,
1397 ) -> Result<(), fidl::Error> {
1398 let _result = self.send_raw(result);
1399 if _result.is_err() {
1400 self.control_handle.shutdown();
1401 }
1402 self.drop_without_shutdown();
1403 _result
1404 }
1405
1406 pub fn send_no_shutdown_on_err(
1408 self,
1409 mut result: Result<PagerRegisterFileResponse, i32>,
1410 ) -> Result<(), fidl::Error> {
1411 let _result = self.send_raw(result);
1412 self.drop_without_shutdown();
1413 _result
1414 }
1415
1416 fn send_raw(
1417 &self,
1418 mut result: Result<PagerRegisterFileResponse, i32>,
1419 ) -> Result<(), fidl::Error> {
1420 self.control_handle
1421 .inner
1422 .send::<fidl::encoding::FlexibleResultType<PagerRegisterFileResponse, i32>>(
1423 fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
1424 self.tx_id,
1425 0x4f85a2ce6cae4aed,
1426 fidl::encoding::DynamicFlags::FLEXIBLE,
1427 )
1428 }
1429}
1430
1431mod internal {
1432 use super::*;
1433
1434 impl ManagerCreatePagerRequest {
1435 #[inline(always)]
1436 fn max_ordinal_present(&self) -> u64 {
1437 if let Some(_) = self.pager {
1438 return 3;
1439 }
1440 if let Some(_) = self.block_size {
1441 return 2;
1442 }
1443 if let Some(_) = self.backing_vmo {
1444 return 1;
1445 }
1446 0
1447 }
1448 }
1449
1450 impl fidl::encoding::ResourceTypeMarker for ManagerCreatePagerRequest {
1451 type Borrowed<'a> = &'a mut Self;
1452 fn take_or_borrow<'a>(
1453 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1454 ) -> Self::Borrowed<'a> {
1455 value
1456 }
1457 }
1458
1459 unsafe impl fidl::encoding::TypeMarker for ManagerCreatePagerRequest {
1460 type Owned = Self;
1461
1462 #[inline(always)]
1463 fn inline_align(_context: fidl::encoding::Context) -> usize {
1464 8
1465 }
1466
1467 #[inline(always)]
1468 fn inline_size(_context: fidl::encoding::Context) -> usize {
1469 16
1470 }
1471 }
1472
1473 unsafe impl
1474 fidl::encoding::Encode<
1475 ManagerCreatePagerRequest,
1476 fidl::encoding::DefaultFuchsiaResourceDialect,
1477 > for &mut ManagerCreatePagerRequest
1478 {
1479 unsafe fn encode(
1480 self,
1481 encoder: &mut fidl::encoding::Encoder<
1482 '_,
1483 fidl::encoding::DefaultFuchsiaResourceDialect,
1484 >,
1485 offset: usize,
1486 mut depth: fidl::encoding::Depth,
1487 ) -> fidl::Result<()> {
1488 encoder.debug_check_bounds::<ManagerCreatePagerRequest>(offset);
1489 let max_ordinal: u64 = self.max_ordinal_present();
1491 encoder.write_num(max_ordinal, offset);
1492 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1493 if max_ordinal == 0 {
1495 return Ok(());
1496 }
1497 depth.increment()?;
1498 let envelope_size = 8;
1499 let bytes_len = max_ordinal as usize * envelope_size;
1500 #[allow(unused_variables)]
1501 let offset = encoder.out_of_line_offset(bytes_len);
1502 let mut _prev_end_offset: usize = 0;
1503 if 1 > max_ordinal {
1504 return Ok(());
1505 }
1506
1507 let cur_offset: usize = (1 - 1) * envelope_size;
1510
1511 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1513
1514 fidl::encoding::encode_in_envelope_optional::<
1519 fidl::encoding::HandleType<
1520 fidl::Vmo,
1521 { fidl::ObjectType::VMO.into_raw() },
1522 2147483648,
1523 >,
1524 fidl::encoding::DefaultFuchsiaResourceDialect,
1525 >(
1526 self.backing_vmo.as_mut().map(
1527 <fidl::encoding::HandleType<
1528 fidl::Vmo,
1529 { fidl::ObjectType::VMO.into_raw() },
1530 2147483648,
1531 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1532 ),
1533 encoder,
1534 offset + cur_offset,
1535 depth,
1536 )?;
1537
1538 _prev_end_offset = cur_offset + envelope_size;
1539 if 2 > max_ordinal {
1540 return Ok(());
1541 }
1542
1543 let cur_offset: usize = (2 - 1) * envelope_size;
1546
1547 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1549
1550 fidl::encoding::encode_in_envelope_optional::<
1555 u64,
1556 fidl::encoding::DefaultFuchsiaResourceDialect,
1557 >(
1558 self.block_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1559 encoder,
1560 offset + cur_offset,
1561 depth,
1562 )?;
1563
1564 _prev_end_offset = cur_offset + envelope_size;
1565 if 3 > max_ordinal {
1566 return Ok(());
1567 }
1568
1569 let cur_offset: usize = (3 - 1) * envelope_size;
1572
1573 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1575
1576 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1581 self.pager.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1582 encoder, offset + cur_offset, depth
1583 )?;
1584
1585 _prev_end_offset = cur_offset + envelope_size;
1586
1587 Ok(())
1588 }
1589 }
1590
1591 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1592 for ManagerCreatePagerRequest
1593 {
1594 #[inline(always)]
1595 fn new_empty() -> Self {
1596 Self::default()
1597 }
1598
1599 unsafe fn decode(
1600 &mut self,
1601 decoder: &mut fidl::encoding::Decoder<
1602 '_,
1603 fidl::encoding::DefaultFuchsiaResourceDialect,
1604 >,
1605 offset: usize,
1606 mut depth: fidl::encoding::Depth,
1607 ) -> fidl::Result<()> {
1608 decoder.debug_check_bounds::<Self>(offset);
1609 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1610 None => return Err(fidl::Error::NotNullable),
1611 Some(len) => len,
1612 };
1613 if len == 0 {
1615 return Ok(());
1616 };
1617 depth.increment()?;
1618 let envelope_size = 8;
1619 let bytes_len = len * envelope_size;
1620 let offset = decoder.out_of_line_offset(bytes_len)?;
1621 let mut _next_ordinal_to_read = 0;
1623 let mut next_offset = offset;
1624 let end_offset = offset + bytes_len;
1625 _next_ordinal_to_read += 1;
1626 if next_offset >= end_offset {
1627 return Ok(());
1628 }
1629
1630 while _next_ordinal_to_read < 1 {
1632 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1633 _next_ordinal_to_read += 1;
1634 next_offset += envelope_size;
1635 }
1636
1637 let next_out_of_line = decoder.next_out_of_line();
1638 let handles_before = decoder.remaining_handles();
1639 if let Some((inlined, num_bytes, num_handles)) =
1640 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1641 {
1642 let member_inline_size = <fidl::encoding::HandleType<
1643 fidl::Vmo,
1644 { fidl::ObjectType::VMO.into_raw() },
1645 2147483648,
1646 > as fidl::encoding::TypeMarker>::inline_size(
1647 decoder.context
1648 );
1649 if inlined != (member_inline_size <= 4) {
1650 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1651 }
1652 let inner_offset;
1653 let mut inner_depth = depth.clone();
1654 if inlined {
1655 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1656 inner_offset = next_offset;
1657 } else {
1658 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1659 inner_depth.increment()?;
1660 }
1661 let val_ref =
1662 self.backing_vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
1663 fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
1664 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1665 {
1666 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1667 }
1668 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1669 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1670 }
1671 }
1672
1673 next_offset += envelope_size;
1674 _next_ordinal_to_read += 1;
1675 if next_offset >= end_offset {
1676 return Ok(());
1677 }
1678
1679 while _next_ordinal_to_read < 2 {
1681 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1682 _next_ordinal_to_read += 1;
1683 next_offset += envelope_size;
1684 }
1685
1686 let next_out_of_line = decoder.next_out_of_line();
1687 let handles_before = decoder.remaining_handles();
1688 if let Some((inlined, num_bytes, num_handles)) =
1689 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1690 {
1691 let member_inline_size =
1692 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1693 if inlined != (member_inline_size <= 4) {
1694 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1695 }
1696 let inner_offset;
1697 let mut inner_depth = depth.clone();
1698 if inlined {
1699 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1700 inner_offset = next_offset;
1701 } else {
1702 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1703 inner_depth.increment()?;
1704 }
1705 let val_ref = self.block_size.get_or_insert_with(|| {
1706 fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
1707 });
1708 fidl::decode!(
1709 u64,
1710 fidl::encoding::DefaultFuchsiaResourceDialect,
1711 val_ref,
1712 decoder,
1713 inner_offset,
1714 inner_depth
1715 )?;
1716 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1717 {
1718 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1719 }
1720 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1721 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1722 }
1723 }
1724
1725 next_offset += envelope_size;
1726 _next_ordinal_to_read += 1;
1727 if next_offset >= end_offset {
1728 return Ok(());
1729 }
1730
1731 while _next_ordinal_to_read < 3 {
1733 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1734 _next_ordinal_to_read += 1;
1735 next_offset += envelope_size;
1736 }
1737
1738 let next_out_of_line = decoder.next_out_of_line();
1739 let handles_before = decoder.remaining_handles();
1740 if let Some((inlined, num_bytes, num_handles)) =
1741 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1742 {
1743 let member_inline_size = <fidl::encoding::Endpoint<
1744 fidl::endpoints::ServerEnd<PagerMarker>,
1745 > as fidl::encoding::TypeMarker>::inline_size(
1746 decoder.context
1747 );
1748 if inlined != (member_inline_size <= 4) {
1749 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1750 }
1751 let inner_offset;
1752 let mut inner_depth = depth.clone();
1753 if inlined {
1754 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1755 inner_offset = next_offset;
1756 } else {
1757 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1758 inner_depth.increment()?;
1759 }
1760 let val_ref = self.pager.get_or_insert_with(|| {
1761 fidl::new_empty!(
1762 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>>,
1763 fidl::encoding::DefaultFuchsiaResourceDialect
1764 )
1765 });
1766 fidl::decode!(
1767 fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>>,
1768 fidl::encoding::DefaultFuchsiaResourceDialect,
1769 val_ref,
1770 decoder,
1771 inner_offset,
1772 inner_depth
1773 )?;
1774 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1775 {
1776 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1777 }
1778 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1779 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1780 }
1781 }
1782
1783 next_offset += envelope_size;
1784
1785 while next_offset < end_offset {
1787 _next_ordinal_to_read += 1;
1788 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1789 next_offset += envelope_size;
1790 }
1791
1792 Ok(())
1793 }
1794 }
1795
1796 impl ManagerProxyWakeChannelRequest {
1797 #[inline(always)]
1798 fn max_ordinal_present(&self) -> u64 {
1799 if let Some(_) = self.counter {
1800 return 5;
1801 }
1802 if let Some(_) = self.name {
1803 return 4;
1804 }
1805 if let Some(_) = self.remote_channel {
1806 return 3;
1807 }
1808 if let Some(_) = self.container_channel {
1809 return 2;
1810 }
1811 if let Some(_) = self.container_job {
1812 return 1;
1813 }
1814 0
1815 }
1816 }
1817
1818 impl fidl::encoding::ResourceTypeMarker for ManagerProxyWakeChannelRequest {
1819 type Borrowed<'a> = &'a mut Self;
1820 fn take_or_borrow<'a>(
1821 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1822 ) -> Self::Borrowed<'a> {
1823 value
1824 }
1825 }
1826
1827 unsafe impl fidl::encoding::TypeMarker for ManagerProxyWakeChannelRequest {
1828 type Owned = Self;
1829
1830 #[inline(always)]
1831 fn inline_align(_context: fidl::encoding::Context) -> usize {
1832 8
1833 }
1834
1835 #[inline(always)]
1836 fn inline_size(_context: fidl::encoding::Context) -> usize {
1837 16
1838 }
1839 }
1840
1841 unsafe impl
1842 fidl::encoding::Encode<
1843 ManagerProxyWakeChannelRequest,
1844 fidl::encoding::DefaultFuchsiaResourceDialect,
1845 > for &mut ManagerProxyWakeChannelRequest
1846 {
1847 unsafe fn encode(
1848 self,
1849 encoder: &mut fidl::encoding::Encoder<
1850 '_,
1851 fidl::encoding::DefaultFuchsiaResourceDialect,
1852 >,
1853 offset: usize,
1854 mut depth: fidl::encoding::Depth,
1855 ) -> fidl::Result<()> {
1856 encoder.debug_check_bounds::<ManagerProxyWakeChannelRequest>(offset);
1857 let max_ordinal: u64 = self.max_ordinal_present();
1859 encoder.write_num(max_ordinal, offset);
1860 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1861 if max_ordinal == 0 {
1863 return Ok(());
1864 }
1865 depth.increment()?;
1866 let envelope_size = 8;
1867 let bytes_len = max_ordinal as usize * envelope_size;
1868 #[allow(unused_variables)]
1869 let offset = encoder.out_of_line_offset(bytes_len);
1870 let mut _prev_end_offset: usize = 0;
1871 if 1 > max_ordinal {
1872 return Ok(());
1873 }
1874
1875 let cur_offset: usize = (1 - 1) * envelope_size;
1878
1879 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1881
1882 fidl::encoding::encode_in_envelope_optional::<
1887 fidl::encoding::HandleType<
1888 fidl::Job,
1889 { fidl::ObjectType::JOB.into_raw() },
1890 2147483648,
1891 >,
1892 fidl::encoding::DefaultFuchsiaResourceDialect,
1893 >(
1894 self.container_job.as_mut().map(
1895 <fidl::encoding::HandleType<
1896 fidl::Job,
1897 { fidl::ObjectType::JOB.into_raw() },
1898 2147483648,
1899 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1900 ),
1901 encoder,
1902 offset + cur_offset,
1903 depth,
1904 )?;
1905
1906 _prev_end_offset = cur_offset + envelope_size;
1907 if 2 > max_ordinal {
1908 return Ok(());
1909 }
1910
1911 let cur_offset: usize = (2 - 1) * envelope_size;
1914
1915 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1917
1918 fidl::encoding::encode_in_envelope_optional::<
1923 fidl::encoding::HandleType<
1924 fidl::Channel,
1925 { fidl::ObjectType::CHANNEL.into_raw() },
1926 2147483648,
1927 >,
1928 fidl::encoding::DefaultFuchsiaResourceDialect,
1929 >(
1930 self.container_channel.as_mut().map(
1931 <fidl::encoding::HandleType<
1932 fidl::Channel,
1933 { fidl::ObjectType::CHANNEL.into_raw() },
1934 2147483648,
1935 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1936 ),
1937 encoder,
1938 offset + cur_offset,
1939 depth,
1940 )?;
1941
1942 _prev_end_offset = cur_offset + envelope_size;
1943 if 3 > max_ordinal {
1944 return Ok(());
1945 }
1946
1947 let cur_offset: usize = (3 - 1) * envelope_size;
1950
1951 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1953
1954 fidl::encoding::encode_in_envelope_optional::<
1959 fidl::encoding::HandleType<
1960 fidl::Channel,
1961 { fidl::ObjectType::CHANNEL.into_raw() },
1962 2147483648,
1963 >,
1964 fidl::encoding::DefaultFuchsiaResourceDialect,
1965 >(
1966 self.remote_channel.as_mut().map(
1967 <fidl::encoding::HandleType<
1968 fidl::Channel,
1969 { fidl::ObjectType::CHANNEL.into_raw() },
1970 2147483648,
1971 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1972 ),
1973 encoder,
1974 offset + cur_offset,
1975 depth,
1976 )?;
1977
1978 _prev_end_offset = cur_offset + envelope_size;
1979 if 4 > max_ordinal {
1980 return Ok(());
1981 }
1982
1983 let cur_offset: usize = (4 - 1) * envelope_size;
1986
1987 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1989
1990 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1995 self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
1996 encoder, offset + cur_offset, depth
1997 )?;
1998
1999 _prev_end_offset = cur_offset + envelope_size;
2000 if 5 > max_ordinal {
2001 return Ok(());
2002 }
2003
2004 let cur_offset: usize = (5 - 1) * envelope_size;
2007
2008 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2010
2011 fidl::encoding::encode_in_envelope_optional::<
2016 fidl::encoding::HandleType<
2017 fidl::Counter,
2018 { fidl::ObjectType::COUNTER.into_raw() },
2019 2147483648,
2020 >,
2021 fidl::encoding::DefaultFuchsiaResourceDialect,
2022 >(
2023 self.counter.as_mut().map(
2024 <fidl::encoding::HandleType<
2025 fidl::Counter,
2026 { fidl::ObjectType::COUNTER.into_raw() },
2027 2147483648,
2028 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2029 ),
2030 encoder,
2031 offset + cur_offset,
2032 depth,
2033 )?;
2034
2035 _prev_end_offset = cur_offset + envelope_size;
2036
2037 Ok(())
2038 }
2039 }
2040
2041 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2042 for ManagerProxyWakeChannelRequest
2043 {
2044 #[inline(always)]
2045 fn new_empty() -> Self {
2046 Self::default()
2047 }
2048
2049 unsafe fn decode(
2050 &mut self,
2051 decoder: &mut fidl::encoding::Decoder<
2052 '_,
2053 fidl::encoding::DefaultFuchsiaResourceDialect,
2054 >,
2055 offset: usize,
2056 mut depth: fidl::encoding::Depth,
2057 ) -> fidl::Result<()> {
2058 decoder.debug_check_bounds::<Self>(offset);
2059 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2060 None => return Err(fidl::Error::NotNullable),
2061 Some(len) => len,
2062 };
2063 if len == 0 {
2065 return Ok(());
2066 };
2067 depth.increment()?;
2068 let envelope_size = 8;
2069 let bytes_len = len * envelope_size;
2070 let offset = decoder.out_of_line_offset(bytes_len)?;
2071 let mut _next_ordinal_to_read = 0;
2073 let mut next_offset = offset;
2074 let end_offset = offset + bytes_len;
2075 _next_ordinal_to_read += 1;
2076 if next_offset >= end_offset {
2077 return Ok(());
2078 }
2079
2080 while _next_ordinal_to_read < 1 {
2082 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2083 _next_ordinal_to_read += 1;
2084 next_offset += envelope_size;
2085 }
2086
2087 let next_out_of_line = decoder.next_out_of_line();
2088 let handles_before = decoder.remaining_handles();
2089 if let Some((inlined, num_bytes, num_handles)) =
2090 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2091 {
2092 let member_inline_size = <fidl::encoding::HandleType<
2093 fidl::Job,
2094 { fidl::ObjectType::JOB.into_raw() },
2095 2147483648,
2096 > as fidl::encoding::TypeMarker>::inline_size(
2097 decoder.context
2098 );
2099 if inlined != (member_inline_size <= 4) {
2100 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2101 }
2102 let inner_offset;
2103 let mut inner_depth = depth.clone();
2104 if inlined {
2105 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2106 inner_offset = next_offset;
2107 } else {
2108 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2109 inner_depth.increment()?;
2110 }
2111 let val_ref =
2112 self.container_job.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2113 fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2114 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2115 {
2116 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2117 }
2118 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2119 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2120 }
2121 }
2122
2123 next_offset += envelope_size;
2124 _next_ordinal_to_read += 1;
2125 if next_offset >= end_offset {
2126 return Ok(());
2127 }
2128
2129 while _next_ordinal_to_read < 2 {
2131 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2132 _next_ordinal_to_read += 1;
2133 next_offset += envelope_size;
2134 }
2135
2136 let next_out_of_line = decoder.next_out_of_line();
2137 let handles_before = decoder.remaining_handles();
2138 if let Some((inlined, num_bytes, num_handles)) =
2139 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2140 {
2141 let member_inline_size = <fidl::encoding::HandleType<
2142 fidl::Channel,
2143 { fidl::ObjectType::CHANNEL.into_raw() },
2144 2147483648,
2145 > as fidl::encoding::TypeMarker>::inline_size(
2146 decoder.context
2147 );
2148 if inlined != (member_inline_size <= 4) {
2149 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2150 }
2151 let inner_offset;
2152 let mut inner_depth = depth.clone();
2153 if inlined {
2154 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2155 inner_offset = next_offset;
2156 } else {
2157 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2158 inner_depth.increment()?;
2159 }
2160 let val_ref =
2161 self.container_channel.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2162 fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2164 {
2165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2166 }
2167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2169 }
2170 }
2171
2172 next_offset += envelope_size;
2173 _next_ordinal_to_read += 1;
2174 if next_offset >= end_offset {
2175 return Ok(());
2176 }
2177
2178 while _next_ordinal_to_read < 3 {
2180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2181 _next_ordinal_to_read += 1;
2182 next_offset += envelope_size;
2183 }
2184
2185 let next_out_of_line = decoder.next_out_of_line();
2186 let handles_before = decoder.remaining_handles();
2187 if let Some((inlined, num_bytes, num_handles)) =
2188 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2189 {
2190 let member_inline_size = <fidl::encoding::HandleType<
2191 fidl::Channel,
2192 { fidl::ObjectType::CHANNEL.into_raw() },
2193 2147483648,
2194 > as fidl::encoding::TypeMarker>::inline_size(
2195 decoder.context
2196 );
2197 if inlined != (member_inline_size <= 4) {
2198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2199 }
2200 let inner_offset;
2201 let mut inner_depth = depth.clone();
2202 if inlined {
2203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2204 inner_offset = next_offset;
2205 } else {
2206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2207 inner_depth.increment()?;
2208 }
2209 let val_ref =
2210 self.remote_channel.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2211 fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2212 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2213 {
2214 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2215 }
2216 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2217 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2218 }
2219 }
2220
2221 next_offset += envelope_size;
2222 _next_ordinal_to_read += 1;
2223 if next_offset >= end_offset {
2224 return Ok(());
2225 }
2226
2227 while _next_ordinal_to_read < 4 {
2229 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2230 _next_ordinal_to_read += 1;
2231 next_offset += envelope_size;
2232 }
2233
2234 let next_out_of_line = decoder.next_out_of_line();
2235 let handles_before = decoder.remaining_handles();
2236 if let Some((inlined, num_bytes, num_handles)) =
2237 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2238 {
2239 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2240 if inlined != (member_inline_size <= 4) {
2241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2242 }
2243 let inner_offset;
2244 let mut inner_depth = depth.clone();
2245 if inlined {
2246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2247 inner_offset = next_offset;
2248 } else {
2249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2250 inner_depth.increment()?;
2251 }
2252 let val_ref = self.name.get_or_insert_with(|| {
2253 fidl::new_empty!(
2254 fidl::encoding::BoundedString<1024>,
2255 fidl::encoding::DefaultFuchsiaResourceDialect
2256 )
2257 });
2258 fidl::decode!(
2259 fidl::encoding::BoundedString<1024>,
2260 fidl::encoding::DefaultFuchsiaResourceDialect,
2261 val_ref,
2262 decoder,
2263 inner_offset,
2264 inner_depth
2265 )?;
2266 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2267 {
2268 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2269 }
2270 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2271 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2272 }
2273 }
2274
2275 next_offset += envelope_size;
2276 _next_ordinal_to_read += 1;
2277 if next_offset >= end_offset {
2278 return Ok(());
2279 }
2280
2281 while _next_ordinal_to_read < 5 {
2283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2284 _next_ordinal_to_read += 1;
2285 next_offset += envelope_size;
2286 }
2287
2288 let next_out_of_line = decoder.next_out_of_line();
2289 let handles_before = decoder.remaining_handles();
2290 if let Some((inlined, num_bytes, num_handles)) =
2291 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2292 {
2293 let member_inline_size = <fidl::encoding::HandleType<
2294 fidl::Counter,
2295 { fidl::ObjectType::COUNTER.into_raw() },
2296 2147483648,
2297 > as fidl::encoding::TypeMarker>::inline_size(
2298 decoder.context
2299 );
2300 if inlined != (member_inline_size <= 4) {
2301 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2302 }
2303 let inner_offset;
2304 let mut inner_depth = depth.clone();
2305 if inlined {
2306 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2307 inner_offset = next_offset;
2308 } else {
2309 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2310 inner_depth.increment()?;
2311 }
2312 let val_ref =
2313 self.counter.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Counter, { fidl::ObjectType::COUNTER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2314 fidl::decode!(fidl::encoding::HandleType<fidl::Counter, { fidl::ObjectType::COUNTER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2315 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2316 {
2317 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2318 }
2319 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2320 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2321 }
2322 }
2323
2324 next_offset += envelope_size;
2325
2326 while next_offset < end_offset {
2328 _next_ordinal_to_read += 1;
2329 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2330 next_offset += envelope_size;
2331 }
2332
2333 Ok(())
2334 }
2335 }
2336
2337 impl ManagerRegisterWakeWatcherRequest {
2338 #[inline(always)]
2339 fn max_ordinal_present(&self) -> u64 {
2340 if let Some(_) = self.watcher {
2341 return 1;
2342 }
2343 0
2344 }
2345 }
2346
2347 impl fidl::encoding::ResourceTypeMarker for ManagerRegisterWakeWatcherRequest {
2348 type Borrowed<'a> = &'a mut Self;
2349 fn take_or_borrow<'a>(
2350 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2351 ) -> Self::Borrowed<'a> {
2352 value
2353 }
2354 }
2355
2356 unsafe impl fidl::encoding::TypeMarker for ManagerRegisterWakeWatcherRequest {
2357 type Owned = Self;
2358
2359 #[inline(always)]
2360 fn inline_align(_context: fidl::encoding::Context) -> usize {
2361 8
2362 }
2363
2364 #[inline(always)]
2365 fn inline_size(_context: fidl::encoding::Context) -> usize {
2366 16
2367 }
2368 }
2369
2370 unsafe impl
2371 fidl::encoding::Encode<
2372 ManagerRegisterWakeWatcherRequest,
2373 fidl::encoding::DefaultFuchsiaResourceDialect,
2374 > for &mut ManagerRegisterWakeWatcherRequest
2375 {
2376 unsafe fn encode(
2377 self,
2378 encoder: &mut fidl::encoding::Encoder<
2379 '_,
2380 fidl::encoding::DefaultFuchsiaResourceDialect,
2381 >,
2382 offset: usize,
2383 mut depth: fidl::encoding::Depth,
2384 ) -> fidl::Result<()> {
2385 encoder.debug_check_bounds::<ManagerRegisterWakeWatcherRequest>(offset);
2386 let max_ordinal: u64 = self.max_ordinal_present();
2388 encoder.write_num(max_ordinal, offset);
2389 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2390 if max_ordinal == 0 {
2392 return Ok(());
2393 }
2394 depth.increment()?;
2395 let envelope_size = 8;
2396 let bytes_len = max_ordinal as usize * envelope_size;
2397 #[allow(unused_variables)]
2398 let offset = encoder.out_of_line_offset(bytes_len);
2399 let mut _prev_end_offset: usize = 0;
2400 if 1 > max_ordinal {
2401 return Ok(());
2402 }
2403
2404 let cur_offset: usize = (1 - 1) * envelope_size;
2407
2408 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2410
2411 fidl::encoding::encode_in_envelope_optional::<
2416 fidl::encoding::HandleType<
2417 fidl::EventPair,
2418 { fidl::ObjectType::EVENTPAIR.into_raw() },
2419 2147483648,
2420 >,
2421 fidl::encoding::DefaultFuchsiaResourceDialect,
2422 >(
2423 self.watcher.as_mut().map(
2424 <fidl::encoding::HandleType<
2425 fidl::EventPair,
2426 { fidl::ObjectType::EVENTPAIR.into_raw() },
2427 2147483648,
2428 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2429 ),
2430 encoder,
2431 offset + cur_offset,
2432 depth,
2433 )?;
2434
2435 _prev_end_offset = cur_offset + envelope_size;
2436
2437 Ok(())
2438 }
2439 }
2440
2441 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2442 for ManagerRegisterWakeWatcherRequest
2443 {
2444 #[inline(always)]
2445 fn new_empty() -> Self {
2446 Self::default()
2447 }
2448
2449 unsafe fn decode(
2450 &mut self,
2451 decoder: &mut fidl::encoding::Decoder<
2452 '_,
2453 fidl::encoding::DefaultFuchsiaResourceDialect,
2454 >,
2455 offset: usize,
2456 mut depth: fidl::encoding::Depth,
2457 ) -> fidl::Result<()> {
2458 decoder.debug_check_bounds::<Self>(offset);
2459 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2460 None => return Err(fidl::Error::NotNullable),
2461 Some(len) => len,
2462 };
2463 if len == 0 {
2465 return Ok(());
2466 };
2467 depth.increment()?;
2468 let envelope_size = 8;
2469 let bytes_len = len * envelope_size;
2470 let offset = decoder.out_of_line_offset(bytes_len)?;
2471 let mut _next_ordinal_to_read = 0;
2473 let mut next_offset = offset;
2474 let end_offset = offset + bytes_len;
2475 _next_ordinal_to_read += 1;
2476 if next_offset >= end_offset {
2477 return Ok(());
2478 }
2479
2480 while _next_ordinal_to_read < 1 {
2482 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2483 _next_ordinal_to_read += 1;
2484 next_offset += envelope_size;
2485 }
2486
2487 let next_out_of_line = decoder.next_out_of_line();
2488 let handles_before = decoder.remaining_handles();
2489 if let Some((inlined, num_bytes, num_handles)) =
2490 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2491 {
2492 let member_inline_size = <fidl::encoding::HandleType<
2493 fidl::EventPair,
2494 { fidl::ObjectType::EVENTPAIR.into_raw() },
2495 2147483648,
2496 > as fidl::encoding::TypeMarker>::inline_size(
2497 decoder.context
2498 );
2499 if inlined != (member_inline_size <= 4) {
2500 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2501 }
2502 let inner_offset;
2503 let mut inner_depth = depth.clone();
2504 if inlined {
2505 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2506 inner_offset = next_offset;
2507 } else {
2508 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2509 inner_depth.increment()?;
2510 }
2511 let val_ref =
2512 self.watcher.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2513 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2514 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2515 {
2516 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2517 }
2518 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2519 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2520 }
2521 }
2522
2523 next_offset += envelope_size;
2524
2525 while next_offset < end_offset {
2527 _next_ordinal_to_read += 1;
2528 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2529 next_offset += envelope_size;
2530 }
2531
2532 Ok(())
2533 }
2534 }
2535
2536 impl ManagerSuspendContainerRequest {
2537 #[inline(always)]
2538 fn max_ordinal_present(&self) -> u64 {
2539 if let Some(_) = self.wake_locks {
2540 return 2;
2541 }
2542 if let Some(_) = self.container_job {
2543 return 1;
2544 }
2545 0
2546 }
2547 }
2548
2549 impl fidl::encoding::ResourceTypeMarker for ManagerSuspendContainerRequest {
2550 type Borrowed<'a> = &'a mut Self;
2551 fn take_or_borrow<'a>(
2552 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2553 ) -> Self::Borrowed<'a> {
2554 value
2555 }
2556 }
2557
2558 unsafe impl fidl::encoding::TypeMarker for ManagerSuspendContainerRequest {
2559 type Owned = Self;
2560
2561 #[inline(always)]
2562 fn inline_align(_context: fidl::encoding::Context) -> usize {
2563 8
2564 }
2565
2566 #[inline(always)]
2567 fn inline_size(_context: fidl::encoding::Context) -> usize {
2568 16
2569 }
2570 }
2571
2572 unsafe impl
2573 fidl::encoding::Encode<
2574 ManagerSuspendContainerRequest,
2575 fidl::encoding::DefaultFuchsiaResourceDialect,
2576 > for &mut ManagerSuspendContainerRequest
2577 {
2578 unsafe fn encode(
2579 self,
2580 encoder: &mut fidl::encoding::Encoder<
2581 '_,
2582 fidl::encoding::DefaultFuchsiaResourceDialect,
2583 >,
2584 offset: usize,
2585 mut depth: fidl::encoding::Depth,
2586 ) -> fidl::Result<()> {
2587 encoder.debug_check_bounds::<ManagerSuspendContainerRequest>(offset);
2588 let max_ordinal: u64 = self.max_ordinal_present();
2590 encoder.write_num(max_ordinal, offset);
2591 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2592 if max_ordinal == 0 {
2594 return Ok(());
2595 }
2596 depth.increment()?;
2597 let envelope_size = 8;
2598 let bytes_len = max_ordinal as usize * envelope_size;
2599 #[allow(unused_variables)]
2600 let offset = encoder.out_of_line_offset(bytes_len);
2601 let mut _prev_end_offset: usize = 0;
2602 if 1 > max_ordinal {
2603 return Ok(());
2604 }
2605
2606 let cur_offset: usize = (1 - 1) * envelope_size;
2609
2610 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2612
2613 fidl::encoding::encode_in_envelope_optional::<
2618 fidl::encoding::HandleType<
2619 fidl::Job,
2620 { fidl::ObjectType::JOB.into_raw() },
2621 2147483648,
2622 >,
2623 fidl::encoding::DefaultFuchsiaResourceDialect,
2624 >(
2625 self.container_job.as_mut().map(
2626 <fidl::encoding::HandleType<
2627 fidl::Job,
2628 { fidl::ObjectType::JOB.into_raw() },
2629 2147483648,
2630 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2631 ),
2632 encoder,
2633 offset + cur_offset,
2634 depth,
2635 )?;
2636
2637 _prev_end_offset = cur_offset + envelope_size;
2638 if 2 > max_ordinal {
2639 return Ok(());
2640 }
2641
2642 let cur_offset: usize = (2 - 1) * envelope_size;
2645
2646 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2648
2649 fidl::encoding::encode_in_envelope_optional::<
2654 fidl::encoding::HandleType<
2655 fidl::EventPair,
2656 { fidl::ObjectType::EVENTPAIR.into_raw() },
2657 2147483648,
2658 >,
2659 fidl::encoding::DefaultFuchsiaResourceDialect,
2660 >(
2661 self.wake_locks.as_mut().map(
2662 <fidl::encoding::HandleType<
2663 fidl::EventPair,
2664 { fidl::ObjectType::EVENTPAIR.into_raw() },
2665 2147483648,
2666 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2667 ),
2668 encoder,
2669 offset + cur_offset,
2670 depth,
2671 )?;
2672
2673 _prev_end_offset = cur_offset + envelope_size;
2674
2675 Ok(())
2676 }
2677 }
2678
2679 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2680 for ManagerSuspendContainerRequest
2681 {
2682 #[inline(always)]
2683 fn new_empty() -> Self {
2684 Self::default()
2685 }
2686
2687 unsafe fn decode(
2688 &mut self,
2689 decoder: &mut fidl::encoding::Decoder<
2690 '_,
2691 fidl::encoding::DefaultFuchsiaResourceDialect,
2692 >,
2693 offset: usize,
2694 mut depth: fidl::encoding::Depth,
2695 ) -> fidl::Result<()> {
2696 decoder.debug_check_bounds::<Self>(offset);
2697 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2698 None => return Err(fidl::Error::NotNullable),
2699 Some(len) => len,
2700 };
2701 if len == 0 {
2703 return Ok(());
2704 };
2705 depth.increment()?;
2706 let envelope_size = 8;
2707 let bytes_len = len * envelope_size;
2708 let offset = decoder.out_of_line_offset(bytes_len)?;
2709 let mut _next_ordinal_to_read = 0;
2711 let mut next_offset = offset;
2712 let end_offset = offset + bytes_len;
2713 _next_ordinal_to_read += 1;
2714 if next_offset >= end_offset {
2715 return Ok(());
2716 }
2717
2718 while _next_ordinal_to_read < 1 {
2720 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2721 _next_ordinal_to_read += 1;
2722 next_offset += envelope_size;
2723 }
2724
2725 let next_out_of_line = decoder.next_out_of_line();
2726 let handles_before = decoder.remaining_handles();
2727 if let Some((inlined, num_bytes, num_handles)) =
2728 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2729 {
2730 let member_inline_size = <fidl::encoding::HandleType<
2731 fidl::Job,
2732 { fidl::ObjectType::JOB.into_raw() },
2733 2147483648,
2734 > as fidl::encoding::TypeMarker>::inline_size(
2735 decoder.context
2736 );
2737 if inlined != (member_inline_size <= 4) {
2738 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2739 }
2740 let inner_offset;
2741 let mut inner_depth = depth.clone();
2742 if inlined {
2743 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2744 inner_offset = next_offset;
2745 } else {
2746 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2747 inner_depth.increment()?;
2748 }
2749 let val_ref =
2750 self.container_job.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2751 fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2752 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2753 {
2754 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2755 }
2756 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2757 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2758 }
2759 }
2760
2761 next_offset += envelope_size;
2762 _next_ordinal_to_read += 1;
2763 if next_offset >= end_offset {
2764 return Ok(());
2765 }
2766
2767 while _next_ordinal_to_read < 2 {
2769 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2770 _next_ordinal_to_read += 1;
2771 next_offset += envelope_size;
2772 }
2773
2774 let next_out_of_line = decoder.next_out_of_line();
2775 let handles_before = decoder.remaining_handles();
2776 if let Some((inlined, num_bytes, num_handles)) =
2777 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2778 {
2779 let member_inline_size = <fidl::encoding::HandleType<
2780 fidl::EventPair,
2781 { fidl::ObjectType::EVENTPAIR.into_raw() },
2782 2147483648,
2783 > as fidl::encoding::TypeMarker>::inline_size(
2784 decoder.context
2785 );
2786 if inlined != (member_inline_size <= 4) {
2787 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2788 }
2789 let inner_offset;
2790 let mut inner_depth = depth.clone();
2791 if inlined {
2792 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2793 inner_offset = next_offset;
2794 } else {
2795 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2796 inner_depth.increment()?;
2797 }
2798 let val_ref =
2799 self.wake_locks.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2800 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2801 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2802 {
2803 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2804 }
2805 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2806 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2807 }
2808 }
2809
2810 next_offset += envelope_size;
2811
2812 while next_offset < end_offset {
2814 _next_ordinal_to_read += 1;
2815 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2816 next_offset += envelope_size;
2817 }
2818
2819 Ok(())
2820 }
2821 }
2822
2823 impl PagerRegisterFileResponse {
2824 #[inline(always)]
2825 fn max_ordinal_present(&self) -> u64 {
2826 if let Some(_) = self.vmo {
2827 return 1;
2828 }
2829 0
2830 }
2831 }
2832
2833 impl fidl::encoding::ResourceTypeMarker for PagerRegisterFileResponse {
2834 type Borrowed<'a> = &'a mut Self;
2835 fn take_or_borrow<'a>(
2836 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2837 ) -> Self::Borrowed<'a> {
2838 value
2839 }
2840 }
2841
2842 unsafe impl fidl::encoding::TypeMarker for PagerRegisterFileResponse {
2843 type Owned = Self;
2844
2845 #[inline(always)]
2846 fn inline_align(_context: fidl::encoding::Context) -> usize {
2847 8
2848 }
2849
2850 #[inline(always)]
2851 fn inline_size(_context: fidl::encoding::Context) -> usize {
2852 16
2853 }
2854 }
2855
2856 unsafe impl
2857 fidl::encoding::Encode<
2858 PagerRegisterFileResponse,
2859 fidl::encoding::DefaultFuchsiaResourceDialect,
2860 > for &mut PagerRegisterFileResponse
2861 {
2862 unsafe fn encode(
2863 self,
2864 encoder: &mut fidl::encoding::Encoder<
2865 '_,
2866 fidl::encoding::DefaultFuchsiaResourceDialect,
2867 >,
2868 offset: usize,
2869 mut depth: fidl::encoding::Depth,
2870 ) -> fidl::Result<()> {
2871 encoder.debug_check_bounds::<PagerRegisterFileResponse>(offset);
2872 let max_ordinal: u64 = self.max_ordinal_present();
2874 encoder.write_num(max_ordinal, offset);
2875 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2876 if max_ordinal == 0 {
2878 return Ok(());
2879 }
2880 depth.increment()?;
2881 let envelope_size = 8;
2882 let bytes_len = max_ordinal as usize * envelope_size;
2883 #[allow(unused_variables)]
2884 let offset = encoder.out_of_line_offset(bytes_len);
2885 let mut _prev_end_offset: usize = 0;
2886 if 1 > max_ordinal {
2887 return Ok(());
2888 }
2889
2890 let cur_offset: usize = (1 - 1) * envelope_size;
2893
2894 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2896
2897 fidl::encoding::encode_in_envelope_optional::<
2902 fidl::encoding::HandleType<
2903 fidl::Vmo,
2904 { fidl::ObjectType::VMO.into_raw() },
2905 2147483648,
2906 >,
2907 fidl::encoding::DefaultFuchsiaResourceDialect,
2908 >(
2909 self.vmo.as_mut().map(
2910 <fidl::encoding::HandleType<
2911 fidl::Vmo,
2912 { fidl::ObjectType::VMO.into_raw() },
2913 2147483648,
2914 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2915 ),
2916 encoder,
2917 offset + cur_offset,
2918 depth,
2919 )?;
2920
2921 _prev_end_offset = cur_offset + envelope_size;
2922
2923 Ok(())
2924 }
2925 }
2926
2927 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2928 for PagerRegisterFileResponse
2929 {
2930 #[inline(always)]
2931 fn new_empty() -> Self {
2932 Self::default()
2933 }
2934
2935 unsafe fn decode(
2936 &mut self,
2937 decoder: &mut fidl::encoding::Decoder<
2938 '_,
2939 fidl::encoding::DefaultFuchsiaResourceDialect,
2940 >,
2941 offset: usize,
2942 mut depth: fidl::encoding::Depth,
2943 ) -> fidl::Result<()> {
2944 decoder.debug_check_bounds::<Self>(offset);
2945 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2946 None => return Err(fidl::Error::NotNullable),
2947 Some(len) => len,
2948 };
2949 if len == 0 {
2951 return Ok(());
2952 };
2953 depth.increment()?;
2954 let envelope_size = 8;
2955 let bytes_len = len * envelope_size;
2956 let offset = decoder.out_of_line_offset(bytes_len)?;
2957 let mut _next_ordinal_to_read = 0;
2959 let mut next_offset = offset;
2960 let end_offset = offset + bytes_len;
2961 _next_ordinal_to_read += 1;
2962 if next_offset >= end_offset {
2963 return Ok(());
2964 }
2965
2966 while _next_ordinal_to_read < 1 {
2968 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2969 _next_ordinal_to_read += 1;
2970 next_offset += envelope_size;
2971 }
2972
2973 let next_out_of_line = decoder.next_out_of_line();
2974 let handles_before = decoder.remaining_handles();
2975 if let Some((inlined, num_bytes, num_handles)) =
2976 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2977 {
2978 let member_inline_size = <fidl::encoding::HandleType<
2979 fidl::Vmo,
2980 { fidl::ObjectType::VMO.into_raw() },
2981 2147483648,
2982 > as fidl::encoding::TypeMarker>::inline_size(
2983 decoder.context
2984 );
2985 if inlined != (member_inline_size <= 4) {
2986 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2987 }
2988 let inner_offset;
2989 let mut inner_depth = depth.clone();
2990 if inlined {
2991 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2992 inner_offset = next_offset;
2993 } else {
2994 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2995 inner_depth.increment()?;
2996 }
2997 let val_ref =
2998 self.vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2999 fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
3000 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3001 {
3002 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3003 }
3004 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3005 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3006 }
3007 }
3008
3009 next_offset += envelope_size;
3010
3011 while next_offset < end_offset {
3013 _next_ordinal_to_read += 1;
3014 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3015 next_offset += envelope_size;
3016 }
3017
3018 Ok(())
3019 }
3020 }
3021}