fidl_test_systemactivitygovernor/
fidl_test_systemactivitygovernor.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_test_systemactivitygovernor__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct RealmFactoryCreateRealmExtRequest {
16    pub options: RealmOptions,
17    pub realm_server: fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
18}
19
20impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
21    for RealmFactoryCreateRealmExtRequest
22{
23}
24
25#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
26pub struct RealmFactoryCreateRealmRequest {
27    pub realm_server: fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
28}
29
30impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
31    for RealmFactoryCreateRealmRequest
32{
33}
34
35/// RealmOptions tells the RealmFactory protocol how to create the test realm.
36#[derive(Debug, Default, PartialEq)]
37pub struct RealmOptions {
38    /// Specifies whether to use a fake SAG that exposes additional protocols
39    /// to set/watch real SAG power element power levels. Defaults to false.
40    pub use_fake_sag: Option<bool>,
41    /// Specifies whether to set the fuchsia.power.WaitForSuspendingToken config
42    /// capability to true. If true, SAG will wait to receive a token through
43    /// [`fuchsia.power.system/CpuElementManager.AddExectuionStateDependency`].
44    /// If false, SAG will skip adding external Execution State dependencies.
45    /// Defaults to false.
46    pub wait_for_suspending_token: Option<bool>,
47    /// Specifies whether SAG will use a suspender or not. Defaults to true.
48    pub use_suspender: Option<bool>,
49    #[doc(hidden)]
50    pub __source_breaking: fidl::marker::SourceBreaking,
51}
52
53impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for RealmOptions {}
54
55#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
56pub struct RealmFactoryMarker;
57
58impl fidl::endpoints::ProtocolMarker for RealmFactoryMarker {
59    type Proxy = RealmFactoryProxy;
60    type RequestStream = RealmFactoryRequestStream;
61    #[cfg(target_os = "fuchsia")]
62    type SynchronousProxy = RealmFactorySynchronousProxy;
63
64    const DEBUG_NAME: &'static str = "test.systemactivitygovernor.RealmFactory";
65}
66impl fidl::endpoints::DiscoverableProtocolMarker for RealmFactoryMarker {}
67pub type RealmFactoryCreateRealmResult =
68    Result<String, fidl_fuchsia_testing_harness::OperationError>;
69pub type RealmFactoryCreateRealmExtResult =
70    Result<String, fidl_fuchsia_testing_harness::OperationError>;
71
72pub trait RealmFactoryProxyInterface: Send + Sync {
73    type CreateRealmResponseFut: std::future::Future<Output = Result<RealmFactoryCreateRealmResult, fidl::Error>>
74        + Send;
75    fn r#create_realm(
76        &self,
77        realm_server: fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
78    ) -> Self::CreateRealmResponseFut;
79    type CreateRealmExtResponseFut: std::future::Future<Output = Result<RealmFactoryCreateRealmExtResult, fidl::Error>>
80        + Send;
81    fn r#create_realm_ext(
82        &self,
83        options: RealmOptions,
84        realm_server: fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
85    ) -> Self::CreateRealmExtResponseFut;
86}
87#[derive(Debug)]
88#[cfg(target_os = "fuchsia")]
89pub struct RealmFactorySynchronousProxy {
90    client: fidl::client::sync::Client,
91}
92
93#[cfg(target_os = "fuchsia")]
94impl fidl::endpoints::SynchronousProxy for RealmFactorySynchronousProxy {
95    type Proxy = RealmFactoryProxy;
96    type Protocol = RealmFactoryMarker;
97
98    fn from_channel(inner: fidl::Channel) -> Self {
99        Self::new(inner)
100    }
101
102    fn into_channel(self) -> fidl::Channel {
103        self.client.into_channel()
104    }
105
106    fn as_channel(&self) -> &fidl::Channel {
107        self.client.as_channel()
108    }
109}
110
111#[cfg(target_os = "fuchsia")]
112impl RealmFactorySynchronousProxy {
113    pub fn new(channel: fidl::Channel) -> Self {
114        Self { client: fidl::client::sync::Client::new(channel) }
115    }
116
117    pub fn into_channel(self) -> fidl::Channel {
118        self.client.into_channel()
119    }
120
121    /// Waits until an event arrives and returns it. It is safe for other
122    /// threads to make concurrent requests while waiting for an event.
123    pub fn wait_for_event(
124        &self,
125        deadline: zx::MonotonicInstant,
126    ) -> Result<RealmFactoryEvent, fidl::Error> {
127        RealmFactoryEvent::decode(self.client.wait_for_event::<RealmFactoryMarker>(deadline)?)
128    }
129
130    /// Creates a new realm and binds the given RealmProxy server end to it.
131    pub fn r#create_realm(
132        &self,
133        mut realm_server: fidl::endpoints::ServerEnd<
134            fidl_fuchsia_testing_harness::RealmProxy_Marker,
135        >,
136        ___deadline: zx::MonotonicInstant,
137    ) -> Result<RealmFactoryCreateRealmResult, fidl::Error> {
138        let _response = self
139            .client
140            .send_query::<RealmFactoryCreateRealmRequest, fidl::encoding::FlexibleResultType<
141                RealmFactoryCreateRealmResponse,
142                fidl_fuchsia_testing_harness::OperationError,
143            >, RealmFactoryMarker>(
144                (realm_server,),
145                0x3fcb27aa634a2df3,
146                fidl::encoding::DynamicFlags::FLEXIBLE,
147                ___deadline,
148            )?
149            .into_result::<RealmFactoryMarker>("create_realm")?;
150        Ok(_response.map(|x| x.activity_governor_moniker))
151    }
152
153    /// Creates a new realm and accepts options.
154    pub fn r#create_realm_ext(
155        &self,
156        mut options: RealmOptions,
157        mut realm_server: fidl::endpoints::ServerEnd<
158            fidl_fuchsia_testing_harness::RealmProxy_Marker,
159        >,
160        ___deadline: zx::MonotonicInstant,
161    ) -> Result<RealmFactoryCreateRealmExtResult, fidl::Error> {
162        let _response = self
163            .client
164            .send_query::<RealmFactoryCreateRealmExtRequest, fidl::encoding::FlexibleResultType<
165                RealmFactoryCreateRealmExtResponse,
166                fidl_fuchsia_testing_harness::OperationError,
167            >, RealmFactoryMarker>(
168                (&mut options, realm_server),
169                0x63a655ff630a0db0,
170                fidl::encoding::DynamicFlags::FLEXIBLE,
171                ___deadline,
172            )?
173            .into_result::<RealmFactoryMarker>("create_realm_ext")?;
174        Ok(_response.map(|x| x.activity_governor_moniker))
175    }
176}
177
178#[cfg(target_os = "fuchsia")]
179impl From<RealmFactorySynchronousProxy> for zx::NullableHandle {
180    fn from(value: RealmFactorySynchronousProxy) -> Self {
181        value.into_channel().into()
182    }
183}
184
185#[cfg(target_os = "fuchsia")]
186impl From<fidl::Channel> for RealmFactorySynchronousProxy {
187    fn from(value: fidl::Channel) -> Self {
188        Self::new(value)
189    }
190}
191
192#[cfg(target_os = "fuchsia")]
193impl fidl::endpoints::FromClient for RealmFactorySynchronousProxy {
194    type Protocol = RealmFactoryMarker;
195
196    fn from_client(value: fidl::endpoints::ClientEnd<RealmFactoryMarker>) -> Self {
197        Self::new(value.into_channel())
198    }
199}
200
201#[derive(Debug, Clone)]
202pub struct RealmFactoryProxy {
203    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
204}
205
206impl fidl::endpoints::Proxy for RealmFactoryProxy {
207    type Protocol = RealmFactoryMarker;
208
209    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
210        Self::new(inner)
211    }
212
213    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
214        self.client.into_channel().map_err(|client| Self { client })
215    }
216
217    fn as_channel(&self) -> &::fidl::AsyncChannel {
218        self.client.as_channel()
219    }
220}
221
222impl RealmFactoryProxy {
223    /// Create a new Proxy for test.systemactivitygovernor/RealmFactory.
224    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
225        let protocol_name = <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
226        Self { client: fidl::client::Client::new(channel, protocol_name) }
227    }
228
229    /// Get a Stream of events from the remote end of the protocol.
230    ///
231    /// # Panics
232    ///
233    /// Panics if the event stream was already taken.
234    pub fn take_event_stream(&self) -> RealmFactoryEventStream {
235        RealmFactoryEventStream { event_receiver: self.client.take_event_receiver() }
236    }
237
238    /// Creates a new realm and binds the given RealmProxy server end to it.
239    pub fn r#create_realm(
240        &self,
241        mut realm_server: fidl::endpoints::ServerEnd<
242            fidl_fuchsia_testing_harness::RealmProxy_Marker,
243        >,
244    ) -> fidl::client::QueryResponseFut<
245        RealmFactoryCreateRealmResult,
246        fidl::encoding::DefaultFuchsiaResourceDialect,
247    > {
248        RealmFactoryProxyInterface::r#create_realm(self, realm_server)
249    }
250
251    /// Creates a new realm and accepts options.
252    pub fn r#create_realm_ext(
253        &self,
254        mut options: RealmOptions,
255        mut realm_server: fidl::endpoints::ServerEnd<
256            fidl_fuchsia_testing_harness::RealmProxy_Marker,
257        >,
258    ) -> fidl::client::QueryResponseFut<
259        RealmFactoryCreateRealmExtResult,
260        fidl::encoding::DefaultFuchsiaResourceDialect,
261    > {
262        RealmFactoryProxyInterface::r#create_realm_ext(self, options, realm_server)
263    }
264}
265
266impl RealmFactoryProxyInterface for RealmFactoryProxy {
267    type CreateRealmResponseFut = fidl::client::QueryResponseFut<
268        RealmFactoryCreateRealmResult,
269        fidl::encoding::DefaultFuchsiaResourceDialect,
270    >;
271    fn r#create_realm(
272        &self,
273        mut realm_server: fidl::endpoints::ServerEnd<
274            fidl_fuchsia_testing_harness::RealmProxy_Marker,
275        >,
276    ) -> Self::CreateRealmResponseFut {
277        fn _decode(
278            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
279        ) -> Result<RealmFactoryCreateRealmResult, fidl::Error> {
280            let _response = fidl::client::decode_transaction_body::<
281                fidl::encoding::FlexibleResultType<
282                    RealmFactoryCreateRealmResponse,
283                    fidl_fuchsia_testing_harness::OperationError,
284                >,
285                fidl::encoding::DefaultFuchsiaResourceDialect,
286                0x3fcb27aa634a2df3,
287            >(_buf?)?
288            .into_result::<RealmFactoryMarker>("create_realm")?;
289            Ok(_response.map(|x| x.activity_governor_moniker))
290        }
291        self.client
292            .send_query_and_decode::<RealmFactoryCreateRealmRequest, RealmFactoryCreateRealmResult>(
293                (realm_server,),
294                0x3fcb27aa634a2df3,
295                fidl::encoding::DynamicFlags::FLEXIBLE,
296                _decode,
297            )
298    }
299
300    type CreateRealmExtResponseFut = fidl::client::QueryResponseFut<
301        RealmFactoryCreateRealmExtResult,
302        fidl::encoding::DefaultFuchsiaResourceDialect,
303    >;
304    fn r#create_realm_ext(
305        &self,
306        mut options: RealmOptions,
307        mut realm_server: fidl::endpoints::ServerEnd<
308            fidl_fuchsia_testing_harness::RealmProxy_Marker,
309        >,
310    ) -> Self::CreateRealmExtResponseFut {
311        fn _decode(
312            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
313        ) -> Result<RealmFactoryCreateRealmExtResult, fidl::Error> {
314            let _response = fidl::client::decode_transaction_body::<
315                fidl::encoding::FlexibleResultType<
316                    RealmFactoryCreateRealmExtResponse,
317                    fidl_fuchsia_testing_harness::OperationError,
318                >,
319                fidl::encoding::DefaultFuchsiaResourceDialect,
320                0x63a655ff630a0db0,
321            >(_buf?)?
322            .into_result::<RealmFactoryMarker>("create_realm_ext")?;
323            Ok(_response.map(|x| x.activity_governor_moniker))
324        }
325        self.client.send_query_and_decode::<
326            RealmFactoryCreateRealmExtRequest,
327            RealmFactoryCreateRealmExtResult,
328        >(
329            (&mut options, realm_server,),
330            0x63a655ff630a0db0,
331            fidl::encoding::DynamicFlags::FLEXIBLE,
332            _decode,
333        )
334    }
335}
336
337pub struct RealmFactoryEventStream {
338    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
339}
340
341impl std::marker::Unpin for RealmFactoryEventStream {}
342
343impl futures::stream::FusedStream for RealmFactoryEventStream {
344    fn is_terminated(&self) -> bool {
345        self.event_receiver.is_terminated()
346    }
347}
348
349impl futures::Stream for RealmFactoryEventStream {
350    type Item = Result<RealmFactoryEvent, fidl::Error>;
351
352    fn poll_next(
353        mut self: std::pin::Pin<&mut Self>,
354        cx: &mut std::task::Context<'_>,
355    ) -> std::task::Poll<Option<Self::Item>> {
356        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
357            &mut self.event_receiver,
358            cx
359        )?) {
360            Some(buf) => std::task::Poll::Ready(Some(RealmFactoryEvent::decode(buf))),
361            None => std::task::Poll::Ready(None),
362        }
363    }
364}
365
366#[derive(Debug)]
367pub enum RealmFactoryEvent {
368    #[non_exhaustive]
369    _UnknownEvent {
370        /// Ordinal of the event that was sent.
371        ordinal: u64,
372    },
373}
374
375impl RealmFactoryEvent {
376    /// Decodes a message buffer as a [`RealmFactoryEvent`].
377    fn decode(
378        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
379    ) -> Result<RealmFactoryEvent, fidl::Error> {
380        let (bytes, _handles) = buf.split_mut();
381        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
382        debug_assert_eq!(tx_header.tx_id, 0);
383        match tx_header.ordinal {
384            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
385                Ok(RealmFactoryEvent::_UnknownEvent { ordinal: tx_header.ordinal })
386            }
387            _ => Err(fidl::Error::UnknownOrdinal {
388                ordinal: tx_header.ordinal,
389                protocol_name: <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
390            }),
391        }
392    }
393}
394
395/// A Stream of incoming requests for test.systemactivitygovernor/RealmFactory.
396pub struct RealmFactoryRequestStream {
397    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
398    is_terminated: bool,
399}
400
401impl std::marker::Unpin for RealmFactoryRequestStream {}
402
403impl futures::stream::FusedStream for RealmFactoryRequestStream {
404    fn is_terminated(&self) -> bool {
405        self.is_terminated
406    }
407}
408
409impl fidl::endpoints::RequestStream for RealmFactoryRequestStream {
410    type Protocol = RealmFactoryMarker;
411    type ControlHandle = RealmFactoryControlHandle;
412
413    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
414        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
415    }
416
417    fn control_handle(&self) -> Self::ControlHandle {
418        RealmFactoryControlHandle { inner: self.inner.clone() }
419    }
420
421    fn into_inner(
422        self,
423    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
424    {
425        (self.inner, self.is_terminated)
426    }
427
428    fn from_inner(
429        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
430        is_terminated: bool,
431    ) -> Self {
432        Self { inner, is_terminated }
433    }
434}
435
436impl futures::Stream for RealmFactoryRequestStream {
437    type Item = Result<RealmFactoryRequest, fidl::Error>;
438
439    fn poll_next(
440        mut self: std::pin::Pin<&mut Self>,
441        cx: &mut std::task::Context<'_>,
442    ) -> std::task::Poll<Option<Self::Item>> {
443        let this = &mut *self;
444        if this.inner.check_shutdown(cx) {
445            this.is_terminated = true;
446            return std::task::Poll::Ready(None);
447        }
448        if this.is_terminated {
449            panic!("polled RealmFactoryRequestStream after completion");
450        }
451        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
452            |bytes, handles| {
453                match this.inner.channel().read_etc(cx, bytes, handles) {
454                    std::task::Poll::Ready(Ok(())) => {}
455                    std::task::Poll::Pending => return std::task::Poll::Pending,
456                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
457                        this.is_terminated = true;
458                        return std::task::Poll::Ready(None);
459                    }
460                    std::task::Poll::Ready(Err(e)) => {
461                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
462                            e.into(),
463                        ))));
464                    }
465                }
466
467                // A message has been received from the channel
468                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
469
470                std::task::Poll::Ready(Some(match header.ordinal {
471                    0x3fcb27aa634a2df3 => {
472                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
473                        let mut req = fidl::new_empty!(
474                            RealmFactoryCreateRealmRequest,
475                            fidl::encoding::DefaultFuchsiaResourceDialect
476                        );
477                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmFactoryCreateRealmRequest>(&header, _body_bytes, handles, &mut req)?;
478                        let control_handle =
479                            RealmFactoryControlHandle { inner: this.inner.clone() };
480                        Ok(RealmFactoryRequest::CreateRealm {
481                            realm_server: req.realm_server,
482
483                            responder: RealmFactoryCreateRealmResponder {
484                                control_handle: std::mem::ManuallyDrop::new(control_handle),
485                                tx_id: header.tx_id,
486                            },
487                        })
488                    }
489                    0x63a655ff630a0db0 => {
490                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
491                        let mut req = fidl::new_empty!(
492                            RealmFactoryCreateRealmExtRequest,
493                            fidl::encoding::DefaultFuchsiaResourceDialect
494                        );
495                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmFactoryCreateRealmExtRequest>(&header, _body_bytes, handles, &mut req)?;
496                        let control_handle =
497                            RealmFactoryControlHandle { inner: this.inner.clone() };
498                        Ok(RealmFactoryRequest::CreateRealmExt {
499                            options: req.options,
500                            realm_server: req.realm_server,
501
502                            responder: RealmFactoryCreateRealmExtResponder {
503                                control_handle: std::mem::ManuallyDrop::new(control_handle),
504                                tx_id: header.tx_id,
505                            },
506                        })
507                    }
508                    _ if header.tx_id == 0
509                        && header
510                            .dynamic_flags()
511                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
512                    {
513                        Ok(RealmFactoryRequest::_UnknownMethod {
514                            ordinal: header.ordinal,
515                            control_handle: RealmFactoryControlHandle { inner: this.inner.clone() },
516                            method_type: fidl::MethodType::OneWay,
517                        })
518                    }
519                    _ if header
520                        .dynamic_flags()
521                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
522                    {
523                        this.inner.send_framework_err(
524                            fidl::encoding::FrameworkErr::UnknownMethod,
525                            header.tx_id,
526                            header.ordinal,
527                            header.dynamic_flags(),
528                            (bytes, handles),
529                        )?;
530                        Ok(RealmFactoryRequest::_UnknownMethod {
531                            ordinal: header.ordinal,
532                            control_handle: RealmFactoryControlHandle { inner: this.inner.clone() },
533                            method_type: fidl::MethodType::TwoWay,
534                        })
535                    }
536                    _ => Err(fidl::Error::UnknownOrdinal {
537                        ordinal: header.ordinal,
538                        protocol_name:
539                            <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
540                    }),
541                }))
542            },
543        )
544    }
545}
546
547#[derive(Debug)]
548pub enum RealmFactoryRequest {
549    /// Creates a new realm and binds the given RealmProxy server end to it.
550    CreateRealm {
551        realm_server: fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
552        responder: RealmFactoryCreateRealmResponder,
553    },
554    /// Creates a new realm and accepts options.
555    CreateRealmExt {
556        options: RealmOptions,
557        realm_server: fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
558        responder: RealmFactoryCreateRealmExtResponder,
559    },
560    /// An interaction was received which does not match any known method.
561    #[non_exhaustive]
562    _UnknownMethod {
563        /// Ordinal of the method that was called.
564        ordinal: u64,
565        control_handle: RealmFactoryControlHandle,
566        method_type: fidl::MethodType,
567    },
568}
569
570impl RealmFactoryRequest {
571    #[allow(irrefutable_let_patterns)]
572    pub fn into_create_realm(
573        self,
574    ) -> Option<(
575        fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
576        RealmFactoryCreateRealmResponder,
577    )> {
578        if let RealmFactoryRequest::CreateRealm { realm_server, responder } = self {
579            Some((realm_server, responder))
580        } else {
581            None
582        }
583    }
584
585    #[allow(irrefutable_let_patterns)]
586    pub fn into_create_realm_ext(
587        self,
588    ) -> Option<(
589        RealmOptions,
590        fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
591        RealmFactoryCreateRealmExtResponder,
592    )> {
593        if let RealmFactoryRequest::CreateRealmExt { options, realm_server, responder } = self {
594            Some((options, realm_server, responder))
595        } else {
596            None
597        }
598    }
599
600    /// Name of the method defined in FIDL
601    pub fn method_name(&self) -> &'static str {
602        match *self {
603            RealmFactoryRequest::CreateRealm { .. } => "create_realm",
604            RealmFactoryRequest::CreateRealmExt { .. } => "create_realm_ext",
605            RealmFactoryRequest::_UnknownMethod {
606                method_type: fidl::MethodType::OneWay, ..
607            } => "unknown one-way method",
608            RealmFactoryRequest::_UnknownMethod {
609                method_type: fidl::MethodType::TwoWay, ..
610            } => "unknown two-way method",
611        }
612    }
613}
614
615#[derive(Debug, Clone)]
616pub struct RealmFactoryControlHandle {
617    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
618}
619
620impl fidl::endpoints::ControlHandle for RealmFactoryControlHandle {
621    fn shutdown(&self) {
622        self.inner.shutdown()
623    }
624
625    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
626        self.inner.shutdown_with_epitaph(status)
627    }
628
629    fn is_closed(&self) -> bool {
630        self.inner.channel().is_closed()
631    }
632    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
633        self.inner.channel().on_closed()
634    }
635
636    #[cfg(target_os = "fuchsia")]
637    fn signal_peer(
638        &self,
639        clear_mask: zx::Signals,
640        set_mask: zx::Signals,
641    ) -> Result<(), zx_status::Status> {
642        use fidl::Peered;
643        self.inner.channel().signal_peer(clear_mask, set_mask)
644    }
645}
646
647impl RealmFactoryControlHandle {}
648
649#[must_use = "FIDL methods require a response to be sent"]
650#[derive(Debug)]
651pub struct RealmFactoryCreateRealmResponder {
652    control_handle: std::mem::ManuallyDrop<RealmFactoryControlHandle>,
653    tx_id: u32,
654}
655
656/// Set the the channel to be shutdown (see [`RealmFactoryControlHandle::shutdown`])
657/// if the responder is dropped without sending a response, so that the client
658/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
659impl std::ops::Drop for RealmFactoryCreateRealmResponder {
660    fn drop(&mut self) {
661        self.control_handle.shutdown();
662        // Safety: drops once, never accessed again
663        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
664    }
665}
666
667impl fidl::endpoints::Responder for RealmFactoryCreateRealmResponder {
668    type ControlHandle = RealmFactoryControlHandle;
669
670    fn control_handle(&self) -> &RealmFactoryControlHandle {
671        &self.control_handle
672    }
673
674    fn drop_without_shutdown(mut self) {
675        // Safety: drops once, never accessed again due to mem::forget
676        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
677        // Prevent Drop from running (which would shut down the channel)
678        std::mem::forget(self);
679    }
680}
681
682impl RealmFactoryCreateRealmResponder {
683    /// Sends a response to the FIDL transaction.
684    ///
685    /// Sets the channel to shutdown if an error occurs.
686    pub fn send(
687        self,
688        mut result: Result<&str, fidl_fuchsia_testing_harness::OperationError>,
689    ) -> Result<(), fidl::Error> {
690        let _result = self.send_raw(result);
691        if _result.is_err() {
692            self.control_handle.shutdown();
693        }
694        self.drop_without_shutdown();
695        _result
696    }
697
698    /// Similar to "send" but does not shutdown the channel if an error occurs.
699    pub fn send_no_shutdown_on_err(
700        self,
701        mut result: Result<&str, fidl_fuchsia_testing_harness::OperationError>,
702    ) -> Result<(), fidl::Error> {
703        let _result = self.send_raw(result);
704        self.drop_without_shutdown();
705        _result
706    }
707
708    fn send_raw(
709        &self,
710        mut result: Result<&str, fidl_fuchsia_testing_harness::OperationError>,
711    ) -> Result<(), fidl::Error> {
712        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
713            RealmFactoryCreateRealmResponse,
714            fidl_fuchsia_testing_harness::OperationError,
715        >>(
716            fidl::encoding::FlexibleResult::new(
717                result.map(|activity_governor_moniker| (activity_governor_moniker,)),
718            ),
719            self.tx_id,
720            0x3fcb27aa634a2df3,
721            fidl::encoding::DynamicFlags::FLEXIBLE,
722        )
723    }
724}
725
726#[must_use = "FIDL methods require a response to be sent"]
727#[derive(Debug)]
728pub struct RealmFactoryCreateRealmExtResponder {
729    control_handle: std::mem::ManuallyDrop<RealmFactoryControlHandle>,
730    tx_id: u32,
731}
732
733/// Set the the channel to be shutdown (see [`RealmFactoryControlHandle::shutdown`])
734/// if the responder is dropped without sending a response, so that the client
735/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
736impl std::ops::Drop for RealmFactoryCreateRealmExtResponder {
737    fn drop(&mut self) {
738        self.control_handle.shutdown();
739        // Safety: drops once, never accessed again
740        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
741    }
742}
743
744impl fidl::endpoints::Responder for RealmFactoryCreateRealmExtResponder {
745    type ControlHandle = RealmFactoryControlHandle;
746
747    fn control_handle(&self) -> &RealmFactoryControlHandle {
748        &self.control_handle
749    }
750
751    fn drop_without_shutdown(mut self) {
752        // Safety: drops once, never accessed again due to mem::forget
753        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
754        // Prevent Drop from running (which would shut down the channel)
755        std::mem::forget(self);
756    }
757}
758
759impl RealmFactoryCreateRealmExtResponder {
760    /// Sends a response to the FIDL transaction.
761    ///
762    /// Sets the channel to shutdown if an error occurs.
763    pub fn send(
764        self,
765        mut result: Result<&str, fidl_fuchsia_testing_harness::OperationError>,
766    ) -> Result<(), fidl::Error> {
767        let _result = self.send_raw(result);
768        if _result.is_err() {
769            self.control_handle.shutdown();
770        }
771        self.drop_without_shutdown();
772        _result
773    }
774
775    /// Similar to "send" but does not shutdown the channel if an error occurs.
776    pub fn send_no_shutdown_on_err(
777        self,
778        mut result: Result<&str, fidl_fuchsia_testing_harness::OperationError>,
779    ) -> Result<(), fidl::Error> {
780        let _result = self.send_raw(result);
781        self.drop_without_shutdown();
782        _result
783    }
784
785    fn send_raw(
786        &self,
787        mut result: Result<&str, fidl_fuchsia_testing_harness::OperationError>,
788    ) -> Result<(), fidl::Error> {
789        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
790            RealmFactoryCreateRealmExtResponse,
791            fidl_fuchsia_testing_harness::OperationError,
792        >>(
793            fidl::encoding::FlexibleResult::new(
794                result.map(|activity_governor_moniker| (activity_governor_moniker,)),
795            ),
796            self.tx_id,
797            0x63a655ff630a0db0,
798            fidl::encoding::DynamicFlags::FLEXIBLE,
799        )
800    }
801}
802
803mod internal {
804    use super::*;
805
806    impl fidl::encoding::ResourceTypeMarker for RealmFactoryCreateRealmExtRequest {
807        type Borrowed<'a> = &'a mut Self;
808        fn take_or_borrow<'a>(
809            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
810        ) -> Self::Borrowed<'a> {
811            value
812        }
813    }
814
815    unsafe impl fidl::encoding::TypeMarker for RealmFactoryCreateRealmExtRequest {
816        type Owned = Self;
817
818        #[inline(always)]
819        fn inline_align(_context: fidl::encoding::Context) -> usize {
820            8
821        }
822
823        #[inline(always)]
824        fn inline_size(_context: fidl::encoding::Context) -> usize {
825            24
826        }
827    }
828
829    unsafe impl
830        fidl::encoding::Encode<
831            RealmFactoryCreateRealmExtRequest,
832            fidl::encoding::DefaultFuchsiaResourceDialect,
833        > for &mut RealmFactoryCreateRealmExtRequest
834    {
835        #[inline]
836        unsafe fn encode(
837            self,
838            encoder: &mut fidl::encoding::Encoder<
839                '_,
840                fidl::encoding::DefaultFuchsiaResourceDialect,
841            >,
842            offset: usize,
843            _depth: fidl::encoding::Depth,
844        ) -> fidl::Result<()> {
845            encoder.debug_check_bounds::<RealmFactoryCreateRealmExtRequest>(offset);
846            // Delegate to tuple encoding.
847            fidl::encoding::Encode::<
848                RealmFactoryCreateRealmExtRequest,
849                fidl::encoding::DefaultFuchsiaResourceDialect,
850            >::encode(
851                (
852                    <RealmOptions as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
853                        &mut self.options,
854                    ),
855                    <fidl::encoding::Endpoint<
856                        fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
857                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
858                        &mut self.realm_server,
859                    ),
860                ),
861                encoder,
862                offset,
863                _depth,
864            )
865        }
866    }
867    unsafe impl<
868        T0: fidl::encoding::Encode<RealmOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
869        T1: fidl::encoding::Encode<
870                fidl::encoding::Endpoint<
871                    fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
872                >,
873                fidl::encoding::DefaultFuchsiaResourceDialect,
874            >,
875    >
876        fidl::encoding::Encode<
877            RealmFactoryCreateRealmExtRequest,
878            fidl::encoding::DefaultFuchsiaResourceDialect,
879        > for (T0, T1)
880    {
881        #[inline]
882        unsafe fn encode(
883            self,
884            encoder: &mut fidl::encoding::Encoder<
885                '_,
886                fidl::encoding::DefaultFuchsiaResourceDialect,
887            >,
888            offset: usize,
889            depth: fidl::encoding::Depth,
890        ) -> fidl::Result<()> {
891            encoder.debug_check_bounds::<RealmFactoryCreateRealmExtRequest>(offset);
892            // Zero out padding regions. There's no need to apply masks
893            // because the unmasked parts will be overwritten by fields.
894            unsafe {
895                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
896                (ptr as *mut u64).write_unaligned(0);
897            }
898            // Write the fields.
899            self.0.encode(encoder, offset + 0, depth)?;
900            self.1.encode(encoder, offset + 16, depth)?;
901            Ok(())
902        }
903    }
904
905    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
906        for RealmFactoryCreateRealmExtRequest
907    {
908        #[inline(always)]
909        fn new_empty() -> Self {
910            Self {
911                options: fidl::new_empty!(
912                    RealmOptions,
913                    fidl::encoding::DefaultFuchsiaResourceDialect
914                ),
915                realm_server: fidl::new_empty!(
916                    fidl::encoding::Endpoint<
917                        fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
918                    >,
919                    fidl::encoding::DefaultFuchsiaResourceDialect
920                ),
921            }
922        }
923
924        #[inline]
925        unsafe fn decode(
926            &mut self,
927            decoder: &mut fidl::encoding::Decoder<
928                '_,
929                fidl::encoding::DefaultFuchsiaResourceDialect,
930            >,
931            offset: usize,
932            _depth: fidl::encoding::Depth,
933        ) -> fidl::Result<()> {
934            decoder.debug_check_bounds::<Self>(offset);
935            // Verify that padding bytes are zero.
936            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
937            let padval = unsafe { (ptr as *const u64).read_unaligned() };
938            let mask = 0xffffffff00000000u64;
939            let maskedval = padval & mask;
940            if maskedval != 0 {
941                return Err(fidl::Error::NonZeroPadding {
942                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
943                });
944            }
945            fidl::decode!(
946                RealmOptions,
947                fidl::encoding::DefaultFuchsiaResourceDialect,
948                &mut self.options,
949                decoder,
950                offset + 0,
951                _depth
952            )?;
953            fidl::decode!(
954                fidl::encoding::Endpoint<
955                    fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
956                >,
957                fidl::encoding::DefaultFuchsiaResourceDialect,
958                &mut self.realm_server,
959                decoder,
960                offset + 16,
961                _depth
962            )?;
963            Ok(())
964        }
965    }
966
967    impl fidl::encoding::ResourceTypeMarker for RealmFactoryCreateRealmRequest {
968        type Borrowed<'a> = &'a mut Self;
969        fn take_or_borrow<'a>(
970            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
971        ) -> Self::Borrowed<'a> {
972            value
973        }
974    }
975
976    unsafe impl fidl::encoding::TypeMarker for RealmFactoryCreateRealmRequest {
977        type Owned = Self;
978
979        #[inline(always)]
980        fn inline_align(_context: fidl::encoding::Context) -> usize {
981            4
982        }
983
984        #[inline(always)]
985        fn inline_size(_context: fidl::encoding::Context) -> usize {
986            4
987        }
988    }
989
990    unsafe impl
991        fidl::encoding::Encode<
992            RealmFactoryCreateRealmRequest,
993            fidl::encoding::DefaultFuchsiaResourceDialect,
994        > for &mut RealmFactoryCreateRealmRequest
995    {
996        #[inline]
997        unsafe fn encode(
998            self,
999            encoder: &mut fidl::encoding::Encoder<
1000                '_,
1001                fidl::encoding::DefaultFuchsiaResourceDialect,
1002            >,
1003            offset: usize,
1004            _depth: fidl::encoding::Depth,
1005        ) -> fidl::Result<()> {
1006            encoder.debug_check_bounds::<RealmFactoryCreateRealmRequest>(offset);
1007            // Delegate to tuple encoding.
1008            fidl::encoding::Encode::<
1009                RealmFactoryCreateRealmRequest,
1010                fidl::encoding::DefaultFuchsiaResourceDialect,
1011            >::encode(
1012                (<fidl::encoding::Endpoint<
1013                    fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1014                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1015                    &mut self.realm_server
1016                ),),
1017                encoder,
1018                offset,
1019                _depth,
1020            )
1021        }
1022    }
1023    unsafe impl<
1024        T0: fidl::encoding::Encode<
1025                fidl::encoding::Endpoint<
1026                    fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1027                >,
1028                fidl::encoding::DefaultFuchsiaResourceDialect,
1029            >,
1030    >
1031        fidl::encoding::Encode<
1032            RealmFactoryCreateRealmRequest,
1033            fidl::encoding::DefaultFuchsiaResourceDialect,
1034        > for (T0,)
1035    {
1036        #[inline]
1037        unsafe fn encode(
1038            self,
1039            encoder: &mut fidl::encoding::Encoder<
1040                '_,
1041                fidl::encoding::DefaultFuchsiaResourceDialect,
1042            >,
1043            offset: usize,
1044            depth: fidl::encoding::Depth,
1045        ) -> fidl::Result<()> {
1046            encoder.debug_check_bounds::<RealmFactoryCreateRealmRequest>(offset);
1047            // Zero out padding regions. There's no need to apply masks
1048            // because the unmasked parts will be overwritten by fields.
1049            // Write the fields.
1050            self.0.encode(encoder, offset + 0, depth)?;
1051            Ok(())
1052        }
1053    }
1054
1055    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1056        for RealmFactoryCreateRealmRequest
1057    {
1058        #[inline(always)]
1059        fn new_empty() -> Self {
1060            Self {
1061                realm_server: fidl::new_empty!(
1062                    fidl::encoding::Endpoint<
1063                        fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1064                    >,
1065                    fidl::encoding::DefaultFuchsiaResourceDialect
1066                ),
1067            }
1068        }
1069
1070        #[inline]
1071        unsafe fn decode(
1072            &mut self,
1073            decoder: &mut fidl::encoding::Decoder<
1074                '_,
1075                fidl::encoding::DefaultFuchsiaResourceDialect,
1076            >,
1077            offset: usize,
1078            _depth: fidl::encoding::Depth,
1079        ) -> fidl::Result<()> {
1080            decoder.debug_check_bounds::<Self>(offset);
1081            // Verify that padding bytes are zero.
1082            fidl::decode!(
1083                fidl::encoding::Endpoint<
1084                    fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1085                >,
1086                fidl::encoding::DefaultFuchsiaResourceDialect,
1087                &mut self.realm_server,
1088                decoder,
1089                offset + 0,
1090                _depth
1091            )?;
1092            Ok(())
1093        }
1094    }
1095
1096    impl RealmOptions {
1097        #[inline(always)]
1098        fn max_ordinal_present(&self) -> u64 {
1099            if let Some(_) = self.use_suspender {
1100                return 3;
1101            }
1102            if let Some(_) = self.wait_for_suspending_token {
1103                return 2;
1104            }
1105            if let Some(_) = self.use_fake_sag {
1106                return 1;
1107            }
1108            0
1109        }
1110    }
1111
1112    impl fidl::encoding::ResourceTypeMarker for RealmOptions {
1113        type Borrowed<'a> = &'a mut Self;
1114        fn take_or_borrow<'a>(
1115            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1116        ) -> Self::Borrowed<'a> {
1117            value
1118        }
1119    }
1120
1121    unsafe impl fidl::encoding::TypeMarker for RealmOptions {
1122        type Owned = Self;
1123
1124        #[inline(always)]
1125        fn inline_align(_context: fidl::encoding::Context) -> usize {
1126            8
1127        }
1128
1129        #[inline(always)]
1130        fn inline_size(_context: fidl::encoding::Context) -> usize {
1131            16
1132        }
1133    }
1134
1135    unsafe impl fidl::encoding::Encode<RealmOptions, fidl::encoding::DefaultFuchsiaResourceDialect>
1136        for &mut RealmOptions
1137    {
1138        unsafe fn encode(
1139            self,
1140            encoder: &mut fidl::encoding::Encoder<
1141                '_,
1142                fidl::encoding::DefaultFuchsiaResourceDialect,
1143            >,
1144            offset: usize,
1145            mut depth: fidl::encoding::Depth,
1146        ) -> fidl::Result<()> {
1147            encoder.debug_check_bounds::<RealmOptions>(offset);
1148            // Vector header
1149            let max_ordinal: u64 = self.max_ordinal_present();
1150            encoder.write_num(max_ordinal, offset);
1151            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1152            // Calling encoder.out_of_line_offset(0) is not allowed.
1153            if max_ordinal == 0 {
1154                return Ok(());
1155            }
1156            depth.increment()?;
1157            let envelope_size = 8;
1158            let bytes_len = max_ordinal as usize * envelope_size;
1159            #[allow(unused_variables)]
1160            let offset = encoder.out_of_line_offset(bytes_len);
1161            let mut _prev_end_offset: usize = 0;
1162            if 1 > max_ordinal {
1163                return Ok(());
1164            }
1165
1166            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1167            // are envelope_size bytes.
1168            let cur_offset: usize = (1 - 1) * envelope_size;
1169
1170            // Zero reserved fields.
1171            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1172
1173            // Safety:
1174            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1175            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1176            //   envelope_size bytes, there is always sufficient room.
1177            fidl::encoding::encode_in_envelope_optional::<
1178                bool,
1179                fidl::encoding::DefaultFuchsiaResourceDialect,
1180            >(
1181                self.use_fake_sag.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1182                encoder,
1183                offset + cur_offset,
1184                depth,
1185            )?;
1186
1187            _prev_end_offset = cur_offset + envelope_size;
1188            if 2 > max_ordinal {
1189                return Ok(());
1190            }
1191
1192            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1193            // are envelope_size bytes.
1194            let cur_offset: usize = (2 - 1) * envelope_size;
1195
1196            // Zero reserved fields.
1197            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1198
1199            // Safety:
1200            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1201            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1202            //   envelope_size bytes, there is always sufficient room.
1203            fidl::encoding::encode_in_envelope_optional::<
1204                bool,
1205                fidl::encoding::DefaultFuchsiaResourceDialect,
1206            >(
1207                self.wait_for_suspending_token
1208                    .as_ref()
1209                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1210                encoder,
1211                offset + cur_offset,
1212                depth,
1213            )?;
1214
1215            _prev_end_offset = cur_offset + envelope_size;
1216            if 3 > max_ordinal {
1217                return Ok(());
1218            }
1219
1220            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1221            // are envelope_size bytes.
1222            let cur_offset: usize = (3 - 1) * envelope_size;
1223
1224            // Zero reserved fields.
1225            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1226
1227            // Safety:
1228            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1229            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1230            //   envelope_size bytes, there is always sufficient room.
1231            fidl::encoding::encode_in_envelope_optional::<
1232                bool,
1233                fidl::encoding::DefaultFuchsiaResourceDialect,
1234            >(
1235                self.use_suspender.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1236                encoder,
1237                offset + cur_offset,
1238                depth,
1239            )?;
1240
1241            _prev_end_offset = cur_offset + envelope_size;
1242
1243            Ok(())
1244        }
1245    }
1246
1247    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for RealmOptions {
1248        #[inline(always)]
1249        fn new_empty() -> Self {
1250            Self::default()
1251        }
1252
1253        unsafe fn decode(
1254            &mut self,
1255            decoder: &mut fidl::encoding::Decoder<
1256                '_,
1257                fidl::encoding::DefaultFuchsiaResourceDialect,
1258            >,
1259            offset: usize,
1260            mut depth: fidl::encoding::Depth,
1261        ) -> fidl::Result<()> {
1262            decoder.debug_check_bounds::<Self>(offset);
1263            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1264                None => return Err(fidl::Error::NotNullable),
1265                Some(len) => len,
1266            };
1267            // Calling decoder.out_of_line_offset(0) is not allowed.
1268            if len == 0 {
1269                return Ok(());
1270            };
1271            depth.increment()?;
1272            let envelope_size = 8;
1273            let bytes_len = len * envelope_size;
1274            let offset = decoder.out_of_line_offset(bytes_len)?;
1275            // Decode the envelope for each type.
1276            let mut _next_ordinal_to_read = 0;
1277            let mut next_offset = offset;
1278            let end_offset = offset + bytes_len;
1279            _next_ordinal_to_read += 1;
1280            if next_offset >= end_offset {
1281                return Ok(());
1282            }
1283
1284            // Decode unknown envelopes for gaps in ordinals.
1285            while _next_ordinal_to_read < 1 {
1286                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1287                _next_ordinal_to_read += 1;
1288                next_offset += envelope_size;
1289            }
1290
1291            let next_out_of_line = decoder.next_out_of_line();
1292            let handles_before = decoder.remaining_handles();
1293            if let Some((inlined, num_bytes, num_handles)) =
1294                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1295            {
1296                let member_inline_size =
1297                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1298                if inlined != (member_inline_size <= 4) {
1299                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1300                }
1301                let inner_offset;
1302                let mut inner_depth = depth.clone();
1303                if inlined {
1304                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1305                    inner_offset = next_offset;
1306                } else {
1307                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1308                    inner_depth.increment()?;
1309                }
1310                let val_ref = self.use_fake_sag.get_or_insert_with(|| {
1311                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
1312                });
1313                fidl::decode!(
1314                    bool,
1315                    fidl::encoding::DefaultFuchsiaResourceDialect,
1316                    val_ref,
1317                    decoder,
1318                    inner_offset,
1319                    inner_depth
1320                )?;
1321                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1322                {
1323                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1324                }
1325                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1326                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1327                }
1328            }
1329
1330            next_offset += envelope_size;
1331            _next_ordinal_to_read += 1;
1332            if next_offset >= end_offset {
1333                return Ok(());
1334            }
1335
1336            // Decode unknown envelopes for gaps in ordinals.
1337            while _next_ordinal_to_read < 2 {
1338                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1339                _next_ordinal_to_read += 1;
1340                next_offset += envelope_size;
1341            }
1342
1343            let next_out_of_line = decoder.next_out_of_line();
1344            let handles_before = decoder.remaining_handles();
1345            if let Some((inlined, num_bytes, num_handles)) =
1346                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1347            {
1348                let member_inline_size =
1349                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1350                if inlined != (member_inline_size <= 4) {
1351                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1352                }
1353                let inner_offset;
1354                let mut inner_depth = depth.clone();
1355                if inlined {
1356                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1357                    inner_offset = next_offset;
1358                } else {
1359                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1360                    inner_depth.increment()?;
1361                }
1362                let val_ref = self.wait_for_suspending_token.get_or_insert_with(|| {
1363                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
1364                });
1365                fidl::decode!(
1366                    bool,
1367                    fidl::encoding::DefaultFuchsiaResourceDialect,
1368                    val_ref,
1369                    decoder,
1370                    inner_offset,
1371                    inner_depth
1372                )?;
1373                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1374                {
1375                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1376                }
1377                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1378                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1379                }
1380            }
1381
1382            next_offset += envelope_size;
1383            _next_ordinal_to_read += 1;
1384            if next_offset >= end_offset {
1385                return Ok(());
1386            }
1387
1388            // Decode unknown envelopes for gaps in ordinals.
1389            while _next_ordinal_to_read < 3 {
1390                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1391                _next_ordinal_to_read += 1;
1392                next_offset += envelope_size;
1393            }
1394
1395            let next_out_of_line = decoder.next_out_of_line();
1396            let handles_before = decoder.remaining_handles();
1397            if let Some((inlined, num_bytes, num_handles)) =
1398                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1399            {
1400                let member_inline_size =
1401                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1402                if inlined != (member_inline_size <= 4) {
1403                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1404                }
1405                let inner_offset;
1406                let mut inner_depth = depth.clone();
1407                if inlined {
1408                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1409                    inner_offset = next_offset;
1410                } else {
1411                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1412                    inner_depth.increment()?;
1413                }
1414                let val_ref = self.use_suspender.get_or_insert_with(|| {
1415                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
1416                });
1417                fidl::decode!(
1418                    bool,
1419                    fidl::encoding::DefaultFuchsiaResourceDialect,
1420                    val_ref,
1421                    decoder,
1422                    inner_offset,
1423                    inner_depth
1424                )?;
1425                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1426                {
1427                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1428                }
1429                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1430                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1431                }
1432            }
1433
1434            next_offset += envelope_size;
1435
1436            // Decode the remaining unknown envelopes.
1437            while next_offset < end_offset {
1438                _next_ordinal_to_read += 1;
1439                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1440                next_offset += envelope_size;
1441            }
1442
1443            Ok(())
1444        }
1445    }
1446}
fidl_test_systemactivitygovernor/fidl_test_systemactivitygovernor.rs

fidl_test_systemactivitygovernor/
fidl_test_systemactivitygovernor.rs
