fidl_fuchsia_ui_gfx/
fidl_fuchsia_ui_gfx.rs

Help
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_fuchsia_ui_gfx_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14/// Instructs the compositor to create the specified `Resource`, and to register
15/// it in a table so that it can be referenced by subsequent commands.
16#[derive(Debug, PartialEq)]
17pub struct CreateResourceCmd {
18    /// An ID that is currently not used within the session.
19    pub id: u32,
20    pub resource: ResourceArgs,
21}
22
23impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateResourceCmd {}
24
25/// Create an external reference to the specified resource, which can then be
26/// imported into another Session by passing a handle to `token`'s peer to
27/// ImportResourceCmd; see that comment for more details.
28///
29/// The importing client is typically in a different process than the exporter.
30/// No specific mechanism is provided for transferring a token from an exporter
31/// to an importer; collaborators may choose any out-of-band API they wish to do
32/// so.
33#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
34pub struct ExportResourceCmdDeprecated {
35    pub id: u32,
36    pub token: fidl::EventPair,
37}
38
39impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
40    for ExportResourceCmdDeprecated
41{
42}
43
44/// Token that uniquely identifies a root point for a subgraph in the global
45/// scene graph. Each `ExportToken` has exactly one corresponding `ImportToken`.
46///
47/// A Scenic client can have its contents referenced from another client by
48/// creating a typed resource using this token.  The other client must also
49/// create a correspondingly typed resource using the corresponding
50/// `ImportToken`.
51///
52/// The exact nature of the inter-client reference depends on the specific
53/// resources created from the tokens.  For example, creating a `View`
54/// resource from this token allows everything attached to the `View` to be
55/// embedded in another clients `ViewHolder`.
56#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
57pub struct ExportToken {
58    pub value: fidl::EventPair,
59}
60
61impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ExportToken {}
62
63/// An image that is backed by a `BufferCollection` registered with `Allocator`.
64#[derive(Debug, PartialEq)]
65pub struct ImageArgs3 {
66    pub width: u32,
67    pub height: u32,
68    /// Image creation requires an allocated `BufferCollection` registered with Allocator.
69    /// `import_token` should be the other end of a BufferCollectionExportToken that is
70    /// successfully registered. All clients of the specified BufferCollection must have set
71    /// their constraints and buffers should be allocated before calling.
72    pub import_token: fidl_fuchsia_ui_composition::BufferCollectionImportToken,
73    /// The index of the VMO from the `BufferCollection` that backs this image.
74    pub buffer_collection_index: u32,
75}
76
77impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ImageArgs3 {}
78
79/// `ImagePipe2` is a `Resource` that can be used as a `Texture` for a `Material`.
80#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
81pub struct ImagePipe2Args {
82    pub image_pipe_request: fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
83}
84
85impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ImagePipe2Args {}
86
87/// Import a resource that was exported via ExportResourceCmd().  `token` is
88/// a handle to the eventpair peer that was used to export the resource, and
89/// `spec` describes the type of the imported resource, and the commands which
90/// can legally be applied to it.  Afterward, `id` can be used to refer to the
91/// resource in an Command, similarly (but not identically: see below) to a
92/// resource that was created in the session.  For example, you can add children
93/// to an imported EntityNode via AddChildCmd.
94///
95/// However, note that the importer does not gain full access to the imported
96/// resource, but rather to an attenuated subset of its capabilities.  For
97/// example, you cannot use a DetachCmd to detach an imported EntityNode from
98/// its parent.
99///
100/// Unlike ExportResourceCmd, there is no configurable timeout.  There is an
101/// expectation that the exported resource will become available in a short
102/// amount of time.  TODO: this needs elaboration... e.g. we might notify via the
103/// SessionListener when we know that the link will never be made (e.g. if the
104/// peer of the import token is destroyed).
105#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
106pub struct ImportResourceCmdDeprecated {
107    pub id: u32,
108    pub token: fidl::EventPair,
109    pub spec: ImportSpec,
110}
111
112impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
113    for ImportResourceCmdDeprecated
114{
115}
116
117/// Token that uniquely identifies an attachment point for a subgraph in the
118/// global scene graph.  Each `ImportToken` has exactly one corresponding
119/// `ExportToken`.
120///
121/// A Scenic client can reference contents from another client by creating a
122/// typed resource using this token.  The other client must also create a
123/// correspondingly typed resource using the corresponding `ExportToken`.
124///
125/// The exact nature of the inter-client reference depends on the specific
126/// resources created from the tokens.  For example, creating a `ViewHolder`
127/// resource from this token allows a client to embed another client's `View`.
128#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
129pub struct ImportToken {
130    pub value: fidl::EventPair,
131}
132
133impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ImportToken {}
134
135/// `Memory` is a `Resource` that wraps a client-provided Zircon vmo to register
136/// it with Scenic.
137#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
138pub struct MemoryArgs {
139    /// The VMO which backs this memory.
140    pub vmo: fidl::Vmo,
141    /// The amount of memory from `vmo` that should be utilized.
142    pub allocation_size: u64,
143    /// The type of memory stored in the VMO, namely whether it's GPU memory or
144    /// host memory.
145    pub memory_type: fidl_fuchsia_images::MemoryType,
146}
147
148impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for MemoryArgs {}
149
150#[derive(Debug, PartialEq)]
151pub struct SnapshotCallbackDeprecatedOnDataRequest {
152    pub data: fidl_fuchsia_mem::Buffer,
153}
154
155impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
156    for SnapshotCallbackDeprecatedOnDataRequest
157{
158}
159
160#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
161pub struct TakeSnapshotCmdDeprecated {
162    pub node_id: u32,
163    pub callback: fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
164}
165
166impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for TakeSnapshotCmdDeprecated {}
167
168/// Represents the root of a subgraph within a larger scene graph.  Nodes can be
169/// attached to the `View` as children, and these Nodes will have the `View`s'
170/// coordinate transform applied to their own, in addition to being clipped to
171/// the `View`s' bounding box.
172/// See `ViewProperties`.
173///
174/// Each `View` is linked to a paired `ViewHolder` via a shared token pair.
175///
176/// Usually the `View` and its associated `ViewHolder` exist in separate
177/// processes.  By combining them, the UI for an entire system can be built
178/// using content contributed from many different processes.
179#[derive(Debug, PartialEq)]
180pub struct ViewArgs {
181    pub token: fidl_fuchsia_ui_views::ViewToken,
182    pub debug_name: Option<String>,
183}
184
185impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs {}
186
187/// Represents the root of a subgraph within a larger scene graph.  Nodes can be
188/// attached to the `View` as children, and these Nodes will have the `View`s'
189/// coordinate transform applied to their own, in addition to being clipped to
190/// the `View`s' bounding box.
191/// See `ViewProperties`.
192///
193/// Each `View` is linked to a paired `ViewHolder` via a shared token pair.
194///
195/// Usually the `View` and its associated `ViewHolder` exist in separate
196/// processes.  By combining them, the UI for an entire system can be built
197/// using content contributed from many different processes.
198///
199/// Clients self-identify their `View` with a `ViewRef`, which is a stable
200/// identifier that may be cloned and passed to other components in a
201/// feed-forward style. It is accompanied by a `ViewRefControl`, which Scenic
202/// uses to signal `View` destruction across the system; the `ViewRefControl`
203/// must be unique - do not clone it.
204#[derive(Debug, PartialEq)]
205pub struct ViewArgs3 {
206    pub token: fidl_fuchsia_ui_views::ViewToken,
207    /// `control_ref.reference` must have default eventpair rights (i.e., with
208    /// signaling), minus ZX_RIGHT_DUPLICATE.
209    pub control_ref: fidl_fuchsia_ui_views::ViewRefControl,
210    /// `view_ref.reference` must have basic rights (i.e., no signaling).
211    pub view_ref: fidl_fuchsia_ui_views::ViewRef,
212    pub debug_name: Option<String>,
213}
214
215impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs3 {}
216
217/// Represents an attachment point for a subgraph within a larger scene graph.
218/// The `ViewHolder` can be attached to a Node as a child, and the contents of
219/// the linked `View` will become a child of the Node as well.
220///
221/// Each `ViewHolder` is linked to a paired `View` via a shared token pair.
222///
223/// Usually the `ViewHolder` and its associated `View` exist in separate
224/// processes.  By combining them, the UI for an entire system can be built
225/// using content contributed from many different processes.
226#[derive(Debug, PartialEq)]
227pub struct ViewHolderArgs {
228    pub token: fidl_fuchsia_ui_views::ViewHolderToken,
229    pub debug_name: Option<String>,
230}
231
232impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ViewHolderArgs {}
233
234/// Commands that are used to modify the state of a `Session`.
235#[derive(Debug, PartialEq)]
236pub enum Command {
237    CreateResource(CreateResourceCmd),
238    ReleaseResource(ReleaseResourceCmd),
239    ExportResource(ExportResourceCmdDeprecated),
240    ImportResource(ImportResourceCmdDeprecated),
241    /// Tagging commands.
242    SetTag(SetTagCmd),
243    /// Grouping commands.
244    Detach(DetachCmd),
245    /// Spatial commands.
246    SetTranslation(SetTranslationCmd),
247    SetScale(SetScaleCmd),
248    SetRotation(SetRotationCmd),
249    SetAnchor(SetAnchorCmd),
250    SetSize(SetSizeCmd),
251    SetOpacity(SetOpacityCmd),
252    SendSizeChangeHintHack(SendSizeChangeHintCmdHack),
253    /// Node-specific commands.
254    AddChild(AddChildCmd),
255    /// re-parenting?
256    AddPart(AddPartCmd),
257    DetachChildren(DetachChildrenCmd),
258    SetShape(SetShapeCmd),
259    SetMaterial(SetMaterialCmd),
260    SetClip(SetClipCmd),
261    SetHitTestBehavior(SetHitTestBehaviorCmd),
262    SetViewProperties(SetViewPropertiesCmd),
263    TakeSnapshotCmd(TakeSnapshotCmdDeprecated),
264    /// Camera and lighting commands.
265    SetCamera(SetCameraCmd),
266    SetCameraTransform(SetCameraTransformCmd),
267    SetCameraProjection(SetCameraProjectionCmd),
268    SetStereoCameraProjection(SetStereoCameraProjectionCmd),
269    SetCameraPoseBuffer(SetCameraPoseBufferCmd),
270    SetLightColor(SetLightColorCmd),
271    SetLightDirection(SetLightDirectionCmd),
272    AddLight(AddLightCmd),
273    DetachLight(DetachLightCmd),
274    DetachLights(DetachLightsCmd),
275    SetTexture(SetTextureCmd),
276    SetColor(SetColorCmd),
277    /// Mesh commands.
278    BindMeshBuffers(BindMeshBuffersCmd),
279    /// Layer and renderer commands.
280    AddLayer(AddLayerCmd),
281    RemoveLayer(RemoveLayerCmd),
282    RemoveAllLayers(RemoveAllLayersCmd),
283    SetLayerStack(SetLayerStackCmd),
284    SetRenderer(SetRendererCmd),
285    SetRendererParam(SetRendererParamCmd),
286    /// Events.
287    SetEventMask(SetEventMaskCmd),
288    /// Diagnostic commands.
289    SetLabel(SetLabelCmd),
290    /// Debugging commands.
291    SetDisableClipping(SetDisableClippingCmd),
292    SetImportFocus(SetImportFocusCmdDeprecated),
293    SetClipPlanes(SetClipPlanesCmd),
294    SetPointLightPosition(SetPointLightPositionCmd),
295    SetPointLightFalloff(SetPointLightFalloffCmd),
296    Scene_AddAmbientLight(SceneAddAmbientLightCmd),
297    Scene_AddDirectionalLight(SceneAddDirectionalLightCmd),
298    Scene_AddPointLight(SceneAddPointLightCmd),
299    SetDisplayColorConversion(SetDisplayColorConversionCmdHack),
300    SetDisplayRotation(SetDisplayRotationCmdHack),
301    SetEnableViewDebugBounds(SetEnableDebugViewBoundsCmd),
302    SetViewHolderBoundsColor(SetViewHolderBoundsColorCmd),
303    SetCameraClipSpaceTransform(SetCameraClipSpaceTransformCmd),
304    SetDisplayMinimumRgb(SetDisplayMinimumRgbCmdHack),
305    SetSemanticVisibility(SetSemanticVisibilityCmd),
306}
307
308impl Command {
309    #[inline]
310    pub fn ordinal(&self) -> u64 {
311        match *self {
312            Self::CreateResource(_) => 1,
313            Self::ReleaseResource(_) => 2,
314            Self::ExportResource(_) => 3,
315            Self::ImportResource(_) => 4,
316            Self::SetTag(_) => 5,
317            Self::Detach(_) => 6,
318            Self::SetTranslation(_) => 7,
319            Self::SetScale(_) => 8,
320            Self::SetRotation(_) => 9,
321            Self::SetAnchor(_) => 10,
322            Self::SetSize(_) => 11,
323            Self::SetOpacity(_) => 12,
324            Self::SendSizeChangeHintHack(_) => 13,
325            Self::AddChild(_) => 14,
326            Self::AddPart(_) => 15,
327            Self::DetachChildren(_) => 16,
328            Self::SetShape(_) => 17,
329            Self::SetMaterial(_) => 18,
330            Self::SetClip(_) => 19,
331            Self::SetHitTestBehavior(_) => 20,
332            Self::SetViewProperties(_) => 21,
333            Self::TakeSnapshotCmd(_) => 22,
334            Self::SetCamera(_) => 23,
335            Self::SetCameraTransform(_) => 24,
336            Self::SetCameraProjection(_) => 25,
337            Self::SetStereoCameraProjection(_) => 26,
338            Self::SetCameraPoseBuffer(_) => 27,
339            Self::SetLightColor(_) => 28,
340            Self::SetLightDirection(_) => 29,
341            Self::AddLight(_) => 30,
342            Self::DetachLight(_) => 31,
343            Self::DetachLights(_) => 32,
344            Self::SetTexture(_) => 33,
345            Self::SetColor(_) => 34,
346            Self::BindMeshBuffers(_) => 35,
347            Self::AddLayer(_) => 36,
348            Self::RemoveLayer(_) => 37,
349            Self::RemoveAllLayers(_) => 38,
350            Self::SetLayerStack(_) => 39,
351            Self::SetRenderer(_) => 40,
352            Self::SetRendererParam(_) => 41,
353            Self::SetEventMask(_) => 42,
354            Self::SetLabel(_) => 43,
355            Self::SetDisableClipping(_) => 44,
356            Self::SetImportFocus(_) => 45,
357            Self::SetClipPlanes(_) => 46,
358            Self::SetPointLightPosition(_) => 47,
359            Self::SetPointLightFalloff(_) => 48,
360            Self::Scene_AddAmbientLight(_) => 49,
361            Self::Scene_AddDirectionalLight(_) => 50,
362            Self::Scene_AddPointLight(_) => 51,
363            Self::SetDisplayColorConversion(_) => 52,
364            Self::SetDisplayRotation(_) => 53,
365            Self::SetEnableViewDebugBounds(_) => 54,
366            Self::SetViewHolderBoundsColor(_) => 55,
367            Self::SetCameraClipSpaceTransform(_) => 56,
368            Self::SetDisplayMinimumRgb(_) => 57,
369            Self::SetSemanticVisibility(_) => 58,
370        }
371    }
372}
373
374impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Command {}
375
376/// These are all of the types of resources that can be created within a
377/// `Session`. Add new fields only to the bottom of the list.
378#[derive(Debug, PartialEq)]
379pub enum ResourceArgs {
380    Memory(MemoryArgs),
381    Image(ImageArgs),
382    Buffer(BufferArgs),
383    View(ViewArgs),
384    ViewHolder(ViewHolderArgs),
385    Rectangle(RectangleArgs),
386    RoundedRectangle(RoundedRectangleArgs),
387    Circle(CircleArgs),
388    Mesh(MeshArgs),
389    ShapeNode(ShapeNodeArgs),
390    ClipNode(ClipNodeArgs),
391    EntityNode(EntityNodeArgs),
392    OpacityNode(OpacityNodeArgsHack),
393    Material(MaterialArgs),
394    Compositor(CompositorArgs),
395    DisplayCompositor(DisplayCompositorArgs),
396    LayerStack(LayerStackArgs),
397    Layer(LayerArgs),
398    Scene(SceneArgs),
399    Camera(CameraArgs),
400    StereoCamera(StereoCameraArgs),
401    Renderer(RendererArgs),
402    AmbientLight(AmbientLightArgs),
403    DirectionalLight(DirectionalLightArgs),
404    Variable(VariableArgs),
405    PointLight(PointLightArgs),
406    View3(ViewArgs3),
407    ImagePipe2(ImagePipe2Args),
408    Image2(ImageArgs2),
409    Image3(ImageArgs3),
410}
411
412impl ResourceArgs {
413    #[inline]
414    pub fn ordinal(&self) -> u64 {
415        match *self {
416            Self::Memory(_) => 1,
417            Self::Image(_) => 2,
418            Self::Buffer(_) => 4,
419            Self::View(_) => 5,
420            Self::ViewHolder(_) => 6,
421            Self::Rectangle(_) => 7,
422            Self::RoundedRectangle(_) => 8,
423            Self::Circle(_) => 9,
424            Self::Mesh(_) => 10,
425            Self::ShapeNode(_) => 11,
426            Self::ClipNode(_) => 12,
427            Self::EntityNode(_) => 13,
428            Self::OpacityNode(_) => 14,
429            Self::Material(_) => 15,
430            Self::Compositor(_) => 16,
431            Self::DisplayCompositor(_) => 17,
432            Self::LayerStack(_) => 19,
433            Self::Layer(_) => 20,
434            Self::Scene(_) => 21,
435            Self::Camera(_) => 22,
436            Self::StereoCamera(_) => 23,
437            Self::Renderer(_) => 24,
438            Self::AmbientLight(_) => 25,
439            Self::DirectionalLight(_) => 26,
440            Self::Variable(_) => 27,
441            Self::PointLight(_) => 28,
442            Self::View3(_) => 31,
443            Self::ImagePipe2(_) => 32,
444            Self::Image2(_) => 33,
445            Self::Image3(_) => 34,
446        }
447    }
448}
449
450impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ResourceArgs {}
451
452#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
453pub struct SnapshotCallbackDeprecatedMarker;
454
455impl fidl::endpoints::ProtocolMarker for SnapshotCallbackDeprecatedMarker {
456    type Proxy = SnapshotCallbackDeprecatedProxy;
457    type RequestStream = SnapshotCallbackDeprecatedRequestStream;
458    #[cfg(target_os = "fuchsia")]
459    type SynchronousProxy = SnapshotCallbackDeprecatedSynchronousProxy;
460
461    const DEBUG_NAME: &'static str = "(anonymous) SnapshotCallbackDeprecated";
462}
463
464pub trait SnapshotCallbackDeprecatedProxyInterface: Send + Sync {
465    fn r#on_data(&self, data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error>;
466}
467#[derive(Debug)]
468#[cfg(target_os = "fuchsia")]
469pub struct SnapshotCallbackDeprecatedSynchronousProxy {
470    client: fidl::client::sync::Client,
471}
472
473#[cfg(target_os = "fuchsia")]
474impl fidl::endpoints::SynchronousProxy for SnapshotCallbackDeprecatedSynchronousProxy {
475    type Proxy = SnapshotCallbackDeprecatedProxy;
476    type Protocol = SnapshotCallbackDeprecatedMarker;
477
478    fn from_channel(inner: fidl::Channel) -> Self {
479        Self::new(inner)
480    }
481
482    fn into_channel(self) -> fidl::Channel {
483        self.client.into_channel()
484    }
485
486    fn as_channel(&self) -> &fidl::Channel {
487        self.client.as_channel()
488    }
489}
490
491#[cfg(target_os = "fuchsia")]
492impl SnapshotCallbackDeprecatedSynchronousProxy {
493    pub fn new(channel: fidl::Channel) -> Self {
494        let protocol_name =
495            <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
496        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
497    }
498
499    pub fn into_channel(self) -> fidl::Channel {
500        self.client.into_channel()
501    }
502
503    /// Waits until an event arrives and returns it. It is safe for other
504    /// threads to make concurrent requests while waiting for an event.
505    pub fn wait_for_event(
506        &self,
507        deadline: zx::MonotonicInstant,
508    ) -> Result<SnapshotCallbackDeprecatedEvent, fidl::Error> {
509        SnapshotCallbackDeprecatedEvent::decode(self.client.wait_for_event(deadline)?)
510    }
511
512    pub fn r#on_data(&self, mut data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
513        self.client.send::<SnapshotCallbackDeprecatedOnDataRequest>(
514            (&mut data,),
515            0x11d1a93b419b7d9f,
516            fidl::encoding::DynamicFlags::empty(),
517        )
518    }
519}
520
521#[cfg(target_os = "fuchsia")]
522impl From<SnapshotCallbackDeprecatedSynchronousProxy> for zx::Handle {
523    fn from(value: SnapshotCallbackDeprecatedSynchronousProxy) -> Self {
524        value.into_channel().into()
525    }
526}
527
528#[cfg(target_os = "fuchsia")]
529impl From<fidl::Channel> for SnapshotCallbackDeprecatedSynchronousProxy {
530    fn from(value: fidl::Channel) -> Self {
531        Self::new(value)
532    }
533}
534
535#[derive(Debug, Clone)]
536pub struct SnapshotCallbackDeprecatedProxy {
537    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
538}
539
540impl fidl::endpoints::Proxy for SnapshotCallbackDeprecatedProxy {
541    type Protocol = SnapshotCallbackDeprecatedMarker;
542
543    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
544        Self::new(inner)
545    }
546
547    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
548        self.client.into_channel().map_err(|client| Self { client })
549    }
550
551    fn as_channel(&self) -> &::fidl::AsyncChannel {
552        self.client.as_channel()
553    }
554}
555
556impl SnapshotCallbackDeprecatedProxy {
557    /// Create a new Proxy for fuchsia.ui.gfx/SnapshotCallbackDEPRECATED.
558    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
559        let protocol_name =
560            <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
561        Self { client: fidl::client::Client::new(channel, protocol_name) }
562    }
563
564    /// Get a Stream of events from the remote end of the protocol.
565    ///
566    /// # Panics
567    ///
568    /// Panics if the event stream was already taken.
569    pub fn take_event_stream(&self) -> SnapshotCallbackDeprecatedEventStream {
570        SnapshotCallbackDeprecatedEventStream { event_receiver: self.client.take_event_receiver() }
571    }
572
573    pub fn r#on_data(&self, mut data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
574        SnapshotCallbackDeprecatedProxyInterface::r#on_data(self, data)
575    }
576}
577
578impl SnapshotCallbackDeprecatedProxyInterface for SnapshotCallbackDeprecatedProxy {
579    fn r#on_data(&self, mut data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
580        self.client.send::<SnapshotCallbackDeprecatedOnDataRequest>(
581            (&mut data,),
582            0x11d1a93b419b7d9f,
583            fidl::encoding::DynamicFlags::empty(),
584        )
585    }
586}
587
588pub struct SnapshotCallbackDeprecatedEventStream {
589    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
590}
591
592impl std::marker::Unpin for SnapshotCallbackDeprecatedEventStream {}
593
594impl futures::stream::FusedStream for SnapshotCallbackDeprecatedEventStream {
595    fn is_terminated(&self) -> bool {
596        self.event_receiver.is_terminated()
597    }
598}
599
600impl futures::Stream for SnapshotCallbackDeprecatedEventStream {
601    type Item = Result<SnapshotCallbackDeprecatedEvent, fidl::Error>;
602
603    fn poll_next(
604        mut self: std::pin::Pin<&mut Self>,
605        cx: &mut std::task::Context<'_>,
606    ) -> std::task::Poll<Option<Self::Item>> {
607        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
608            &mut self.event_receiver,
609            cx
610        )?) {
611            Some(buf) => std::task::Poll::Ready(Some(SnapshotCallbackDeprecatedEvent::decode(buf))),
612            None => std::task::Poll::Ready(None),
613        }
614    }
615}
616
617#[derive(Debug)]
618pub enum SnapshotCallbackDeprecatedEvent {}
619
620impl SnapshotCallbackDeprecatedEvent {
621    /// Decodes a message buffer as a [`SnapshotCallbackDeprecatedEvent`].
622    fn decode(
623        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
624    ) -> Result<SnapshotCallbackDeprecatedEvent, fidl::Error> {
625        let (bytes, _handles) = buf.split_mut();
626        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
627        debug_assert_eq!(tx_header.tx_id, 0);
628        match tx_header.ordinal {
629            _ => Err(fidl::Error::UnknownOrdinal {
630                ordinal: tx_header.ordinal,
631                protocol_name: <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
632            })
633        }
634    }
635}
636
637/// A Stream of incoming requests for fuchsia.ui.gfx/SnapshotCallbackDEPRECATED.
638pub struct SnapshotCallbackDeprecatedRequestStream {
639    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
640    is_terminated: bool,
641}
642
643impl std::marker::Unpin for SnapshotCallbackDeprecatedRequestStream {}
644
645impl futures::stream::FusedStream for SnapshotCallbackDeprecatedRequestStream {
646    fn is_terminated(&self) -> bool {
647        self.is_terminated
648    }
649}
650
651impl fidl::endpoints::RequestStream for SnapshotCallbackDeprecatedRequestStream {
652    type Protocol = SnapshotCallbackDeprecatedMarker;
653    type ControlHandle = SnapshotCallbackDeprecatedControlHandle;
654
655    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
656        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
657    }
658
659    fn control_handle(&self) -> Self::ControlHandle {
660        SnapshotCallbackDeprecatedControlHandle { inner: self.inner.clone() }
661    }
662
663    fn into_inner(
664        self,
665    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
666    {
667        (self.inner, self.is_terminated)
668    }
669
670    fn from_inner(
671        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
672        is_terminated: bool,
673    ) -> Self {
674        Self { inner, is_terminated }
675    }
676}
677
678impl futures::Stream for SnapshotCallbackDeprecatedRequestStream {
679    type Item = Result<SnapshotCallbackDeprecatedRequest, fidl::Error>;
680
681    fn poll_next(
682        mut self: std::pin::Pin<&mut Self>,
683        cx: &mut std::task::Context<'_>,
684    ) -> std::task::Poll<Option<Self::Item>> {
685        let this = &mut *self;
686        if this.inner.check_shutdown(cx) {
687            this.is_terminated = true;
688            return std::task::Poll::Ready(None);
689        }
690        if this.is_terminated {
691            panic!("polled SnapshotCallbackDeprecatedRequestStream after completion");
692        }
693        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
694            |bytes, handles| {
695                match this.inner.channel().read_etc(cx, bytes, handles) {
696                    std::task::Poll::Ready(Ok(())) => {}
697                    std::task::Poll::Pending => return std::task::Poll::Pending,
698                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
699                        this.is_terminated = true;
700                        return std::task::Poll::Ready(None);
701                    }
702                    std::task::Poll::Ready(Err(e)) => {
703                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
704                            e.into(),
705                        ))))
706                    }
707                }
708
709                // A message has been received from the channel
710                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
711
712                std::task::Poll::Ready(Some(match header.ordinal {
713                0x11d1a93b419b7d9f => {
714                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
715                    let mut req = fidl::new_empty!(SnapshotCallbackDeprecatedOnDataRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
716                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SnapshotCallbackDeprecatedOnDataRequest>(&header, _body_bytes, handles, &mut req)?;
717                    let control_handle = SnapshotCallbackDeprecatedControlHandle {
718                        inner: this.inner.clone(),
719                    };
720                    Ok(SnapshotCallbackDeprecatedRequest::OnData {data: req.data,
721
722                        control_handle,
723                    })
724                }
725                _ => Err(fidl::Error::UnknownOrdinal {
726                    ordinal: header.ordinal,
727                    protocol_name: <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
728                }),
729            }))
730            },
731        )
732    }
733}
734
735#[derive(Debug)]
736pub enum SnapshotCallbackDeprecatedRequest {
737    OnData {
738        data: fidl_fuchsia_mem::Buffer,
739        control_handle: SnapshotCallbackDeprecatedControlHandle,
740    },
741}
742
743impl SnapshotCallbackDeprecatedRequest {
744    #[allow(irrefutable_let_patterns)]
745    pub fn into_on_data(
746        self,
747    ) -> Option<(fidl_fuchsia_mem::Buffer, SnapshotCallbackDeprecatedControlHandle)> {
748        if let SnapshotCallbackDeprecatedRequest::OnData { data, control_handle } = self {
749            Some((data, control_handle))
750        } else {
751            None
752        }
753    }
754
755    /// Name of the method defined in FIDL
756    pub fn method_name(&self) -> &'static str {
757        match *self {
758            SnapshotCallbackDeprecatedRequest::OnData { .. } => "on_data",
759        }
760    }
761}
762
763#[derive(Debug, Clone)]
764pub struct SnapshotCallbackDeprecatedControlHandle {
765    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
766}
767
768impl fidl::endpoints::ControlHandle for SnapshotCallbackDeprecatedControlHandle {
769    fn shutdown(&self) {
770        self.inner.shutdown()
771    }
772    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
773        self.inner.shutdown_with_epitaph(status)
774    }
775
776    fn is_closed(&self) -> bool {
777        self.inner.channel().is_closed()
778    }
779    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
780        self.inner.channel().on_closed()
781    }
782
783    #[cfg(target_os = "fuchsia")]
784    fn signal_peer(
785        &self,
786        clear_mask: zx::Signals,
787        set_mask: zx::Signals,
788    ) -> Result<(), zx_status::Status> {
789        use fidl::Peered;
790        self.inner.channel().signal_peer(clear_mask, set_mask)
791    }
792}
793
794impl SnapshotCallbackDeprecatedControlHandle {}
795
796mod internal {
797    use super::*;
798
799    impl fidl::encoding::ResourceTypeMarker for CreateResourceCmd {
800        type Borrowed<'a> = &'a mut Self;
801        fn take_or_borrow<'a>(
802            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
803        ) -> Self::Borrowed<'a> {
804            value
805        }
806    }
807
808    unsafe impl fidl::encoding::TypeMarker for CreateResourceCmd {
809        type Owned = Self;
810
811        #[inline(always)]
812        fn inline_align(_context: fidl::encoding::Context) -> usize {
813            8
814        }
815
816        #[inline(always)]
817        fn inline_size(_context: fidl::encoding::Context) -> usize {
818            24
819        }
820    }
821
822    unsafe impl
823        fidl::encoding::Encode<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>
824        for &mut CreateResourceCmd
825    {
826        #[inline]
827        unsafe fn encode(
828            self,
829            encoder: &mut fidl::encoding::Encoder<
830                '_,
831                fidl::encoding::DefaultFuchsiaResourceDialect,
832            >,
833            offset: usize,
834            _depth: fidl::encoding::Depth,
835        ) -> fidl::Result<()> {
836            encoder.debug_check_bounds::<CreateResourceCmd>(offset);
837            // Delegate to tuple encoding.
838            fidl::encoding::Encode::<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
839                (
840                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
841                    <ResourceArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.resource),
842                ),
843                encoder, offset, _depth
844            )
845        }
846    }
847    unsafe impl<
848            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
849            T1: fidl::encoding::Encode<ResourceArgs, fidl::encoding::DefaultFuchsiaResourceDialect>,
850        >
851        fidl::encoding::Encode<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>
852        for (T0, T1)
853    {
854        #[inline]
855        unsafe fn encode(
856            self,
857            encoder: &mut fidl::encoding::Encoder<
858                '_,
859                fidl::encoding::DefaultFuchsiaResourceDialect,
860            >,
861            offset: usize,
862            depth: fidl::encoding::Depth,
863        ) -> fidl::Result<()> {
864            encoder.debug_check_bounds::<CreateResourceCmd>(offset);
865            // Zero out padding regions. There's no need to apply masks
866            // because the unmasked parts will be overwritten by fields.
867            unsafe {
868                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
869                (ptr as *mut u64).write_unaligned(0);
870            }
871            // Write the fields.
872            self.0.encode(encoder, offset + 0, depth)?;
873            self.1.encode(encoder, offset + 8, depth)?;
874            Ok(())
875        }
876    }
877
878    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
879        for CreateResourceCmd
880    {
881        #[inline(always)]
882        fn new_empty() -> Self {
883            Self {
884                id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
885                resource: fidl::new_empty!(
886                    ResourceArgs,
887                    fidl::encoding::DefaultFuchsiaResourceDialect
888                ),
889            }
890        }
891
892        #[inline]
893        unsafe fn decode(
894            &mut self,
895            decoder: &mut fidl::encoding::Decoder<
896                '_,
897                fidl::encoding::DefaultFuchsiaResourceDialect,
898            >,
899            offset: usize,
900            _depth: fidl::encoding::Depth,
901        ) -> fidl::Result<()> {
902            decoder.debug_check_bounds::<Self>(offset);
903            // Verify that padding bytes are zero.
904            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
905            let padval = unsafe { (ptr as *const u64).read_unaligned() };
906            let mask = 0xffffffff00000000u64;
907            let maskedval = padval & mask;
908            if maskedval != 0 {
909                return Err(fidl::Error::NonZeroPadding {
910                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
911                });
912            }
913            fidl::decode!(
914                u32,
915                fidl::encoding::DefaultFuchsiaResourceDialect,
916                &mut self.id,
917                decoder,
918                offset + 0,
919                _depth
920            )?;
921            fidl::decode!(
922                ResourceArgs,
923                fidl::encoding::DefaultFuchsiaResourceDialect,
924                &mut self.resource,
925                decoder,
926                offset + 8,
927                _depth
928            )?;
929            Ok(())
930        }
931    }
932
933    impl fidl::encoding::ResourceTypeMarker for ExportResourceCmdDeprecated {
934        type Borrowed<'a> = &'a mut Self;
935        fn take_or_borrow<'a>(
936            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
937        ) -> Self::Borrowed<'a> {
938            value
939        }
940    }
941
942    unsafe impl fidl::encoding::TypeMarker for ExportResourceCmdDeprecated {
943        type Owned = Self;
944
945        #[inline(always)]
946        fn inline_align(_context: fidl::encoding::Context) -> usize {
947            4
948        }
949
950        #[inline(always)]
951        fn inline_size(_context: fidl::encoding::Context) -> usize {
952            8
953        }
954    }
955
956    unsafe impl
957        fidl::encoding::Encode<
958            ExportResourceCmdDeprecated,
959            fidl::encoding::DefaultFuchsiaResourceDialect,
960        > for &mut ExportResourceCmdDeprecated
961    {
962        #[inline]
963        unsafe fn encode(
964            self,
965            encoder: &mut fidl::encoding::Encoder<
966                '_,
967                fidl::encoding::DefaultFuchsiaResourceDialect,
968            >,
969            offset: usize,
970            _depth: fidl::encoding::Depth,
971        ) -> fidl::Result<()> {
972            encoder.debug_check_bounds::<ExportResourceCmdDeprecated>(offset);
973            // Delegate to tuple encoding.
974            fidl::encoding::Encode::<
975                ExportResourceCmdDeprecated,
976                fidl::encoding::DefaultFuchsiaResourceDialect,
977            >::encode(
978                (
979                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
980                    <fidl::encoding::HandleType<
981                        fidl::EventPair,
982                        { fidl::ObjectType::EVENTPAIR.into_raw() },
983                        2147483648,
984                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
985                        &mut self.token
986                    ),
987                ),
988                encoder,
989                offset,
990                _depth,
991            )
992        }
993    }
994    unsafe impl<
995            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
996            T1: fidl::encoding::Encode<
997                fidl::encoding::HandleType<
998                    fidl::EventPair,
999                    { fidl::ObjectType::EVENTPAIR.into_raw() },
1000                    2147483648,
1001                >,
1002                fidl::encoding::DefaultFuchsiaResourceDialect,
1003            >,
1004        >
1005        fidl::encoding::Encode<
1006            ExportResourceCmdDeprecated,
1007            fidl::encoding::DefaultFuchsiaResourceDialect,
1008        > for (T0, T1)
1009    {
1010        #[inline]
1011        unsafe fn encode(
1012            self,
1013            encoder: &mut fidl::encoding::Encoder<
1014                '_,
1015                fidl::encoding::DefaultFuchsiaResourceDialect,
1016            >,
1017            offset: usize,
1018            depth: fidl::encoding::Depth,
1019        ) -> fidl::Result<()> {
1020            encoder.debug_check_bounds::<ExportResourceCmdDeprecated>(offset);
1021            // Zero out padding regions. There's no need to apply masks
1022            // because the unmasked parts will be overwritten by fields.
1023            // Write the fields.
1024            self.0.encode(encoder, offset + 0, depth)?;
1025            self.1.encode(encoder, offset + 4, depth)?;
1026            Ok(())
1027        }
1028    }
1029
1030    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1031        for ExportResourceCmdDeprecated
1032    {
1033        #[inline(always)]
1034        fn new_empty() -> Self {
1035            Self {
1036                id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
1037                token: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1038            }
1039        }
1040
1041        #[inline]
1042        unsafe fn decode(
1043            &mut self,
1044            decoder: &mut fidl::encoding::Decoder<
1045                '_,
1046                fidl::encoding::DefaultFuchsiaResourceDialect,
1047            >,
1048            offset: usize,
1049            _depth: fidl::encoding::Depth,
1050        ) -> fidl::Result<()> {
1051            decoder.debug_check_bounds::<Self>(offset);
1052            // Verify that padding bytes are zero.
1053            fidl::decode!(
1054                u32,
1055                fidl::encoding::DefaultFuchsiaResourceDialect,
1056                &mut self.id,
1057                decoder,
1058                offset + 0,
1059                _depth
1060            )?;
1061            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.token, decoder, offset + 4, _depth)?;
1062            Ok(())
1063        }
1064    }
1065
1066    impl fidl::encoding::ResourceTypeMarker for ExportToken {
1067        type Borrowed<'a> = &'a mut Self;
1068        fn take_or_borrow<'a>(
1069            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1070        ) -> Self::Borrowed<'a> {
1071            value
1072        }
1073    }
1074
1075    unsafe impl fidl::encoding::TypeMarker for ExportToken {
1076        type Owned = Self;
1077
1078        #[inline(always)]
1079        fn inline_align(_context: fidl::encoding::Context) -> usize {
1080            4
1081        }
1082
1083        #[inline(always)]
1084        fn inline_size(_context: fidl::encoding::Context) -> usize {
1085            4
1086        }
1087    }
1088
1089    unsafe impl fidl::encoding::Encode<ExportToken, fidl::encoding::DefaultFuchsiaResourceDialect>
1090        for &mut ExportToken
1091    {
1092        #[inline]
1093        unsafe fn encode(
1094            self,
1095            encoder: &mut fidl::encoding::Encoder<
1096                '_,
1097                fidl::encoding::DefaultFuchsiaResourceDialect,
1098            >,
1099            offset: usize,
1100            _depth: fidl::encoding::Depth,
1101        ) -> fidl::Result<()> {
1102            encoder.debug_check_bounds::<ExportToken>(offset);
1103            // Delegate to tuple encoding.
1104            fidl::encoding::Encode::<ExportToken, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1105                (
1106                    <fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
1107                ),
1108                encoder, offset, _depth
1109            )
1110        }
1111    }
1112    unsafe impl<
1113            T0: fidl::encoding::Encode<
1114                fidl::encoding::HandleType<
1115                    fidl::EventPair,
1116                    { fidl::ObjectType::EVENTPAIR.into_raw() },
1117                    2147483648,
1118                >,
1119                fidl::encoding::DefaultFuchsiaResourceDialect,
1120            >,
1121        > fidl::encoding::Encode<ExportToken, fidl::encoding::DefaultFuchsiaResourceDialect>
1122        for (T0,)
1123    {
1124        #[inline]
1125        unsafe fn encode(
1126            self,
1127            encoder: &mut fidl::encoding::Encoder<
1128                '_,
1129                fidl::encoding::DefaultFuchsiaResourceDialect,
1130            >,
1131            offset: usize,
1132            depth: fidl::encoding::Depth,
1133        ) -> fidl::Result<()> {
1134            encoder.debug_check_bounds::<ExportToken>(offset);
1135            // Zero out padding regions. There's no need to apply masks
1136            // because the unmasked parts will be overwritten by fields.
1137            // Write the fields.
1138            self.0.encode(encoder, offset + 0, depth)?;
1139            Ok(())
1140        }
1141    }
1142
1143    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ExportToken {
1144        #[inline(always)]
1145        fn new_empty() -> Self {
1146            Self {
1147                value: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1148            }
1149        }
1150
1151        #[inline]
1152        unsafe fn decode(
1153            &mut self,
1154            decoder: &mut fidl::encoding::Decoder<
1155                '_,
1156                fidl::encoding::DefaultFuchsiaResourceDialect,
1157            >,
1158            offset: usize,
1159            _depth: fidl::encoding::Depth,
1160        ) -> fidl::Result<()> {
1161            decoder.debug_check_bounds::<Self>(offset);
1162            // Verify that padding bytes are zero.
1163            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.value, decoder, offset + 0, _depth)?;
1164            Ok(())
1165        }
1166    }
1167
1168    impl fidl::encoding::ResourceTypeMarker for ImageArgs3 {
1169        type Borrowed<'a> = &'a mut Self;
1170        fn take_or_borrow<'a>(
1171            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1172        ) -> Self::Borrowed<'a> {
1173            value
1174        }
1175    }
1176
1177    unsafe impl fidl::encoding::TypeMarker for ImageArgs3 {
1178        type Owned = Self;
1179
1180        #[inline(always)]
1181        fn inline_align(_context: fidl::encoding::Context) -> usize {
1182            4
1183        }
1184
1185        #[inline(always)]
1186        fn inline_size(_context: fidl::encoding::Context) -> usize {
1187            16
1188        }
1189    }
1190
1191    unsafe impl fidl::encoding::Encode<ImageArgs3, fidl::encoding::DefaultFuchsiaResourceDialect>
1192        for &mut ImageArgs3
1193    {
1194        #[inline]
1195        unsafe fn encode(
1196            self,
1197            encoder: &mut fidl::encoding::Encoder<
1198                '_,
1199                fidl::encoding::DefaultFuchsiaResourceDialect,
1200            >,
1201            offset: usize,
1202            _depth: fidl::encoding::Depth,
1203        ) -> fidl::Result<()> {
1204            encoder.debug_check_bounds::<ImageArgs3>(offset);
1205            // Delegate to tuple encoding.
1206            fidl::encoding::Encode::<ImageArgs3, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1207                (
1208                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.width),
1209                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.height),
1210                    <fidl_fuchsia_ui_composition::BufferCollectionImportToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.import_token),
1211                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer_collection_index),
1212                ),
1213                encoder, offset, _depth
1214            )
1215        }
1216    }
1217    unsafe impl<
1218            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
1219            T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
1220            T2: fidl::encoding::Encode<
1221                fidl_fuchsia_ui_composition::BufferCollectionImportToken,
1222                fidl::encoding::DefaultFuchsiaResourceDialect,
1223            >,
1224            T3: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
1225        > fidl::encoding::Encode<ImageArgs3, fidl::encoding::DefaultFuchsiaResourceDialect>
1226        for (T0, T1, T2, T3)
1227    {
1228        #[inline]
1229        unsafe fn encode(
1230            self,
1231            encoder: &mut fidl::encoding::Encoder<
1232                '_,
1233                fidl::encoding::DefaultFuchsiaResourceDialect,
1234            >,
1235            offset: usize,
1236            depth: fidl::encoding::Depth,
1237        ) -> fidl::Result<()> {
1238            encoder.debug_check_bounds::<ImageArgs3>(offset);
1239            // Zero out padding regions. There's no need to apply masks
1240            // because the unmasked parts will be overwritten by fields.
1241            // Write the fields.
1242            self.0.encode(encoder, offset + 0, depth)?;
1243            self.1.encode(encoder, offset + 4, depth)?;
1244            self.2.encode(encoder, offset + 8, depth)?;
1245            self.3.encode(encoder, offset + 12, depth)?;
1246            Ok(())
1247        }
1248    }
1249
1250    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ImageArgs3 {
1251        #[inline(always)]
1252        fn new_empty() -> Self {
1253            Self {
1254                width: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
1255                height: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
1256                import_token: fidl::new_empty!(
1257                    fidl_fuchsia_ui_composition::BufferCollectionImportToken,
1258                    fidl::encoding::DefaultFuchsiaResourceDialect
1259                ),
1260                buffer_collection_index: fidl::new_empty!(
1261                    u32,
1262                    fidl::encoding::DefaultFuchsiaResourceDialect
1263                ),
1264            }
1265        }
1266
1267        #[inline]
1268        unsafe fn decode(
1269            &mut self,
1270            decoder: &mut fidl::encoding::Decoder<
1271                '_,
1272                fidl::encoding::DefaultFuchsiaResourceDialect,
1273            >,
1274            offset: usize,
1275            _depth: fidl::encoding::Depth,
1276        ) -> fidl::Result<()> {
1277            decoder.debug_check_bounds::<Self>(offset);
1278            // Verify that padding bytes are zero.
1279            fidl::decode!(
1280                u32,
1281                fidl::encoding::DefaultFuchsiaResourceDialect,
1282                &mut self.width,
1283                decoder,
1284                offset + 0,
1285                _depth
1286            )?;
1287            fidl::decode!(
1288                u32,
1289                fidl::encoding::DefaultFuchsiaResourceDialect,
1290                &mut self.height,
1291                decoder,
1292                offset + 4,
1293                _depth
1294            )?;
1295            fidl::decode!(
1296                fidl_fuchsia_ui_composition::BufferCollectionImportToken,
1297                fidl::encoding::DefaultFuchsiaResourceDialect,
1298                &mut self.import_token,
1299                decoder,
1300                offset + 8,
1301                _depth
1302            )?;
1303            fidl::decode!(
1304                u32,
1305                fidl::encoding::DefaultFuchsiaResourceDialect,
1306                &mut self.buffer_collection_index,
1307                decoder,
1308                offset + 12,
1309                _depth
1310            )?;
1311            Ok(())
1312        }
1313    }
1314
1315    impl fidl::encoding::ResourceTypeMarker for ImagePipe2Args {
1316        type Borrowed<'a> = &'a mut Self;
1317        fn take_or_borrow<'a>(
1318            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1319        ) -> Self::Borrowed<'a> {
1320            value
1321        }
1322    }
1323
1324    unsafe impl fidl::encoding::TypeMarker for ImagePipe2Args {
1325        type Owned = Self;
1326
1327        #[inline(always)]
1328        fn inline_align(_context: fidl::encoding::Context) -> usize {
1329            4
1330        }
1331
1332        #[inline(always)]
1333        fn inline_size(_context: fidl::encoding::Context) -> usize {
1334            4
1335        }
1336    }
1337
1338    unsafe impl
1339        fidl::encoding::Encode<ImagePipe2Args, fidl::encoding::DefaultFuchsiaResourceDialect>
1340        for &mut ImagePipe2Args
1341    {
1342        #[inline]
1343        unsafe fn encode(
1344            self,
1345            encoder: &mut fidl::encoding::Encoder<
1346                '_,
1347                fidl::encoding::DefaultFuchsiaResourceDialect,
1348            >,
1349            offset: usize,
1350            _depth: fidl::encoding::Depth,
1351        ) -> fidl::Result<()> {
1352            encoder.debug_check_bounds::<ImagePipe2Args>(offset);
1353            // Delegate to tuple encoding.
1354            fidl::encoding::Encode::<ImagePipe2Args, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1355                (
1356                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.image_pipe_request),
1357                ),
1358                encoder, offset, _depth
1359            )
1360        }
1361    }
1362    unsafe impl<
1363            T0: fidl::encoding::Encode<
1364                fidl::encoding::Endpoint<
1365                    fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
1366                >,
1367                fidl::encoding::DefaultFuchsiaResourceDialect,
1368            >,
1369        > fidl::encoding::Encode<ImagePipe2Args, fidl::encoding::DefaultFuchsiaResourceDialect>
1370        for (T0,)
1371    {
1372        #[inline]
1373        unsafe fn encode(
1374            self,
1375            encoder: &mut fidl::encoding::Encoder<
1376                '_,
1377                fidl::encoding::DefaultFuchsiaResourceDialect,
1378            >,
1379            offset: usize,
1380            depth: fidl::encoding::Depth,
1381        ) -> fidl::Result<()> {
1382            encoder.debug_check_bounds::<ImagePipe2Args>(offset);
1383            // Zero out padding regions. There's no need to apply masks
1384            // because the unmasked parts will be overwritten by fields.
1385            // Write the fields.
1386            self.0.encode(encoder, offset + 0, depth)?;
1387            Ok(())
1388        }
1389    }
1390
1391    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1392        for ImagePipe2Args
1393    {
1394        #[inline(always)]
1395        fn new_empty() -> Self {
1396            Self {
1397                image_pipe_request: fidl::new_empty!(
1398                    fidl::encoding::Endpoint<
1399                        fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
1400                    >,
1401                    fidl::encoding::DefaultFuchsiaResourceDialect
1402                ),
1403            }
1404        }
1405
1406        #[inline]
1407        unsafe fn decode(
1408            &mut self,
1409            decoder: &mut fidl::encoding::Decoder<
1410                '_,
1411                fidl::encoding::DefaultFuchsiaResourceDialect,
1412            >,
1413            offset: usize,
1414            _depth: fidl::encoding::Depth,
1415        ) -> fidl::Result<()> {
1416            decoder.debug_check_bounds::<Self>(offset);
1417            // Verify that padding bytes are zero.
1418            fidl::decode!(
1419                fidl::encoding::Endpoint<
1420                    fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
1421                >,
1422                fidl::encoding::DefaultFuchsiaResourceDialect,
1423                &mut self.image_pipe_request,
1424                decoder,
1425                offset + 0,
1426                _depth
1427            )?;
1428            Ok(())
1429        }
1430    }
1431
1432    impl fidl::encoding::ResourceTypeMarker for ImportResourceCmdDeprecated {
1433        type Borrowed<'a> = &'a mut Self;
1434        fn take_or_borrow<'a>(
1435            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1436        ) -> Self::Borrowed<'a> {
1437            value
1438        }
1439    }
1440
1441    unsafe impl fidl::encoding::TypeMarker for ImportResourceCmdDeprecated {
1442        type Owned = Self;
1443
1444        #[inline(always)]
1445        fn inline_align(_context: fidl::encoding::Context) -> usize {
1446            4
1447        }
1448
1449        #[inline(always)]
1450        fn inline_size(_context: fidl::encoding::Context) -> usize {
1451            12
1452        }
1453    }
1454
1455    unsafe impl
1456        fidl::encoding::Encode<
1457            ImportResourceCmdDeprecated,
1458            fidl::encoding::DefaultFuchsiaResourceDialect,
1459        > for &mut ImportResourceCmdDeprecated
1460    {
1461        #[inline]
1462        unsafe fn encode(
1463            self,
1464            encoder: &mut fidl::encoding::Encoder<
1465                '_,
1466                fidl::encoding::DefaultFuchsiaResourceDialect,
1467            >,
1468            offset: usize,
1469            _depth: fidl::encoding::Depth,
1470        ) -> fidl::Result<()> {
1471            encoder.debug_check_bounds::<ImportResourceCmdDeprecated>(offset);
1472            // Delegate to tuple encoding.
1473            fidl::encoding::Encode::<
1474                ImportResourceCmdDeprecated,
1475                fidl::encoding::DefaultFuchsiaResourceDialect,
1476            >::encode(
1477                (
1478                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
1479                    <fidl::encoding::HandleType<
1480                        fidl::EventPair,
1481                        { fidl::ObjectType::EVENTPAIR.into_raw() },
1482                        2147483648,
1483                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1484                        &mut self.token
1485                    ),
1486                    <ImportSpec as fidl::encoding::ValueTypeMarker>::borrow(&self.spec),
1487                ),
1488                encoder,
1489                offset,
1490                _depth,
1491            )
1492        }
1493    }
1494    unsafe impl<
1495            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
1496            T1: fidl::encoding::Encode<
1497                fidl::encoding::HandleType<
1498                    fidl::EventPair,
1499                    { fidl::ObjectType::EVENTPAIR.into_raw() },
1500                    2147483648,
1501                >,
1502                fidl::encoding::DefaultFuchsiaResourceDialect,
1503            >,
1504            T2: fidl::encoding::Encode<ImportSpec, fidl::encoding::DefaultFuchsiaResourceDialect>,
1505        >
1506        fidl::encoding::Encode<
1507            ImportResourceCmdDeprecated,
1508            fidl::encoding::DefaultFuchsiaResourceDialect,
1509        > for (T0, T1, T2)
1510    {
1511        #[inline]
1512        unsafe fn encode(
1513            self,
1514            encoder: &mut fidl::encoding::Encoder<
1515                '_,
1516                fidl::encoding::DefaultFuchsiaResourceDialect,
1517            >,
1518            offset: usize,
1519            depth: fidl::encoding::Depth,
1520        ) -> fidl::Result<()> {
1521            encoder.debug_check_bounds::<ImportResourceCmdDeprecated>(offset);
1522            // Zero out padding regions. There's no need to apply masks
1523            // because the unmasked parts will be overwritten by fields.
1524            // Write the fields.
1525            self.0.encode(encoder, offset + 0, depth)?;
1526            self.1.encode(encoder, offset + 4, depth)?;
1527            self.2.encode(encoder, offset + 8, depth)?;
1528            Ok(())
1529        }
1530    }
1531
1532    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1533        for ImportResourceCmdDeprecated
1534    {
1535        #[inline(always)]
1536        fn new_empty() -> Self {
1537            Self {
1538                id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
1539                token: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1540                spec: fidl::new_empty!(ImportSpec, fidl::encoding::DefaultFuchsiaResourceDialect),
1541            }
1542        }
1543
1544        #[inline]
1545        unsafe fn decode(
1546            &mut self,
1547            decoder: &mut fidl::encoding::Decoder<
1548                '_,
1549                fidl::encoding::DefaultFuchsiaResourceDialect,
1550            >,
1551            offset: usize,
1552            _depth: fidl::encoding::Depth,
1553        ) -> fidl::Result<()> {
1554            decoder.debug_check_bounds::<Self>(offset);
1555            // Verify that padding bytes are zero.
1556            fidl::decode!(
1557                u32,
1558                fidl::encoding::DefaultFuchsiaResourceDialect,
1559                &mut self.id,
1560                decoder,
1561                offset + 0,
1562                _depth
1563            )?;
1564            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.token, decoder, offset + 4, _depth)?;
1565            fidl::decode!(
1566                ImportSpec,
1567                fidl::encoding::DefaultFuchsiaResourceDialect,
1568                &mut self.spec,
1569                decoder,
1570                offset + 8,
1571                _depth
1572            )?;
1573            Ok(())
1574        }
1575    }
1576
1577    impl fidl::encoding::ResourceTypeMarker for ImportToken {
1578        type Borrowed<'a> = &'a mut Self;
1579        fn take_or_borrow<'a>(
1580            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1581        ) -> Self::Borrowed<'a> {
1582            value
1583        }
1584    }
1585
1586    unsafe impl fidl::encoding::TypeMarker for ImportToken {
1587        type Owned = Self;
1588
1589        #[inline(always)]
1590        fn inline_align(_context: fidl::encoding::Context) -> usize {
1591            4
1592        }
1593
1594        #[inline(always)]
1595        fn inline_size(_context: fidl::encoding::Context) -> usize {
1596            4
1597        }
1598    }
1599
1600    unsafe impl fidl::encoding::Encode<ImportToken, fidl::encoding::DefaultFuchsiaResourceDialect>
1601        for &mut ImportToken
1602    {
1603        #[inline]
1604        unsafe fn encode(
1605            self,
1606            encoder: &mut fidl::encoding::Encoder<
1607                '_,
1608                fidl::encoding::DefaultFuchsiaResourceDialect,
1609            >,
1610            offset: usize,
1611            _depth: fidl::encoding::Depth,
1612        ) -> fidl::Result<()> {
1613            encoder.debug_check_bounds::<ImportToken>(offset);
1614            // Delegate to tuple encoding.
1615            fidl::encoding::Encode::<ImportToken, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1616                (
1617                    <fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
1618                ),
1619                encoder, offset, _depth
1620            )
1621        }
1622    }
1623    unsafe impl<
1624            T0: fidl::encoding::Encode<
1625                fidl::encoding::HandleType<
1626                    fidl::EventPair,
1627                    { fidl::ObjectType::EVENTPAIR.into_raw() },
1628                    2147483648,
1629                >,
1630                fidl::encoding::DefaultFuchsiaResourceDialect,
1631            >,
1632        > fidl::encoding::Encode<ImportToken, fidl::encoding::DefaultFuchsiaResourceDialect>
1633        for (T0,)
1634    {
1635        #[inline]
1636        unsafe fn encode(
1637            self,
1638            encoder: &mut fidl::encoding::Encoder<
1639                '_,
1640                fidl::encoding::DefaultFuchsiaResourceDialect,
1641            >,
1642            offset: usize,
1643            depth: fidl::encoding::Depth,
1644        ) -> fidl::Result<()> {
1645            encoder.debug_check_bounds::<ImportToken>(offset);
1646            // Zero out padding regions. There's no need to apply masks
1647            // because the unmasked parts will be overwritten by fields.
1648            // Write the fields.
1649            self.0.encode(encoder, offset + 0, depth)?;
1650            Ok(())
1651        }
1652    }
1653
1654    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ImportToken {
1655        #[inline(always)]
1656        fn new_empty() -> Self {
1657            Self {
1658                value: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1659            }
1660        }
1661
1662        #[inline]
1663        unsafe fn decode(
1664            &mut self,
1665            decoder: &mut fidl::encoding::Decoder<
1666                '_,
1667                fidl::encoding::DefaultFuchsiaResourceDialect,
1668            >,
1669            offset: usize,
1670            _depth: fidl::encoding::Depth,
1671        ) -> fidl::Result<()> {
1672            decoder.debug_check_bounds::<Self>(offset);
1673            // Verify that padding bytes are zero.
1674            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.value, decoder, offset + 0, _depth)?;
1675            Ok(())
1676        }
1677    }
1678
1679    impl fidl::encoding::ResourceTypeMarker for MemoryArgs {
1680        type Borrowed<'a> = &'a mut Self;
1681        fn take_or_borrow<'a>(
1682            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1683        ) -> Self::Borrowed<'a> {
1684            value
1685        }
1686    }
1687
1688    unsafe impl fidl::encoding::TypeMarker for MemoryArgs {
1689        type Owned = Self;
1690
1691        #[inline(always)]
1692        fn inline_align(_context: fidl::encoding::Context) -> usize {
1693            8
1694        }
1695
1696        #[inline(always)]
1697        fn inline_size(_context: fidl::encoding::Context) -> usize {
1698            24
1699        }
1700    }
1701
1702    unsafe impl fidl::encoding::Encode<MemoryArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
1703        for &mut MemoryArgs
1704    {
1705        #[inline]
1706        unsafe fn encode(
1707            self,
1708            encoder: &mut fidl::encoding::Encoder<
1709                '_,
1710                fidl::encoding::DefaultFuchsiaResourceDialect,
1711            >,
1712            offset: usize,
1713            _depth: fidl::encoding::Depth,
1714        ) -> fidl::Result<()> {
1715            encoder.debug_check_bounds::<MemoryArgs>(offset);
1716            // Delegate to tuple encoding.
1717            fidl::encoding::Encode::<MemoryArgs, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1718                (
1719                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.vmo),
1720                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.allocation_size),
1721                    <fidl_fuchsia_images::MemoryType as fidl::encoding::ValueTypeMarker>::borrow(&self.memory_type),
1722                ),
1723                encoder, offset, _depth
1724            )
1725        }
1726    }
1727    unsafe impl<
1728            T0: fidl::encoding::Encode<
1729                fidl::encoding::HandleType<
1730                    fidl::Vmo,
1731                    { fidl::ObjectType::VMO.into_raw() },
1732                    2147483648,
1733                >,
1734                fidl::encoding::DefaultFuchsiaResourceDialect,
1735            >,
1736            T1: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
1737            T2: fidl::encoding::Encode<
1738                fidl_fuchsia_images::MemoryType,
1739                fidl::encoding::DefaultFuchsiaResourceDialect,
1740            >,
1741        > fidl::encoding::Encode<MemoryArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
1742        for (T0, T1, T2)
1743    {
1744        #[inline]
1745        unsafe fn encode(
1746            self,
1747            encoder: &mut fidl::encoding::Encoder<
1748                '_,
1749                fidl::encoding::DefaultFuchsiaResourceDialect,
1750            >,
1751            offset: usize,
1752            depth: fidl::encoding::Depth,
1753        ) -> fidl::Result<()> {
1754            encoder.debug_check_bounds::<MemoryArgs>(offset);
1755            // Zero out padding regions. There's no need to apply masks
1756            // because the unmasked parts will be overwritten by fields.
1757            unsafe {
1758                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1759                (ptr as *mut u64).write_unaligned(0);
1760            }
1761            unsafe {
1762                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1763                (ptr as *mut u64).write_unaligned(0);
1764            }
1765            // Write the fields.
1766            self.0.encode(encoder, offset + 0, depth)?;
1767            self.1.encode(encoder, offset + 8, depth)?;
1768            self.2.encode(encoder, offset + 16, depth)?;
1769            Ok(())
1770        }
1771    }
1772
1773    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for MemoryArgs {
1774        #[inline(always)]
1775        fn new_empty() -> Self {
1776            Self {
1777                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
1778                allocation_size: fidl::new_empty!(
1779                    u64,
1780                    fidl::encoding::DefaultFuchsiaResourceDialect
1781                ),
1782                memory_type: fidl::new_empty!(
1783                    fidl_fuchsia_images::MemoryType,
1784                    fidl::encoding::DefaultFuchsiaResourceDialect
1785                ),
1786            }
1787        }
1788
1789        #[inline]
1790        unsafe fn decode(
1791            &mut self,
1792            decoder: &mut fidl::encoding::Decoder<
1793                '_,
1794                fidl::encoding::DefaultFuchsiaResourceDialect,
1795            >,
1796            offset: usize,
1797            _depth: fidl::encoding::Depth,
1798        ) -> fidl::Result<()> {
1799            decoder.debug_check_bounds::<Self>(offset);
1800            // Verify that padding bytes are zero.
1801            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1802            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1803            let mask = 0xffffffff00000000u64;
1804            let maskedval = padval & mask;
1805            if maskedval != 0 {
1806                return Err(fidl::Error::NonZeroPadding {
1807                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1808                });
1809            }
1810            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1811            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1812            let mask = 0xffffffff00000000u64;
1813            let maskedval = padval & mask;
1814            if maskedval != 0 {
1815                return Err(fidl::Error::NonZeroPadding {
1816                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1817                });
1818            }
1819            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo, decoder, offset + 0, _depth)?;
1820            fidl::decode!(
1821                u64,
1822                fidl::encoding::DefaultFuchsiaResourceDialect,
1823                &mut self.allocation_size,
1824                decoder,
1825                offset + 8,
1826                _depth
1827            )?;
1828            fidl::decode!(
1829                fidl_fuchsia_images::MemoryType,
1830                fidl::encoding::DefaultFuchsiaResourceDialect,
1831                &mut self.memory_type,
1832                decoder,
1833                offset + 16,
1834                _depth
1835            )?;
1836            Ok(())
1837        }
1838    }
1839
1840    impl fidl::encoding::ResourceTypeMarker for SnapshotCallbackDeprecatedOnDataRequest {
1841        type Borrowed<'a> = &'a mut Self;
1842        fn take_or_borrow<'a>(
1843            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1844        ) -> Self::Borrowed<'a> {
1845            value
1846        }
1847    }
1848
1849    unsafe impl fidl::encoding::TypeMarker for SnapshotCallbackDeprecatedOnDataRequest {
1850        type Owned = Self;
1851
1852        #[inline(always)]
1853        fn inline_align(_context: fidl::encoding::Context) -> usize {
1854            8
1855        }
1856
1857        #[inline(always)]
1858        fn inline_size(_context: fidl::encoding::Context) -> usize {
1859            16
1860        }
1861    }
1862
1863    unsafe impl
1864        fidl::encoding::Encode<
1865            SnapshotCallbackDeprecatedOnDataRequest,
1866            fidl::encoding::DefaultFuchsiaResourceDialect,
1867        > for &mut SnapshotCallbackDeprecatedOnDataRequest
1868    {
1869        #[inline]
1870        unsafe fn encode(
1871            self,
1872            encoder: &mut fidl::encoding::Encoder<
1873                '_,
1874                fidl::encoding::DefaultFuchsiaResourceDialect,
1875            >,
1876            offset: usize,
1877            _depth: fidl::encoding::Depth,
1878        ) -> fidl::Result<()> {
1879            encoder.debug_check_bounds::<SnapshotCallbackDeprecatedOnDataRequest>(offset);
1880            // Delegate to tuple encoding.
1881            fidl::encoding::Encode::<
1882                SnapshotCallbackDeprecatedOnDataRequest,
1883                fidl::encoding::DefaultFuchsiaResourceDialect,
1884            >::encode(
1885                (<fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
1886                    &mut self.data,
1887                ),),
1888                encoder,
1889                offset,
1890                _depth,
1891            )
1892        }
1893    }
1894    unsafe impl<
1895            T0: fidl::encoding::Encode<
1896                fidl_fuchsia_mem::Buffer,
1897                fidl::encoding::DefaultFuchsiaResourceDialect,
1898            >,
1899        >
1900        fidl::encoding::Encode<
1901            SnapshotCallbackDeprecatedOnDataRequest,
1902            fidl::encoding::DefaultFuchsiaResourceDialect,
1903        > for (T0,)
1904    {
1905        #[inline]
1906        unsafe fn encode(
1907            self,
1908            encoder: &mut fidl::encoding::Encoder<
1909                '_,
1910                fidl::encoding::DefaultFuchsiaResourceDialect,
1911            >,
1912            offset: usize,
1913            depth: fidl::encoding::Depth,
1914        ) -> fidl::Result<()> {
1915            encoder.debug_check_bounds::<SnapshotCallbackDeprecatedOnDataRequest>(offset);
1916            // Zero out padding regions. There's no need to apply masks
1917            // because the unmasked parts will be overwritten by fields.
1918            // Write the fields.
1919            self.0.encode(encoder, offset + 0, depth)?;
1920            Ok(())
1921        }
1922    }
1923
1924    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1925        for SnapshotCallbackDeprecatedOnDataRequest
1926    {
1927        #[inline(always)]
1928        fn new_empty() -> Self {
1929            Self {
1930                data: fidl::new_empty!(
1931                    fidl_fuchsia_mem::Buffer,
1932                    fidl::encoding::DefaultFuchsiaResourceDialect
1933                ),
1934            }
1935        }
1936
1937        #[inline]
1938        unsafe fn decode(
1939            &mut self,
1940            decoder: &mut fidl::encoding::Decoder<
1941                '_,
1942                fidl::encoding::DefaultFuchsiaResourceDialect,
1943            >,
1944            offset: usize,
1945            _depth: fidl::encoding::Depth,
1946        ) -> fidl::Result<()> {
1947            decoder.debug_check_bounds::<Self>(offset);
1948            // Verify that padding bytes are zero.
1949            fidl::decode!(
1950                fidl_fuchsia_mem::Buffer,
1951                fidl::encoding::DefaultFuchsiaResourceDialect,
1952                &mut self.data,
1953                decoder,
1954                offset + 0,
1955                _depth
1956            )?;
1957            Ok(())
1958        }
1959    }
1960
1961    impl fidl::encoding::ResourceTypeMarker for TakeSnapshotCmdDeprecated {
1962        type Borrowed<'a> = &'a mut Self;
1963        fn take_or_borrow<'a>(
1964            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1965        ) -> Self::Borrowed<'a> {
1966            value
1967        }
1968    }
1969
1970    unsafe impl fidl::encoding::TypeMarker for TakeSnapshotCmdDeprecated {
1971        type Owned = Self;
1972
1973        #[inline(always)]
1974        fn inline_align(_context: fidl::encoding::Context) -> usize {
1975            4
1976        }
1977
1978        #[inline(always)]
1979        fn inline_size(_context: fidl::encoding::Context) -> usize {
1980            8
1981        }
1982    }
1983
1984    unsafe impl
1985        fidl::encoding::Encode<
1986            TakeSnapshotCmdDeprecated,
1987            fidl::encoding::DefaultFuchsiaResourceDialect,
1988        > for &mut TakeSnapshotCmdDeprecated
1989    {
1990        #[inline]
1991        unsafe fn encode(
1992            self,
1993            encoder: &mut fidl::encoding::Encoder<
1994                '_,
1995                fidl::encoding::DefaultFuchsiaResourceDialect,
1996            >,
1997            offset: usize,
1998            _depth: fidl::encoding::Depth,
1999        ) -> fidl::Result<()> {
2000            encoder.debug_check_bounds::<TakeSnapshotCmdDeprecated>(offset);
2001            // Delegate to tuple encoding.
2002            fidl::encoding::Encode::<
2003                TakeSnapshotCmdDeprecated,
2004                fidl::encoding::DefaultFuchsiaResourceDialect,
2005            >::encode(
2006                (
2007                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.node_id),
2008                    <fidl::encoding::Endpoint<
2009                        fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
2010                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
2011                        &mut self.callback
2012                    ),
2013                ),
2014                encoder,
2015                offset,
2016                _depth,
2017            )
2018        }
2019    }
2020    unsafe impl<
2021            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
2022            T1: fidl::encoding::Encode<
2023                fidl::encoding::Endpoint<
2024                    fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
2025                >,
2026                fidl::encoding::DefaultFuchsiaResourceDialect,
2027            >,
2028        >
2029        fidl::encoding::Encode<
2030            TakeSnapshotCmdDeprecated,
2031            fidl::encoding::DefaultFuchsiaResourceDialect,
2032        > for (T0, T1)
2033    {
2034        #[inline]
2035        unsafe fn encode(
2036            self,
2037            encoder: &mut fidl::encoding::Encoder<
2038                '_,
2039                fidl::encoding::DefaultFuchsiaResourceDialect,
2040            >,
2041            offset: usize,
2042            depth: fidl::encoding::Depth,
2043        ) -> fidl::Result<()> {
2044            encoder.debug_check_bounds::<TakeSnapshotCmdDeprecated>(offset);
2045            // Zero out padding regions. There's no need to apply masks
2046            // because the unmasked parts will be overwritten by fields.
2047            // Write the fields.
2048            self.0.encode(encoder, offset + 0, depth)?;
2049            self.1.encode(encoder, offset + 4, depth)?;
2050            Ok(())
2051        }
2052    }
2053
2054    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2055        for TakeSnapshotCmdDeprecated
2056    {
2057        #[inline(always)]
2058        fn new_empty() -> Self {
2059            Self {
2060                node_id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
2061                callback: fidl::new_empty!(
2062                    fidl::encoding::Endpoint<
2063                        fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
2064                    >,
2065                    fidl::encoding::DefaultFuchsiaResourceDialect
2066                ),
2067            }
2068        }
2069
2070        #[inline]
2071        unsafe fn decode(
2072            &mut self,
2073            decoder: &mut fidl::encoding::Decoder<
2074                '_,
2075                fidl::encoding::DefaultFuchsiaResourceDialect,
2076            >,
2077            offset: usize,
2078            _depth: fidl::encoding::Depth,
2079        ) -> fidl::Result<()> {
2080            decoder.debug_check_bounds::<Self>(offset);
2081            // Verify that padding bytes are zero.
2082            fidl::decode!(
2083                u32,
2084                fidl::encoding::DefaultFuchsiaResourceDialect,
2085                &mut self.node_id,
2086                decoder,
2087                offset + 0,
2088                _depth
2089            )?;
2090            fidl::decode!(
2091                fidl::encoding::Endpoint<
2092                    fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
2093                >,
2094                fidl::encoding::DefaultFuchsiaResourceDialect,
2095                &mut self.callback,
2096                decoder,
2097                offset + 4,
2098                _depth
2099            )?;
2100            Ok(())
2101        }
2102    }
2103
2104    impl fidl::encoding::ResourceTypeMarker for ViewArgs {
2105        type Borrowed<'a> = &'a mut Self;
2106        fn take_or_borrow<'a>(
2107            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2108        ) -> Self::Borrowed<'a> {
2109            value
2110        }
2111    }
2112
2113    unsafe impl fidl::encoding::TypeMarker for ViewArgs {
2114        type Owned = Self;
2115
2116        #[inline(always)]
2117        fn inline_align(_context: fidl::encoding::Context) -> usize {
2118            8
2119        }
2120
2121        #[inline(always)]
2122        fn inline_size(_context: fidl::encoding::Context) -> usize {
2123            24
2124        }
2125    }
2126
2127    unsafe impl fidl::encoding::Encode<ViewArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
2128        for &mut ViewArgs
2129    {
2130        #[inline]
2131        unsafe fn encode(
2132            self,
2133            encoder: &mut fidl::encoding::Encoder<
2134                '_,
2135                fidl::encoding::DefaultFuchsiaResourceDialect,
2136            >,
2137            offset: usize,
2138            _depth: fidl::encoding::Depth,
2139        ) -> fidl::Result<()> {
2140            encoder.debug_check_bounds::<ViewArgs>(offset);
2141            // Delegate to tuple encoding.
2142            fidl::encoding::Encode::<ViewArgs, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
2143                (
2144                    <fidl_fuchsia_ui_views::ViewToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
2145                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.debug_name),
2146                ),
2147                encoder, offset, _depth
2148            )
2149        }
2150    }
2151    unsafe impl<
2152            T0: fidl::encoding::Encode<
2153                fidl_fuchsia_ui_views::ViewToken,
2154                fidl::encoding::DefaultFuchsiaResourceDialect,
2155            >,
2156            T1: fidl::encoding::Encode<
2157                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2158                fidl::encoding::DefaultFuchsiaResourceDialect,
2159            >,
2160        > fidl::encoding::Encode<ViewArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
2161        for (T0, T1)
2162    {
2163        #[inline]
2164        unsafe fn encode(
2165            self,
2166            encoder: &mut fidl::encoding::Encoder<
2167                '_,
2168                fidl::encoding::DefaultFuchsiaResourceDialect,
2169            >,
2170            offset: usize,
2171            depth: fidl::encoding::Depth,
2172        ) -> fidl::Result<()> {
2173            encoder.debug_check_bounds::<ViewArgs>(offset);
2174            // Zero out padding regions. There's no need to apply masks
2175            // because the unmasked parts will be overwritten by fields.
2176            unsafe {
2177                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2178                (ptr as *mut u64).write_unaligned(0);
2179            }
2180            // Write the fields.
2181            self.0.encode(encoder, offset + 0, depth)?;
2182            self.1.encode(encoder, offset + 8, depth)?;
2183            Ok(())
2184        }
2185    }
2186
2187    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs {
2188        #[inline(always)]
2189        fn new_empty() -> Self {
2190            Self {
2191                token: fidl::new_empty!(
2192                    fidl_fuchsia_ui_views::ViewToken,
2193                    fidl::encoding::DefaultFuchsiaResourceDialect
2194                ),
2195                debug_name: fidl::new_empty!(
2196                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2197                    fidl::encoding::DefaultFuchsiaResourceDialect
2198                ),
2199            }
2200        }
2201
2202        #[inline]
2203        unsafe fn decode(
2204            &mut self,
2205            decoder: &mut fidl::encoding::Decoder<
2206                '_,
2207                fidl::encoding::DefaultFuchsiaResourceDialect,
2208            >,
2209            offset: usize,
2210            _depth: fidl::encoding::Depth,
2211        ) -> fidl::Result<()> {
2212            decoder.debug_check_bounds::<Self>(offset);
2213            // Verify that padding bytes are zero.
2214            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2215            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2216            let mask = 0xffffffff00000000u64;
2217            let maskedval = padval & mask;
2218            if maskedval != 0 {
2219                return Err(fidl::Error::NonZeroPadding {
2220                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2221                });
2222            }
2223            fidl::decode!(
2224                fidl_fuchsia_ui_views::ViewToken,
2225                fidl::encoding::DefaultFuchsiaResourceDialect,
2226                &mut self.token,
2227                decoder,
2228                offset + 0,
2229                _depth
2230            )?;
2231            fidl::decode!(
2232                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2233                fidl::encoding::DefaultFuchsiaResourceDialect,
2234                &mut self.debug_name,
2235                decoder,
2236                offset + 8,
2237                _depth
2238            )?;
2239            Ok(())
2240        }
2241    }
2242
2243    impl fidl::encoding::ResourceTypeMarker for ViewArgs3 {
2244        type Borrowed<'a> = &'a mut Self;
2245        fn take_or_borrow<'a>(
2246            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2247        ) -> Self::Borrowed<'a> {
2248            value
2249        }
2250    }
2251
2252    unsafe impl fidl::encoding::TypeMarker for ViewArgs3 {
2253        type Owned = Self;
2254
2255        #[inline(always)]
2256        fn inline_align(_context: fidl::encoding::Context) -> usize {
2257            8
2258        }
2259
2260        #[inline(always)]
2261        fn inline_size(_context: fidl::encoding::Context) -> usize {
2262            32
2263        }
2264    }
2265
2266    unsafe impl fidl::encoding::Encode<ViewArgs3, fidl::encoding::DefaultFuchsiaResourceDialect>
2267        for &mut ViewArgs3
2268    {
2269        #[inline]
2270        unsafe fn encode(
2271            self,
2272            encoder: &mut fidl::encoding::Encoder<
2273                '_,
2274                fidl::encoding::DefaultFuchsiaResourceDialect,
2275            >,
2276            offset: usize,
2277            _depth: fidl::encoding::Depth,
2278        ) -> fidl::Result<()> {
2279            encoder.debug_check_bounds::<ViewArgs3>(offset);
2280            // Delegate to tuple encoding.
2281            fidl::encoding::Encode::<ViewArgs3, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
2282                (
2283                    <fidl_fuchsia_ui_views::ViewToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
2284                    <fidl_fuchsia_ui_views::ViewRefControl as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.control_ref),
2285                    <fidl_fuchsia_ui_views::ViewRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref),
2286                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.debug_name),
2287                ),
2288                encoder, offset, _depth
2289            )
2290        }
2291    }
2292    unsafe impl<
2293            T0: fidl::encoding::Encode<
2294                fidl_fuchsia_ui_views::ViewToken,
2295                fidl::encoding::DefaultFuchsiaResourceDialect,
2296            >,
2297            T1: fidl::encoding::Encode<
2298                fidl_fuchsia_ui_views::ViewRefControl,
2299                fidl::encoding::DefaultFuchsiaResourceDialect,
2300            >,
2301            T2: fidl::encoding::Encode<
2302                fidl_fuchsia_ui_views::ViewRef,
2303                fidl::encoding::DefaultFuchsiaResourceDialect,
2304            >,
2305            T3: fidl::encoding::Encode<
2306                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2307                fidl::encoding::DefaultFuchsiaResourceDialect,
2308            >,
2309        > fidl::encoding::Encode<ViewArgs3, fidl::encoding::DefaultFuchsiaResourceDialect>
2310        for (T0, T1, T2, T3)
2311    {
2312        #[inline]
2313        unsafe fn encode(
2314            self,
2315            encoder: &mut fidl::encoding::Encoder<
2316                '_,
2317                fidl::encoding::DefaultFuchsiaResourceDialect,
2318            >,
2319            offset: usize,
2320            depth: fidl::encoding::Depth,
2321        ) -> fidl::Result<()> {
2322            encoder.debug_check_bounds::<ViewArgs3>(offset);
2323            // Zero out padding regions. There's no need to apply masks
2324            // because the unmasked parts will be overwritten by fields.
2325            unsafe {
2326                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2327                (ptr as *mut u64).write_unaligned(0);
2328            }
2329            // Write the fields.
2330            self.0.encode(encoder, offset + 0, depth)?;
2331            self.1.encode(encoder, offset + 4, depth)?;
2332            self.2.encode(encoder, offset + 8, depth)?;
2333            self.3.encode(encoder, offset + 16, depth)?;
2334            Ok(())
2335        }
2336    }
2337
2338    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs3 {
2339        #[inline(always)]
2340        fn new_empty() -> Self {
2341            Self {
2342                token: fidl::new_empty!(
2343                    fidl_fuchsia_ui_views::ViewToken,
2344                    fidl::encoding::DefaultFuchsiaResourceDialect
2345                ),
2346                control_ref: fidl::new_empty!(
2347                    fidl_fuchsia_ui_views::ViewRefControl,
2348                    fidl::encoding::DefaultFuchsiaResourceDialect
2349                ),
2350                view_ref: fidl::new_empty!(
2351                    fidl_fuchsia_ui_views::ViewRef,
2352                    fidl::encoding::DefaultFuchsiaResourceDialect
2353                ),
2354                debug_name: fidl::new_empty!(
2355                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2356                    fidl::encoding::DefaultFuchsiaResourceDialect
2357                ),
2358            }
2359        }
2360
2361        #[inline]
2362        unsafe fn decode(
2363            &mut self,
2364            decoder: &mut fidl::encoding::Decoder<
2365                '_,
2366                fidl::encoding::DefaultFuchsiaResourceDialect,
2367            >,
2368            offset: usize,
2369            _depth: fidl::encoding::Depth,
2370        ) -> fidl::Result<()> {
2371            decoder.debug_check_bounds::<Self>(offset);
2372            // Verify that padding bytes are zero.
2373            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
2374            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2375            let mask = 0xffffffff00000000u64;
2376            let maskedval = padval & mask;
2377            if maskedval != 0 {
2378                return Err(fidl::Error::NonZeroPadding {
2379                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2380                });
2381            }
2382            fidl::decode!(
2383                fidl_fuchsia_ui_views::ViewToken,
2384                fidl::encoding::DefaultFuchsiaResourceDialect,
2385                &mut self.token,
2386                decoder,
2387                offset + 0,
2388                _depth
2389            )?;
2390            fidl::decode!(
2391                fidl_fuchsia_ui_views::ViewRefControl,
2392                fidl::encoding::DefaultFuchsiaResourceDialect,
2393                &mut self.control_ref,
2394                decoder,
2395                offset + 4,
2396                _depth
2397            )?;
2398            fidl::decode!(
2399                fidl_fuchsia_ui_views::ViewRef,
2400                fidl::encoding::DefaultFuchsiaResourceDialect,
2401                &mut self.view_ref,
2402                decoder,
2403                offset + 8,
2404                _depth
2405            )?;
2406            fidl::decode!(
2407                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2408                fidl::encoding::DefaultFuchsiaResourceDialect,
2409                &mut self.debug_name,
2410                decoder,
2411                offset + 16,
2412                _depth
2413            )?;
2414            Ok(())
2415        }
2416    }
2417
2418    impl fidl::encoding::ResourceTypeMarker for ViewHolderArgs {
2419        type Borrowed<'a> = &'a mut Self;
2420        fn take_or_borrow<'a>(
2421            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2422        ) -> Self::Borrowed<'a> {
2423            value
2424        }
2425    }
2426
2427    unsafe impl fidl::encoding::TypeMarker for ViewHolderArgs {
2428        type Owned = Self;
2429
2430        #[inline(always)]
2431        fn inline_align(_context: fidl::encoding::Context) -> usize {
2432            8
2433        }
2434
2435        #[inline(always)]
2436        fn inline_size(_context: fidl::encoding::Context) -> usize {
2437            24
2438        }
2439    }
2440
2441    unsafe impl
2442        fidl::encoding::Encode<ViewHolderArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
2443        for &mut ViewHolderArgs
2444    {
2445        #[inline]
2446        unsafe fn encode(
2447            self,
2448            encoder: &mut fidl::encoding::Encoder<
2449                '_,
2450                fidl::encoding::DefaultFuchsiaResourceDialect,
2451            >,
2452            offset: usize,
2453            _depth: fidl::encoding::Depth,
2454        ) -> fidl::Result<()> {
2455            encoder.debug_check_bounds::<ViewHolderArgs>(offset);
2456            // Delegate to tuple encoding.
2457            fidl::encoding::Encode::<ViewHolderArgs, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
2458                (
2459                    <fidl_fuchsia_ui_views::ViewHolderToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
2460                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.debug_name),
2461                ),
2462                encoder, offset, _depth
2463            )
2464        }
2465    }
2466    unsafe impl<
2467            T0: fidl::encoding::Encode<
2468                fidl_fuchsia_ui_views::ViewHolderToken,
2469                fidl::encoding::DefaultFuchsiaResourceDialect,
2470            >,
2471            T1: fidl::encoding::Encode<
2472                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2473                fidl::encoding::DefaultFuchsiaResourceDialect,
2474            >,
2475        > fidl::encoding::Encode<ViewHolderArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
2476        for (T0, T1)
2477    {
2478        #[inline]
2479        unsafe fn encode(
2480            self,
2481            encoder: &mut fidl::encoding::Encoder<
2482                '_,
2483                fidl::encoding::DefaultFuchsiaResourceDialect,
2484            >,
2485            offset: usize,
2486            depth: fidl::encoding::Depth,
2487        ) -> fidl::Result<()> {
2488            encoder.debug_check_bounds::<ViewHolderArgs>(offset);
2489            // Zero out padding regions. There's no need to apply masks
2490            // because the unmasked parts will be overwritten by fields.
2491            unsafe {
2492                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2493                (ptr as *mut u64).write_unaligned(0);
2494            }
2495            // Write the fields.
2496            self.0.encode(encoder, offset + 0, depth)?;
2497            self.1.encode(encoder, offset + 8, depth)?;
2498            Ok(())
2499        }
2500    }
2501
2502    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2503        for ViewHolderArgs
2504    {
2505        #[inline(always)]
2506        fn new_empty() -> Self {
2507            Self {
2508                token: fidl::new_empty!(
2509                    fidl_fuchsia_ui_views::ViewHolderToken,
2510                    fidl::encoding::DefaultFuchsiaResourceDialect
2511                ),
2512                debug_name: fidl::new_empty!(
2513                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2514                    fidl::encoding::DefaultFuchsiaResourceDialect
2515                ),
2516            }
2517        }
2518
2519        #[inline]
2520        unsafe fn decode(
2521            &mut self,
2522            decoder: &mut fidl::encoding::Decoder<
2523                '_,
2524                fidl::encoding::DefaultFuchsiaResourceDialect,
2525            >,
2526            offset: usize,
2527            _depth: fidl::encoding::Depth,
2528        ) -> fidl::Result<()> {
2529            decoder.debug_check_bounds::<Self>(offset);
2530            // Verify that padding bytes are zero.
2531            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2532            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2533            let mask = 0xffffffff00000000u64;
2534            let maskedval = padval & mask;
2535            if maskedval != 0 {
2536                return Err(fidl::Error::NonZeroPadding {
2537                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2538                });
2539            }
2540            fidl::decode!(
2541                fidl_fuchsia_ui_views::ViewHolderToken,
2542                fidl::encoding::DefaultFuchsiaResourceDialect,
2543                &mut self.token,
2544                decoder,
2545                offset + 0,
2546                _depth
2547            )?;
2548            fidl::decode!(
2549                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
2550                fidl::encoding::DefaultFuchsiaResourceDialect,
2551                &mut self.debug_name,
2552                decoder,
2553                offset + 8,
2554                _depth
2555            )?;
2556            Ok(())
2557        }
2558    }
2559
2560    impl fidl::encoding::ResourceTypeMarker for Command {
2561        type Borrowed<'a> = &'a mut Self;
2562        fn take_or_borrow<'a>(
2563            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2564        ) -> Self::Borrowed<'a> {
2565            value
2566        }
2567    }
2568
2569    unsafe impl fidl::encoding::TypeMarker for Command {
2570        type Owned = Self;
2571
2572        #[inline(always)]
2573        fn inline_align(_context: fidl::encoding::Context) -> usize {
2574            8
2575        }
2576
2577        #[inline(always)]
2578        fn inline_size(_context: fidl::encoding::Context) -> usize {
2579            16
2580        }
2581    }
2582
2583    unsafe impl fidl::encoding::Encode<Command, fidl::encoding::DefaultFuchsiaResourceDialect>
2584        for &mut Command
2585    {
2586        #[inline]
2587        unsafe fn encode(
2588            self,
2589            encoder: &mut fidl::encoding::Encoder<
2590                '_,
2591                fidl::encoding::DefaultFuchsiaResourceDialect,
2592            >,
2593            offset: usize,
2594            _depth: fidl::encoding::Depth,
2595        ) -> fidl::Result<()> {
2596            encoder.debug_check_bounds::<Command>(offset);
2597            encoder.write_num::<u64>(self.ordinal(), offset);
2598            match self {
2599            Command::CreateResource(ref mut val) => {
2600                fidl::encoding::encode_in_envelope::<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2601                    <CreateResourceCmd as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
2602                    encoder, offset + 8, _depth
2603                )
2604            }
2605            Command::ReleaseResource(ref val) => {
2606                fidl::encoding::encode_in_envelope::<ReleaseResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2607                    <ReleaseResourceCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2608                    encoder, offset + 8, _depth
2609                )
2610            }
2611            Command::ExportResource(ref mut val) => {
2612                fidl::encoding::encode_in_envelope::<ExportResourceCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
2613                    <ExportResourceCmdDeprecated as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
2614                    encoder, offset + 8, _depth
2615                )
2616            }
2617            Command::ImportResource(ref mut val) => {
2618                fidl::encoding::encode_in_envelope::<ImportResourceCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
2619                    <ImportResourceCmdDeprecated as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
2620                    encoder, offset + 8, _depth
2621                )
2622            }
2623            Command::SetTag(ref val) => {
2624                fidl::encoding::encode_in_envelope::<SetTagCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2625                    <SetTagCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2626                    encoder, offset + 8, _depth
2627                )
2628            }
2629            Command::Detach(ref val) => {
2630                fidl::encoding::encode_in_envelope::<DetachCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2631                    <DetachCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2632                    encoder, offset + 8, _depth
2633                )
2634            }
2635            Command::SetTranslation(ref val) => {
2636                fidl::encoding::encode_in_envelope::<SetTranslationCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2637                    <SetTranslationCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2638                    encoder, offset + 8, _depth
2639                )
2640            }
2641            Command::SetScale(ref val) => {
2642                fidl::encoding::encode_in_envelope::<SetScaleCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2643                    <SetScaleCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2644                    encoder, offset + 8, _depth
2645                )
2646            }
2647            Command::SetRotation(ref val) => {
2648                fidl::encoding::encode_in_envelope::<SetRotationCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2649                    <SetRotationCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2650                    encoder, offset + 8, _depth
2651                )
2652            }
2653            Command::SetAnchor(ref val) => {
2654                fidl::encoding::encode_in_envelope::<SetAnchorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2655                    <SetAnchorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2656                    encoder, offset + 8, _depth
2657                )
2658            }
2659            Command::SetSize(ref val) => {
2660                fidl::encoding::encode_in_envelope::<SetSizeCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2661                    <SetSizeCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2662                    encoder, offset + 8, _depth
2663                )
2664            }
2665            Command::SetOpacity(ref val) => {
2666                fidl::encoding::encode_in_envelope::<SetOpacityCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2667                    <SetOpacityCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2668                    encoder, offset + 8, _depth
2669                )
2670            }
2671            Command::SendSizeChangeHintHack(ref val) => {
2672                fidl::encoding::encode_in_envelope::<SendSizeChangeHintCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
2673                    <SendSizeChangeHintCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
2674                    encoder, offset + 8, _depth
2675                )
2676            }
2677            Command::AddChild(ref val) => {
2678                fidl::encoding::encode_in_envelope::<AddChildCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2679                    <AddChildCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2680                    encoder, offset + 8, _depth
2681                )
2682            }
2683            Command::AddPart(ref val) => {
2684                fidl::encoding::encode_in_envelope::<AddPartCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2685                    <AddPartCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2686                    encoder, offset + 8, _depth
2687                )
2688            }
2689            Command::DetachChildren(ref val) => {
2690                fidl::encoding::encode_in_envelope::<DetachChildrenCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2691                    <DetachChildrenCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2692                    encoder, offset + 8, _depth
2693                )
2694            }
2695            Command::SetShape(ref val) => {
2696                fidl::encoding::encode_in_envelope::<SetShapeCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2697                    <SetShapeCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2698                    encoder, offset + 8, _depth
2699                )
2700            }
2701            Command::SetMaterial(ref val) => {
2702                fidl::encoding::encode_in_envelope::<SetMaterialCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2703                    <SetMaterialCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2704                    encoder, offset + 8, _depth
2705                )
2706            }
2707            Command::SetClip(ref val) => {
2708                fidl::encoding::encode_in_envelope::<SetClipCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2709                    <SetClipCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2710                    encoder, offset + 8, _depth
2711                )
2712            }
2713            Command::SetHitTestBehavior(ref val) => {
2714                fidl::encoding::encode_in_envelope::<SetHitTestBehaviorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2715                    <SetHitTestBehaviorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2716                    encoder, offset + 8, _depth
2717                )
2718            }
2719            Command::SetViewProperties(ref val) => {
2720                fidl::encoding::encode_in_envelope::<SetViewPropertiesCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2721                    <SetViewPropertiesCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2722                    encoder, offset + 8, _depth
2723                )
2724            }
2725            Command::TakeSnapshotCmd(ref mut val) => {
2726                fidl::encoding::encode_in_envelope::<TakeSnapshotCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
2727                    <TakeSnapshotCmdDeprecated as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
2728                    encoder, offset + 8, _depth
2729                )
2730            }
2731            Command::SetCamera(ref val) => {
2732                fidl::encoding::encode_in_envelope::<SetCameraCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2733                    <SetCameraCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2734                    encoder, offset + 8, _depth
2735                )
2736            }
2737            Command::SetCameraTransform(ref val) => {
2738                fidl::encoding::encode_in_envelope::<SetCameraTransformCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2739                    <SetCameraTransformCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2740                    encoder, offset + 8, _depth
2741                )
2742            }
2743            Command::SetCameraProjection(ref val) => {
2744                fidl::encoding::encode_in_envelope::<SetCameraProjectionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2745                    <SetCameraProjectionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2746                    encoder, offset + 8, _depth
2747                )
2748            }
2749            Command::SetStereoCameraProjection(ref val) => {
2750                fidl::encoding::encode_in_envelope::<SetStereoCameraProjectionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2751                    <SetStereoCameraProjectionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2752                    encoder, offset + 8, _depth
2753                )
2754            }
2755            Command::SetCameraPoseBuffer(ref val) => {
2756                fidl::encoding::encode_in_envelope::<SetCameraPoseBufferCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2757                    <SetCameraPoseBufferCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2758                    encoder, offset + 8, _depth
2759                )
2760            }
2761            Command::SetLightColor(ref val) => {
2762                fidl::encoding::encode_in_envelope::<SetLightColorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2763                    <SetLightColorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2764                    encoder, offset + 8, _depth
2765                )
2766            }
2767            Command::SetLightDirection(ref val) => {
2768                fidl::encoding::encode_in_envelope::<SetLightDirectionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2769                    <SetLightDirectionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2770                    encoder, offset + 8, _depth
2771                )
2772            }
2773            Command::AddLight(ref val) => {
2774                fidl::encoding::encode_in_envelope::<AddLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2775                    <AddLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2776                    encoder, offset + 8, _depth
2777                )
2778            }
2779            Command::DetachLight(ref val) => {
2780                fidl::encoding::encode_in_envelope::<DetachLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2781                    <DetachLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2782                    encoder, offset + 8, _depth
2783                )
2784            }
2785            Command::DetachLights(ref val) => {
2786                fidl::encoding::encode_in_envelope::<DetachLightsCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2787                    <DetachLightsCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2788                    encoder, offset + 8, _depth
2789                )
2790            }
2791            Command::SetTexture(ref val) => {
2792                fidl::encoding::encode_in_envelope::<SetTextureCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2793                    <SetTextureCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2794                    encoder, offset + 8, _depth
2795                )
2796            }
2797            Command::SetColor(ref val) => {
2798                fidl::encoding::encode_in_envelope::<SetColorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2799                    <SetColorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2800                    encoder, offset + 8, _depth
2801                )
2802            }
2803            Command::BindMeshBuffers(ref val) => {
2804                fidl::encoding::encode_in_envelope::<BindMeshBuffersCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2805                    <BindMeshBuffersCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2806                    encoder, offset + 8, _depth
2807                )
2808            }
2809            Command::AddLayer(ref val) => {
2810                fidl::encoding::encode_in_envelope::<AddLayerCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2811                    <AddLayerCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2812                    encoder, offset + 8, _depth
2813                )
2814            }
2815            Command::RemoveLayer(ref val) => {
2816                fidl::encoding::encode_in_envelope::<RemoveLayerCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2817                    <RemoveLayerCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2818                    encoder, offset + 8, _depth
2819                )
2820            }
2821            Command::RemoveAllLayers(ref val) => {
2822                fidl::encoding::encode_in_envelope::<RemoveAllLayersCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2823                    <RemoveAllLayersCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2824                    encoder, offset + 8, _depth
2825                )
2826            }
2827            Command::SetLayerStack(ref val) => {
2828                fidl::encoding::encode_in_envelope::<SetLayerStackCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2829                    <SetLayerStackCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2830                    encoder, offset + 8, _depth
2831                )
2832            }
2833            Command::SetRenderer(ref val) => {
2834                fidl::encoding::encode_in_envelope::<SetRendererCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2835                    <SetRendererCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2836                    encoder, offset + 8, _depth
2837                )
2838            }
2839            Command::SetRendererParam(ref val) => {
2840                fidl::encoding::encode_in_envelope::<SetRendererParamCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2841                    <SetRendererParamCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2842                    encoder, offset + 8, _depth
2843                )
2844            }
2845            Command::SetEventMask(ref val) => {
2846                fidl::encoding::encode_in_envelope::<SetEventMaskCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2847                    <SetEventMaskCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2848                    encoder, offset + 8, _depth
2849                )
2850            }
2851            Command::SetLabel(ref val) => {
2852                fidl::encoding::encode_in_envelope::<SetLabelCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2853                    <SetLabelCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2854                    encoder, offset + 8, _depth
2855                )
2856            }
2857            Command::SetDisableClipping(ref val) => {
2858                fidl::encoding::encode_in_envelope::<SetDisableClippingCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2859                    <SetDisableClippingCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2860                    encoder, offset + 8, _depth
2861                )
2862            }
2863            Command::SetImportFocus(ref val) => {
2864                fidl::encoding::encode_in_envelope::<SetImportFocusCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
2865                    <SetImportFocusCmdDeprecated as fidl::encoding::ValueTypeMarker>::borrow(val),
2866                    encoder, offset + 8, _depth
2867                )
2868            }
2869            Command::SetClipPlanes(ref val) => {
2870                fidl::encoding::encode_in_envelope::<SetClipPlanesCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2871                    <SetClipPlanesCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2872                    encoder, offset + 8, _depth
2873                )
2874            }
2875            Command::SetPointLightPosition(ref val) => {
2876                fidl::encoding::encode_in_envelope::<SetPointLightPositionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2877                    <SetPointLightPositionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2878                    encoder, offset + 8, _depth
2879                )
2880            }
2881            Command::SetPointLightFalloff(ref val) => {
2882                fidl::encoding::encode_in_envelope::<SetPointLightFalloffCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2883                    <SetPointLightFalloffCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2884                    encoder, offset + 8, _depth
2885                )
2886            }
2887            Command::Scene_AddAmbientLight(ref val) => {
2888                fidl::encoding::encode_in_envelope::<SceneAddAmbientLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2889                    <SceneAddAmbientLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2890                    encoder, offset + 8, _depth
2891                )
2892            }
2893            Command::Scene_AddDirectionalLight(ref val) => {
2894                fidl::encoding::encode_in_envelope::<SceneAddDirectionalLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2895                    <SceneAddDirectionalLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2896                    encoder, offset + 8, _depth
2897                )
2898            }
2899            Command::Scene_AddPointLight(ref val) => {
2900                fidl::encoding::encode_in_envelope::<SceneAddPointLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2901                    <SceneAddPointLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2902                    encoder, offset + 8, _depth
2903                )
2904            }
2905            Command::SetDisplayColorConversion(ref val) => {
2906                fidl::encoding::encode_in_envelope::<SetDisplayColorConversionCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
2907                    <SetDisplayColorConversionCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
2908                    encoder, offset + 8, _depth
2909                )
2910            }
2911            Command::SetDisplayRotation(ref val) => {
2912                fidl::encoding::encode_in_envelope::<SetDisplayRotationCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
2913                    <SetDisplayRotationCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
2914                    encoder, offset + 8, _depth
2915                )
2916            }
2917            Command::SetEnableViewDebugBounds(ref val) => {
2918                fidl::encoding::encode_in_envelope::<SetEnableDebugViewBoundsCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2919                    <SetEnableDebugViewBoundsCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2920                    encoder, offset + 8, _depth
2921                )
2922            }
2923            Command::SetViewHolderBoundsColor(ref val) => {
2924                fidl::encoding::encode_in_envelope::<SetViewHolderBoundsColorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2925                    <SetViewHolderBoundsColorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2926                    encoder, offset + 8, _depth
2927                )
2928            }
2929            Command::SetCameraClipSpaceTransform(ref val) => {
2930                fidl::encoding::encode_in_envelope::<SetCameraClipSpaceTransformCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2931                    <SetCameraClipSpaceTransformCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2932                    encoder, offset + 8, _depth
2933                )
2934            }
2935            Command::SetDisplayMinimumRgb(ref val) => {
2936                fidl::encoding::encode_in_envelope::<SetDisplayMinimumRgbCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
2937                    <SetDisplayMinimumRgbCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
2938                    encoder, offset + 8, _depth
2939                )
2940            }
2941            Command::SetSemanticVisibility(ref val) => {
2942                fidl::encoding::encode_in_envelope::<SetSemanticVisibilityCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
2943                    <SetSemanticVisibilityCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
2944                    encoder, offset + 8, _depth
2945                )
2946            }
2947        }
2948        }
2949    }
2950
2951    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Command {
2952        #[inline(always)]
2953        fn new_empty() -> Self {
2954            Self::CreateResource(fidl::new_empty!(
2955                CreateResourceCmd,
2956                fidl::encoding::DefaultFuchsiaResourceDialect
2957            ))
2958        }
2959
2960        #[inline]
2961        unsafe fn decode(
2962            &mut self,
2963            decoder: &mut fidl::encoding::Decoder<
2964                '_,
2965                fidl::encoding::DefaultFuchsiaResourceDialect,
2966            >,
2967            offset: usize,
2968            mut depth: fidl::encoding::Depth,
2969        ) -> fidl::Result<()> {
2970            decoder.debug_check_bounds::<Self>(offset);
2971            #[allow(unused_variables)]
2972            let next_out_of_line = decoder.next_out_of_line();
2973            let handles_before = decoder.remaining_handles();
2974            let (ordinal, inlined, num_bytes, num_handles) =
2975                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2976
2977            let member_inline_size = match ordinal {
2978                1 => {
2979                    <CreateResourceCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
2980                }
2981                2 => {
2982                    <ReleaseResourceCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
2983                }
2984                3 => <ExportResourceCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
2985                    decoder.context,
2986                ),
2987                4 => <ImportResourceCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
2988                    decoder.context,
2989                ),
2990                5 => <SetTagCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2991                6 => <DetachCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2992                7 => {
2993                    <SetTranslationCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
2994                }
2995                8 => <SetScaleCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2996                9 => <SetRotationCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2997                10 => <SetAnchorCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2998                11 => <SetSizeCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2999                12 => <SetOpacityCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3000                13 => <SendSizeChangeHintCmdHack as fidl::encoding::TypeMarker>::inline_size(
3001                    decoder.context,
3002                ),
3003                14 => <AddChildCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3004                15 => <AddPartCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3005                16 => {
3006                    <DetachChildrenCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
3007                }
3008                17 => <SetShapeCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3009                18 => <SetMaterialCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3010                19 => <SetClipCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3011                20 => <SetHitTestBehaviorCmd as fidl::encoding::TypeMarker>::inline_size(
3012                    decoder.context,
3013                ),
3014                21 => <SetViewPropertiesCmd as fidl::encoding::TypeMarker>::inline_size(
3015                    decoder.context,
3016                ),
3017                22 => <TakeSnapshotCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
3018                    decoder.context,
3019                ),
3020                23 => <SetCameraCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3021                24 => <SetCameraTransformCmd as fidl::encoding::TypeMarker>::inline_size(
3022                    decoder.context,
3023                ),
3024                25 => <SetCameraProjectionCmd as fidl::encoding::TypeMarker>::inline_size(
3025                    decoder.context,
3026                ),
3027                26 => <SetStereoCameraProjectionCmd as fidl::encoding::TypeMarker>::inline_size(
3028                    decoder.context,
3029                ),
3030                27 => <SetCameraPoseBufferCmd as fidl::encoding::TypeMarker>::inline_size(
3031                    decoder.context,
3032                ),
3033                28 => {
3034                    <SetLightColorCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
3035                }
3036                29 => <SetLightDirectionCmd as fidl::encoding::TypeMarker>::inline_size(
3037                    decoder.context,
3038                ),
3039                30 => <AddLightCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3040                31 => <DetachLightCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3041                32 => <DetachLightsCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3042                33 => <SetTextureCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3043                34 => <SetColorCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3044                35 => {
3045                    <BindMeshBuffersCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
3046                }
3047                36 => <AddLayerCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3048                37 => <RemoveLayerCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3049                38 => {
3050                    <RemoveAllLayersCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
3051                }
3052                39 => {
3053                    <SetLayerStackCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
3054                }
3055                40 => <SetRendererCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3056                41 => <SetRendererParamCmd as fidl::encoding::TypeMarker>::inline_size(
3057                    decoder.context,
3058                ),
3059                42 => <SetEventMaskCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3060                43 => <SetLabelCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3061                44 => <SetDisableClippingCmd as fidl::encoding::TypeMarker>::inline_size(
3062                    decoder.context,
3063                ),
3064                45 => <SetImportFocusCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
3065                    decoder.context,
3066                ),
3067                46 => {
3068                    <SetClipPlanesCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
3069                }
3070                47 => <SetPointLightPositionCmd as fidl::encoding::TypeMarker>::inline_size(
3071                    decoder.context,
3072                ),
3073                48 => <SetPointLightFalloffCmd as fidl::encoding::TypeMarker>::inline_size(
3074                    decoder.context,
3075                ),
3076                49 => <SceneAddAmbientLightCmd as fidl::encoding::TypeMarker>::inline_size(
3077                    decoder.context,
3078                ),
3079                50 => <SceneAddDirectionalLightCmd as fidl::encoding::TypeMarker>::inline_size(
3080                    decoder.context,
3081                ),
3082                51 => <SceneAddPointLightCmd as fidl::encoding::TypeMarker>::inline_size(
3083                    decoder.context,
3084                ),
3085                52 => {
3086                    <SetDisplayColorConversionCmdHack as fidl::encoding::TypeMarker>::inline_size(
3087                        decoder.context,
3088                    )
3089                }
3090                53 => <SetDisplayRotationCmdHack as fidl::encoding::TypeMarker>::inline_size(
3091                    decoder.context,
3092                ),
3093                54 => <SetEnableDebugViewBoundsCmd as fidl::encoding::TypeMarker>::inline_size(
3094                    decoder.context,
3095                ),
3096                55 => <SetViewHolderBoundsColorCmd as fidl::encoding::TypeMarker>::inline_size(
3097                    decoder.context,
3098                ),
3099                56 => <SetCameraClipSpaceTransformCmd as fidl::encoding::TypeMarker>::inline_size(
3100                    decoder.context,
3101                ),
3102                57 => <SetDisplayMinimumRgbCmdHack as fidl::encoding::TypeMarker>::inline_size(
3103                    decoder.context,
3104                ),
3105                58 => <SetSemanticVisibilityCmd as fidl::encoding::TypeMarker>::inline_size(
3106                    decoder.context,
3107                ),
3108                _ => return Err(fidl::Error::UnknownUnionTag),
3109            };
3110
3111            if inlined != (member_inline_size <= 4) {
3112                return Err(fidl::Error::InvalidInlineBitInEnvelope);
3113            }
3114            let _inner_offset;
3115            if inlined {
3116                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
3117                _inner_offset = offset + 8;
3118            } else {
3119                depth.increment()?;
3120                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3121            }
3122            match ordinal {
3123                1 => {
3124                    #[allow(irrefutable_let_patterns)]
3125                    if let Command::CreateResource(_) = self {
3126                        // Do nothing, read the value into the object
3127                    } else {
3128                        // Initialize `self` to the right variant
3129                        *self = Command::CreateResource(fidl::new_empty!(
3130                            CreateResourceCmd,
3131                            fidl::encoding::DefaultFuchsiaResourceDialect
3132                        ));
3133                    }
3134                    #[allow(irrefutable_let_patterns)]
3135                    if let Command::CreateResource(ref mut val) = self {
3136                        fidl::decode!(
3137                            CreateResourceCmd,
3138                            fidl::encoding::DefaultFuchsiaResourceDialect,
3139                            val,
3140                            decoder,
3141                            _inner_offset,
3142                            depth
3143                        )?;
3144                    } else {
3145                        unreachable!()
3146                    }
3147                }
3148                2 => {
3149                    #[allow(irrefutable_let_patterns)]
3150                    if let Command::ReleaseResource(_) = self {
3151                        // Do nothing, read the value into the object
3152                    } else {
3153                        // Initialize `self` to the right variant
3154                        *self = Command::ReleaseResource(fidl::new_empty!(
3155                            ReleaseResourceCmd,
3156                            fidl::encoding::DefaultFuchsiaResourceDialect
3157                        ));
3158                    }
3159                    #[allow(irrefutable_let_patterns)]
3160                    if let Command::ReleaseResource(ref mut val) = self {
3161                        fidl::decode!(
3162                            ReleaseResourceCmd,
3163                            fidl::encoding::DefaultFuchsiaResourceDialect,
3164                            val,
3165                            decoder,
3166                            _inner_offset,
3167                            depth
3168                        )?;
3169                    } else {
3170                        unreachable!()
3171                    }
3172                }
3173                3 => {
3174                    #[allow(irrefutable_let_patterns)]
3175                    if let Command::ExportResource(_) = self {
3176                        // Do nothing, read the value into the object
3177                    } else {
3178                        // Initialize `self` to the right variant
3179                        *self = Command::ExportResource(fidl::new_empty!(
3180                            ExportResourceCmdDeprecated,
3181                            fidl::encoding::DefaultFuchsiaResourceDialect
3182                        ));
3183                    }
3184                    #[allow(irrefutable_let_patterns)]
3185                    if let Command::ExportResource(ref mut val) = self {
3186                        fidl::decode!(
3187                            ExportResourceCmdDeprecated,
3188                            fidl::encoding::DefaultFuchsiaResourceDialect,
3189                            val,
3190                            decoder,
3191                            _inner_offset,
3192                            depth
3193                        )?;
3194                    } else {
3195                        unreachable!()
3196                    }
3197                }
3198                4 => {
3199                    #[allow(irrefutable_let_patterns)]
3200                    if let Command::ImportResource(_) = self {
3201                        // Do nothing, read the value into the object
3202                    } else {
3203                        // Initialize `self` to the right variant
3204                        *self = Command::ImportResource(fidl::new_empty!(
3205                            ImportResourceCmdDeprecated,
3206                            fidl::encoding::DefaultFuchsiaResourceDialect
3207                        ));
3208                    }
3209                    #[allow(irrefutable_let_patterns)]
3210                    if let Command::ImportResource(ref mut val) = self {
3211                        fidl::decode!(
3212                            ImportResourceCmdDeprecated,
3213                            fidl::encoding::DefaultFuchsiaResourceDialect,
3214                            val,
3215                            decoder,
3216                            _inner_offset,
3217                            depth
3218                        )?;
3219                    } else {
3220                        unreachable!()
3221                    }
3222                }
3223                5 => {
3224                    #[allow(irrefutable_let_patterns)]
3225                    if let Command::SetTag(_) = self {
3226                        // Do nothing, read the value into the object
3227                    } else {
3228                        // Initialize `self` to the right variant
3229                        *self = Command::SetTag(fidl::new_empty!(
3230                            SetTagCmd,
3231                            fidl::encoding::DefaultFuchsiaResourceDialect
3232                        ));
3233                    }
3234                    #[allow(irrefutable_let_patterns)]
3235                    if let Command::SetTag(ref mut val) = self {
3236                        fidl::decode!(
3237                            SetTagCmd,
3238                            fidl::encoding::DefaultFuchsiaResourceDialect,
3239                            val,
3240                            decoder,
3241                            _inner_offset,
3242                            depth
3243                        )?;
3244                    } else {
3245                        unreachable!()
3246                    }
3247                }
3248                6 => {
3249                    #[allow(irrefutable_let_patterns)]
3250                    if let Command::Detach(_) = self {
3251                        // Do nothing, read the value into the object
3252                    } else {
3253                        // Initialize `self` to the right variant
3254                        *self = Command::Detach(fidl::new_empty!(
3255                            DetachCmd,
3256                            fidl::encoding::DefaultFuchsiaResourceDialect
3257                        ));
3258                    }
3259                    #[allow(irrefutable_let_patterns)]
3260                    if let Command::Detach(ref mut val) = self {
3261                        fidl::decode!(
3262                            DetachCmd,
3263                            fidl::encoding::DefaultFuchsiaResourceDialect,
3264                            val,
3265                            decoder,
3266                            _inner_offset,
3267                            depth
3268                        )?;
3269                    } else {
3270                        unreachable!()
3271                    }
3272                }
3273                7 => {
3274                    #[allow(irrefutable_let_patterns)]
3275                    if let Command::SetTranslation(_) = self {
3276                        // Do nothing, read the value into the object
3277                    } else {
3278                        // Initialize `self` to the right variant
3279                        *self = Command::SetTranslation(fidl::new_empty!(
3280                            SetTranslationCmd,
3281                            fidl::encoding::DefaultFuchsiaResourceDialect
3282                        ));
3283                    }
3284                    #[allow(irrefutable_let_patterns)]
3285                    if let Command::SetTranslation(ref mut val) = self {
3286                        fidl::decode!(
3287                            SetTranslationCmd,
3288                            fidl::encoding::DefaultFuchsiaResourceDialect,
3289                            val,
3290                            decoder,
3291                            _inner_offset,
3292                            depth
3293                        )?;
3294                    } else {
3295                        unreachable!()
3296                    }
3297                }
3298                8 => {
3299                    #[allow(irrefutable_let_patterns)]
3300                    if let Command::SetScale(_) = self {
3301                        // Do nothing, read the value into the object
3302                    } else {
3303                        // Initialize `self` to the right variant
3304                        *self = Command::SetScale(fidl::new_empty!(
3305                            SetScaleCmd,
3306                            fidl::encoding::DefaultFuchsiaResourceDialect
3307                        ));
3308                    }
3309                    #[allow(irrefutable_let_patterns)]
3310                    if let Command::SetScale(ref mut val) = self {
3311                        fidl::decode!(
3312                            SetScaleCmd,
3313                            fidl::encoding::DefaultFuchsiaResourceDialect,
3314                            val,
3315                            decoder,
3316                            _inner_offset,
3317                            depth
3318                        )?;
3319                    } else {
3320                        unreachable!()
3321                    }
3322                }
3323                9 => {
3324                    #[allow(irrefutable_let_patterns)]
3325                    if let Command::SetRotation(_) = self {
3326                        // Do nothing, read the value into the object
3327                    } else {
3328                        // Initialize `self` to the right variant
3329                        *self = Command::SetRotation(fidl::new_empty!(
3330                            SetRotationCmd,
3331                            fidl::encoding::DefaultFuchsiaResourceDialect
3332                        ));
3333                    }
3334                    #[allow(irrefutable_let_patterns)]
3335                    if let Command::SetRotation(ref mut val) = self {
3336                        fidl::decode!(
3337                            SetRotationCmd,
3338                            fidl::encoding::DefaultFuchsiaResourceDialect,
3339                            val,
3340                            decoder,
3341                            _inner_offset,
3342                            depth
3343                        )?;
3344                    } else {
3345                        unreachable!()
3346                    }
3347                }
3348                10 => {
3349                    #[allow(irrefutable_let_patterns)]
3350                    if let Command::SetAnchor(_) = self {
3351                        // Do nothing, read the value into the object
3352                    } else {
3353                        // Initialize `self` to the right variant
3354                        *self = Command::SetAnchor(fidl::new_empty!(
3355                            SetAnchorCmd,
3356                            fidl::encoding::DefaultFuchsiaResourceDialect
3357                        ));
3358                    }
3359                    #[allow(irrefutable_let_patterns)]
3360                    if let Command::SetAnchor(ref mut val) = self {
3361                        fidl::decode!(
3362                            SetAnchorCmd,
3363                            fidl::encoding::DefaultFuchsiaResourceDialect,
3364                            val,
3365                            decoder,
3366                            _inner_offset,
3367                            depth
3368                        )?;
3369                    } else {
3370                        unreachable!()
3371                    }
3372                }
3373                11 => {
3374                    #[allow(irrefutable_let_patterns)]
3375                    if let Command::SetSize(_) = self {
3376                        // Do nothing, read the value into the object
3377                    } else {
3378                        // Initialize `self` to the right variant
3379                        *self = Command::SetSize(fidl::new_empty!(
3380                            SetSizeCmd,
3381                            fidl::encoding::DefaultFuchsiaResourceDialect
3382                        ));
3383                    }
3384                    #[allow(irrefutable_let_patterns)]
3385                    if let Command::SetSize(ref mut val) = self {
3386                        fidl::decode!(
3387                            SetSizeCmd,
3388                            fidl::encoding::DefaultFuchsiaResourceDialect,
3389                            val,
3390                            decoder,
3391                            _inner_offset,
3392                            depth
3393                        )?;
3394                    } else {
3395                        unreachable!()
3396                    }
3397                }
3398                12 => {
3399                    #[allow(irrefutable_let_patterns)]
3400                    if let Command::SetOpacity(_) = self {
3401                        // Do nothing, read the value into the object
3402                    } else {
3403                        // Initialize `self` to the right variant
3404                        *self = Command::SetOpacity(fidl::new_empty!(
3405                            SetOpacityCmd,
3406                            fidl::encoding::DefaultFuchsiaResourceDialect
3407                        ));
3408                    }
3409                    #[allow(irrefutable_let_patterns)]
3410                    if let Command::SetOpacity(ref mut val) = self {
3411                        fidl::decode!(
3412                            SetOpacityCmd,
3413                            fidl::encoding::DefaultFuchsiaResourceDialect,
3414                            val,
3415                            decoder,
3416                            _inner_offset,
3417                            depth
3418                        )?;
3419                    } else {
3420                        unreachable!()
3421                    }
3422                }
3423                13 => {
3424                    #[allow(irrefutable_let_patterns)]
3425                    if let Command::SendSizeChangeHintHack(_) = self {
3426                        // Do nothing, read the value into the object
3427                    } else {
3428                        // Initialize `self` to the right variant
3429                        *self = Command::SendSizeChangeHintHack(fidl::new_empty!(
3430                            SendSizeChangeHintCmdHack,
3431                            fidl::encoding::DefaultFuchsiaResourceDialect
3432                        ));
3433                    }
3434                    #[allow(irrefutable_let_patterns)]
3435                    if let Command::SendSizeChangeHintHack(ref mut val) = self {
3436                        fidl::decode!(
3437                            SendSizeChangeHintCmdHack,
3438                            fidl::encoding::DefaultFuchsiaResourceDialect,
3439                            val,
3440                            decoder,
3441                            _inner_offset,
3442                            depth
3443                        )?;
3444                    } else {
3445                        unreachable!()
3446                    }
3447                }
3448                14 => {
3449                    #[allow(irrefutable_let_patterns)]
3450                    if let Command::AddChild(_) = self {
3451                        // Do nothing, read the value into the object
3452                    } else {
3453                        // Initialize `self` to the right variant
3454                        *self = Command::AddChild(fidl::new_empty!(
3455                            AddChildCmd,
3456                            fidl::encoding::DefaultFuchsiaResourceDialect
3457                        ));
3458                    }
3459                    #[allow(irrefutable_let_patterns)]
3460                    if let Command::AddChild(ref mut val) = self {
3461                        fidl::decode!(
3462                            AddChildCmd,
3463                            fidl::encoding::DefaultFuchsiaResourceDialect,
3464                            val,
3465                            decoder,
3466                            _inner_offset,
3467                            depth
3468                        )?;
3469                    } else {
3470                        unreachable!()
3471                    }
3472                }
3473                15 => {
3474                    #[allow(irrefutable_let_patterns)]
3475                    if let Command::AddPart(_) = self {
3476                        // Do nothing, read the value into the object
3477                    } else {
3478                        // Initialize `self` to the right variant
3479                        *self = Command::AddPart(fidl::new_empty!(
3480                            AddPartCmd,
3481                            fidl::encoding::DefaultFuchsiaResourceDialect
3482                        ));
3483                    }
3484                    #[allow(irrefutable_let_patterns)]
3485                    if let Command::AddPart(ref mut val) = self {
3486                        fidl::decode!(
3487                            AddPartCmd,
3488                            fidl::encoding::DefaultFuchsiaResourceDialect,
3489                            val,
3490                            decoder,
3491                            _inner_offset,
3492                            depth
3493                        )?;
3494                    } else {
3495                        unreachable!()
3496                    }
3497                }
3498                16 => {
3499                    #[allow(irrefutable_let_patterns)]
3500                    if let Command::DetachChildren(_) = self {
3501                        // Do nothing, read the value into the object
3502                    } else {
3503                        // Initialize `self` to the right variant
3504                        *self = Command::DetachChildren(fidl::new_empty!(
3505                            DetachChildrenCmd,
3506                            fidl::encoding::DefaultFuchsiaResourceDialect
3507                        ));
3508                    }
3509                    #[allow(irrefutable_let_patterns)]
3510                    if let Command::DetachChildren(ref mut val) = self {
3511                        fidl::decode!(
3512                            DetachChildrenCmd,
3513                            fidl::encoding::DefaultFuchsiaResourceDialect,
3514                            val,
3515                            decoder,
3516                            _inner_offset,
3517                            depth
3518                        )?;
3519                    } else {
3520                        unreachable!()
3521                    }
3522                }
3523                17 => {
3524                    #[allow(irrefutable_let_patterns)]
3525                    if let Command::SetShape(_) = self {
3526                        // Do nothing, read the value into the object
3527                    } else {
3528                        // Initialize `self` to the right variant
3529                        *self = Command::SetShape(fidl::new_empty!(
3530                            SetShapeCmd,
3531                            fidl::encoding::DefaultFuchsiaResourceDialect
3532                        ));
3533                    }
3534                    #[allow(irrefutable_let_patterns)]
3535                    if let Command::SetShape(ref mut val) = self {
3536                        fidl::decode!(
3537                            SetShapeCmd,
3538                            fidl::encoding::DefaultFuchsiaResourceDialect,
3539                            val,
3540                            decoder,
3541                            _inner_offset,
3542                            depth
3543                        )?;
3544                    } else {
3545                        unreachable!()
3546                    }
3547                }
3548                18 => {
3549                    #[allow(irrefutable_let_patterns)]
3550                    if let Command::SetMaterial(_) = self {
3551                        // Do nothing, read the value into the object
3552                    } else {
3553                        // Initialize `self` to the right variant
3554                        *self = Command::SetMaterial(fidl::new_empty!(
3555                            SetMaterialCmd,
3556                            fidl::encoding::DefaultFuchsiaResourceDialect
3557                        ));
3558                    }
3559                    #[allow(irrefutable_let_patterns)]
3560                    if let Command::SetMaterial(ref mut val) = self {
3561                        fidl::decode!(
3562                            SetMaterialCmd,
3563                            fidl::encoding::DefaultFuchsiaResourceDialect,
3564                            val,
3565                            decoder,
3566                            _inner_offset,
3567                            depth
3568                        )?;
3569                    } else {
3570                        unreachable!()
3571                    }
3572                }
3573                19 => {
3574                    #[allow(irrefutable_let_patterns)]
3575                    if let Command::SetClip(_) = self {
3576                        // Do nothing, read the value into the object
3577                    } else {
3578                        // Initialize `self` to the right variant
3579                        *self = Command::SetClip(fidl::new_empty!(
3580                            SetClipCmd,
3581                            fidl::encoding::DefaultFuchsiaResourceDialect
3582                        ));
3583                    }
3584                    #[allow(irrefutable_let_patterns)]
3585                    if let Command::SetClip(ref mut val) = self {
3586                        fidl::decode!(
3587                            SetClipCmd,
3588                            fidl::encoding::DefaultFuchsiaResourceDialect,
3589                            val,
3590                            decoder,
3591                            _inner_offset,
3592                            depth
3593                        )?;
3594                    } else {
3595                        unreachable!()
3596                    }
3597                }
3598                20 => {
3599                    #[allow(irrefutable_let_patterns)]
3600                    if let Command::SetHitTestBehavior(_) = self {
3601                        // Do nothing, read the value into the object
3602                    } else {
3603                        // Initialize `self` to the right variant
3604                        *self = Command::SetHitTestBehavior(fidl::new_empty!(
3605                            SetHitTestBehaviorCmd,
3606                            fidl::encoding::DefaultFuchsiaResourceDialect
3607                        ));
3608                    }
3609                    #[allow(irrefutable_let_patterns)]
3610                    if let Command::SetHitTestBehavior(ref mut val) = self {
3611                        fidl::decode!(
3612                            SetHitTestBehaviorCmd,
3613                            fidl::encoding::DefaultFuchsiaResourceDialect,
3614                            val,
3615                            decoder,
3616                            _inner_offset,
3617                            depth
3618                        )?;
3619                    } else {
3620                        unreachable!()
3621                    }
3622                }
3623                21 => {
3624                    #[allow(irrefutable_let_patterns)]
3625                    if let Command::SetViewProperties(_) = self {
3626                        // Do nothing, read the value into the object
3627                    } else {
3628                        // Initialize `self` to the right variant
3629                        *self = Command::SetViewProperties(fidl::new_empty!(
3630                            SetViewPropertiesCmd,
3631                            fidl::encoding::DefaultFuchsiaResourceDialect
3632                        ));
3633                    }
3634                    #[allow(irrefutable_let_patterns)]
3635                    if let Command::SetViewProperties(ref mut val) = self {
3636                        fidl::decode!(
3637                            SetViewPropertiesCmd,
3638                            fidl::encoding::DefaultFuchsiaResourceDialect,
3639                            val,
3640                            decoder,
3641                            _inner_offset,
3642                            depth
3643                        )?;
3644                    } else {
3645                        unreachable!()
3646                    }
3647                }
3648                22 => {
3649                    #[allow(irrefutable_let_patterns)]
3650                    if let Command::TakeSnapshotCmd(_) = self {
3651                        // Do nothing, read the value into the object
3652                    } else {
3653                        // Initialize `self` to the right variant
3654                        *self = Command::TakeSnapshotCmd(fidl::new_empty!(
3655                            TakeSnapshotCmdDeprecated,
3656                            fidl::encoding::DefaultFuchsiaResourceDialect
3657                        ));
3658                    }
3659                    #[allow(irrefutable_let_patterns)]
3660                    if let Command::TakeSnapshotCmd(ref mut val) = self {
3661                        fidl::decode!(
3662                            TakeSnapshotCmdDeprecated,
3663                            fidl::encoding::DefaultFuchsiaResourceDialect,
3664                            val,
3665                            decoder,
3666                            _inner_offset,
3667                            depth
3668                        )?;
3669                    } else {
3670                        unreachable!()
3671                    }
3672                }
3673                23 => {
3674                    #[allow(irrefutable_let_patterns)]
3675                    if let Command::SetCamera(_) = self {
3676                        // Do nothing, read the value into the object
3677                    } else {
3678                        // Initialize `self` to the right variant
3679                        *self = Command::SetCamera(fidl::new_empty!(
3680                            SetCameraCmd,
3681                            fidl::encoding::DefaultFuchsiaResourceDialect
3682                        ));
3683                    }
3684                    #[allow(irrefutable_let_patterns)]
3685                    if let Command::SetCamera(ref mut val) = self {
3686                        fidl::decode!(
3687                            SetCameraCmd,
3688                            fidl::encoding::DefaultFuchsiaResourceDialect,
3689                            val,
3690                            decoder,
3691                            _inner_offset,
3692                            depth
3693                        )?;
3694                    } else {
3695                        unreachable!()
3696                    }
3697                }
3698                24 => {
3699                    #[allow(irrefutable_let_patterns)]
3700                    if let Command::SetCameraTransform(_) = self {
3701                        // Do nothing, read the value into the object
3702                    } else {
3703                        // Initialize `self` to the right variant
3704                        *self = Command::SetCameraTransform(fidl::new_empty!(
3705                            SetCameraTransformCmd,
3706                            fidl::encoding::DefaultFuchsiaResourceDialect
3707                        ));
3708                    }
3709                    #[allow(irrefutable_let_patterns)]
3710                    if let Command::SetCameraTransform(ref mut val) = self {
3711                        fidl::decode!(
3712                            SetCameraTransformCmd,
3713                            fidl::encoding::DefaultFuchsiaResourceDialect,
3714                            val,
3715                            decoder,
3716                            _inner_offset,
3717                            depth
3718                        )?;
3719                    } else {
3720                        unreachable!()
3721                    }
3722                }
3723                25 => {
3724                    #[allow(irrefutable_let_patterns)]
3725                    if let Command::SetCameraProjection(_) = self {
3726                        // Do nothing, read the value into the object
3727                    } else {
3728                        // Initialize `self` to the right variant
3729                        *self = Command::SetCameraProjection(fidl::new_empty!(
3730                            SetCameraProjectionCmd,
3731                            fidl::encoding::DefaultFuchsiaResourceDialect
3732                        ));
3733                    }
3734                    #[allow(irrefutable_let_patterns)]
3735                    if let Command::SetCameraProjection(ref mut val) = self {
3736                        fidl::decode!(
3737                            SetCameraProjectionCmd,
3738                            fidl::encoding::DefaultFuchsiaResourceDialect,
3739                            val,
3740                            decoder,
3741                            _inner_offset,
3742                            depth
3743                        )?;
3744                    } else {
3745                        unreachable!()
3746                    }
3747                }
3748                26 => {
3749                    #[allow(irrefutable_let_patterns)]
3750                    if let Command::SetStereoCameraProjection(_) = self {
3751                        // Do nothing, read the value into the object
3752                    } else {
3753                        // Initialize `self` to the right variant
3754                        *self = Command::SetStereoCameraProjection(fidl::new_empty!(
3755                            SetStereoCameraProjectionCmd,
3756                            fidl::encoding::DefaultFuchsiaResourceDialect
3757                        ));
3758                    }
3759                    #[allow(irrefutable_let_patterns)]
3760                    if let Command::SetStereoCameraProjection(ref mut val) = self {
3761                        fidl::decode!(
3762                            SetStereoCameraProjectionCmd,
3763                            fidl::encoding::DefaultFuchsiaResourceDialect,
3764                            val,
3765                            decoder,
3766                            _inner_offset,
3767                            depth
3768                        )?;
3769                    } else {
3770                        unreachable!()
3771                    }
3772                }
3773                27 => {
3774                    #[allow(irrefutable_let_patterns)]
3775                    if let Command::SetCameraPoseBuffer(_) = self {
3776                        // Do nothing, read the value into the object
3777                    } else {
3778                        // Initialize `self` to the right variant
3779                        *self = Command::SetCameraPoseBuffer(fidl::new_empty!(
3780                            SetCameraPoseBufferCmd,
3781                            fidl::encoding::DefaultFuchsiaResourceDialect
3782                        ));
3783                    }
3784                    #[allow(irrefutable_let_patterns)]
3785                    if let Command::SetCameraPoseBuffer(ref mut val) = self {
3786                        fidl::decode!(
3787                            SetCameraPoseBufferCmd,
3788                            fidl::encoding::DefaultFuchsiaResourceDialect,
3789                            val,
3790                            decoder,
3791                            _inner_offset,
3792                            depth
3793                        )?;
3794                    } else {
3795                        unreachable!()
3796                    }
3797                }
3798                28 => {
3799                    #[allow(irrefutable_let_patterns)]
3800                    if let Command::SetLightColor(_) = self {
3801                        // Do nothing, read the value into the object
3802                    } else {
3803                        // Initialize `self` to the right variant
3804                        *self = Command::SetLightColor(fidl::new_empty!(
3805                            SetLightColorCmd,
3806                            fidl::encoding::DefaultFuchsiaResourceDialect
3807                        ));
3808                    }
3809                    #[allow(irrefutable_let_patterns)]
3810                    if let Command::SetLightColor(ref mut val) = self {
3811                        fidl::decode!(
3812                            SetLightColorCmd,
3813                            fidl::encoding::DefaultFuchsiaResourceDialect,
3814                            val,
3815                            decoder,
3816                            _inner_offset,
3817                            depth
3818                        )?;
3819                    } else {
3820                        unreachable!()
3821                    }
3822                }
3823                29 => {
3824                    #[allow(irrefutable_let_patterns)]
3825                    if let Command::SetLightDirection(_) = self {
3826                        // Do nothing, read the value into the object
3827                    } else {
3828                        // Initialize `self` to the right variant
3829                        *self = Command::SetLightDirection(fidl::new_empty!(
3830                            SetLightDirectionCmd,
3831                            fidl::encoding::DefaultFuchsiaResourceDialect
3832                        ));
3833                    }
3834                    #[allow(irrefutable_let_patterns)]
3835                    if let Command::SetLightDirection(ref mut val) = self {
3836                        fidl::decode!(
3837                            SetLightDirectionCmd,
3838                            fidl::encoding::DefaultFuchsiaResourceDialect,
3839                            val,
3840                            decoder,
3841                            _inner_offset,
3842                            depth
3843                        )?;
3844                    } else {
3845                        unreachable!()
3846                    }
3847                }
3848                30 => {
3849                    #[allow(irrefutable_let_patterns)]
3850                    if let Command::AddLight(_) = self {
3851                        // Do nothing, read the value into the object
3852                    } else {
3853                        // Initialize `self` to the right variant
3854                        *self = Command::AddLight(fidl::new_empty!(
3855                            AddLightCmd,
3856                            fidl::encoding::DefaultFuchsiaResourceDialect
3857                        ));
3858                    }
3859                    #[allow(irrefutable_let_patterns)]
3860                    if let Command::AddLight(ref mut val) = self {
3861                        fidl::decode!(
3862                            AddLightCmd,
3863                            fidl::encoding::DefaultFuchsiaResourceDialect,
3864                            val,
3865                            decoder,
3866                            _inner_offset,
3867                            depth
3868                        )?;
3869                    } else {
3870                        unreachable!()
3871                    }
3872                }
3873                31 => {
3874                    #[allow(irrefutable_let_patterns)]
3875                    if let Command::DetachLight(_) = self {
3876                        // Do nothing, read the value into the object
3877                    } else {
3878                        // Initialize `self` to the right variant
3879                        *self = Command::DetachLight(fidl::new_empty!(
3880                            DetachLightCmd,
3881                            fidl::encoding::DefaultFuchsiaResourceDialect
3882                        ));
3883                    }
3884                    #[allow(irrefutable_let_patterns)]
3885                    if let Command::DetachLight(ref mut val) = self {
3886                        fidl::decode!(
3887                            DetachLightCmd,
3888                            fidl::encoding::DefaultFuchsiaResourceDialect,
3889                            val,
3890                            decoder,
3891                            _inner_offset,
3892                            depth
3893                        )?;
3894                    } else {
3895                        unreachable!()
3896                    }
3897                }
3898                32 => {
3899                    #[allow(irrefutable_let_patterns)]
3900                    if let Command::DetachLights(_) = self {
3901                        // Do nothing, read the value into the object
3902                    } else {
3903                        // Initialize `self` to the right variant
3904                        *self = Command::DetachLights(fidl::new_empty!(
3905                            DetachLightsCmd,
3906                            fidl::encoding::DefaultFuchsiaResourceDialect
3907                        ));
3908                    }
3909                    #[allow(irrefutable_let_patterns)]
3910                    if let Command::DetachLights(ref mut val) = self {
3911                        fidl::decode!(
3912                            DetachLightsCmd,
3913                            fidl::encoding::DefaultFuchsiaResourceDialect,
3914                            val,
3915                            decoder,
3916                            _inner_offset,
3917                            depth
3918                        )?;
3919                    } else {
3920                        unreachable!()
3921                    }
3922                }
3923                33 => {
3924                    #[allow(irrefutable_let_patterns)]
3925                    if let Command::SetTexture(_) = self {
3926                        // Do nothing, read the value into the object
3927                    } else {
3928                        // Initialize `self` to the right variant
3929                        *self = Command::SetTexture(fidl::new_empty!(
3930                            SetTextureCmd,
3931                            fidl::encoding::DefaultFuchsiaResourceDialect
3932                        ));
3933                    }
3934                    #[allow(irrefutable_let_patterns)]
3935                    if let Command::SetTexture(ref mut val) = self {
3936                        fidl::decode!(
3937                            SetTextureCmd,
3938                            fidl::encoding::DefaultFuchsiaResourceDialect,
3939                            val,
3940                            decoder,
3941                            _inner_offset,
3942                            depth
3943                        )?;
3944                    } else {
3945                        unreachable!()
3946                    }
3947                }
3948                34 => {
3949                    #[allow(irrefutable_let_patterns)]
3950                    if let Command::SetColor(_) = self {
3951                        // Do nothing, read the value into the object
3952                    } else {
3953                        // Initialize `self` to the right variant
3954                        *self = Command::SetColor(fidl::new_empty!(
3955                            SetColorCmd,
3956                            fidl::encoding::DefaultFuchsiaResourceDialect
3957                        ));
3958                    }
3959                    #[allow(irrefutable_let_patterns)]
3960                    if let Command::SetColor(ref mut val) = self {
3961                        fidl::decode!(
3962                            SetColorCmd,
3963                            fidl::encoding::DefaultFuchsiaResourceDialect,
3964                            val,
3965                            decoder,
3966                            _inner_offset,
3967                            depth
3968                        )?;
3969                    } else {
3970                        unreachable!()
3971                    }
3972                }
3973                35 => {
3974                    #[allow(irrefutable_let_patterns)]
3975                    if let Command::BindMeshBuffers(_) = self {
3976                        // Do nothing, read the value into the object
3977                    } else {
3978                        // Initialize `self` to the right variant
3979                        *self = Command::BindMeshBuffers(fidl::new_empty!(
3980                            BindMeshBuffersCmd,
3981                            fidl::encoding::DefaultFuchsiaResourceDialect
3982                        ));
3983                    }
3984                    #[allow(irrefutable_let_patterns)]
3985                    if let Command::BindMeshBuffers(ref mut val) = self {
3986                        fidl::decode!(
3987                            BindMeshBuffersCmd,
3988                            fidl::encoding::DefaultFuchsiaResourceDialect,
3989                            val,
3990                            decoder,
3991                            _inner_offset,
3992                            depth
3993                        )?;
3994                    } else {
3995                        unreachable!()
3996                    }
3997                }
3998                36 => {
3999                    #[allow(irrefutable_let_patterns)]
4000                    if let Command::AddLayer(_) = self {
4001                        // Do nothing, read the value into the object
4002                    } else {
4003                        // Initialize `self` to the right variant
4004                        *self = Command::AddLayer(fidl::new_empty!(
4005                            AddLayerCmd,
4006                            fidl::encoding::DefaultFuchsiaResourceDialect
4007                        ));
4008                    }
4009                    #[allow(irrefutable_let_patterns)]
4010                    if let Command::AddLayer(ref mut val) = self {
4011                        fidl::decode!(
4012                            AddLayerCmd,
4013                            fidl::encoding::DefaultFuchsiaResourceDialect,
4014                            val,
4015                            decoder,
4016                            _inner_offset,
4017                            depth
4018                        )?;
4019                    } else {
4020                        unreachable!()
4021                    }
4022                }
4023                37 => {
4024                    #[allow(irrefutable_let_patterns)]
4025                    if let Command::RemoveLayer(_) = self {
4026                        // Do nothing, read the value into the object
4027                    } else {
4028                        // Initialize `self` to the right variant
4029                        *self = Command::RemoveLayer(fidl::new_empty!(
4030                            RemoveLayerCmd,
4031                            fidl::encoding::DefaultFuchsiaResourceDialect
4032                        ));
4033                    }
4034                    #[allow(irrefutable_let_patterns)]
4035                    if let Command::RemoveLayer(ref mut val) = self {
4036                        fidl::decode!(
4037                            RemoveLayerCmd,
4038                            fidl::encoding::DefaultFuchsiaResourceDialect,
4039                            val,
4040                            decoder,
4041                            _inner_offset,
4042                            depth
4043                        )?;
4044                    } else {
4045                        unreachable!()
4046                    }
4047                }
4048                38 => {
4049                    #[allow(irrefutable_let_patterns)]
4050                    if let Command::RemoveAllLayers(_) = self {
4051                        // Do nothing, read the value into the object
4052                    } else {
4053                        // Initialize `self` to the right variant
4054                        *self = Command::RemoveAllLayers(fidl::new_empty!(
4055                            RemoveAllLayersCmd,
4056                            fidl::encoding::DefaultFuchsiaResourceDialect
4057                        ));
4058                    }
4059                    #[allow(irrefutable_let_patterns)]
4060                    if let Command::RemoveAllLayers(ref mut val) = self {
4061                        fidl::decode!(
4062                            RemoveAllLayersCmd,
4063                            fidl::encoding::DefaultFuchsiaResourceDialect,
4064                            val,
4065                            decoder,
4066                            _inner_offset,
4067                            depth
4068                        )?;
4069                    } else {
4070                        unreachable!()
4071                    }
4072                }
4073                39 => {
4074                    #[allow(irrefutable_let_patterns)]
4075                    if let Command::SetLayerStack(_) = self {
4076                        // Do nothing, read the value into the object
4077                    } else {
4078                        // Initialize `self` to the right variant
4079                        *self = Command::SetLayerStack(fidl::new_empty!(
4080                            SetLayerStackCmd,
4081                            fidl::encoding::DefaultFuchsiaResourceDialect
4082                        ));
4083                    }
4084                    #[allow(irrefutable_let_patterns)]
4085                    if let Command::SetLayerStack(ref mut val) = self {
4086                        fidl::decode!(
4087                            SetLayerStackCmd,
4088                            fidl::encoding::DefaultFuchsiaResourceDialect,
4089                            val,
4090                            decoder,
4091                            _inner_offset,
4092                            depth
4093                        )?;
4094                    } else {
4095                        unreachable!()
4096                    }
4097                }
4098                40 => {
4099                    #[allow(irrefutable_let_patterns)]
4100                    if let Command::SetRenderer(_) = self {
4101                        // Do nothing, read the value into the object
4102                    } else {
4103                        // Initialize `self` to the right variant
4104                        *self = Command::SetRenderer(fidl::new_empty!(
4105                            SetRendererCmd,
4106                            fidl::encoding::DefaultFuchsiaResourceDialect
4107                        ));
4108                    }
4109                    #[allow(irrefutable_let_patterns)]
4110                    if let Command::SetRenderer(ref mut val) = self {
4111                        fidl::decode!(
4112                            SetRendererCmd,
4113                            fidl::encoding::DefaultFuchsiaResourceDialect,
4114                            val,
4115                            decoder,
4116                            _inner_offset,
4117                            depth
4118                        )?;
4119                    } else {
4120                        unreachable!()
4121                    }
4122                }
4123                41 => {
4124                    #[allow(irrefutable_let_patterns)]
4125                    if let Command::SetRendererParam(_) = self {
4126                        // Do nothing, read the value into the object
4127                    } else {
4128                        // Initialize `self` to the right variant
4129                        *self = Command::SetRendererParam(fidl::new_empty!(
4130                            SetRendererParamCmd,
4131                            fidl::encoding::DefaultFuchsiaResourceDialect
4132                        ));
4133                    }
4134                    #[allow(irrefutable_let_patterns)]
4135                    if let Command::SetRendererParam(ref mut val) = self {
4136                        fidl::decode!(
4137                            SetRendererParamCmd,
4138                            fidl::encoding::DefaultFuchsiaResourceDialect,
4139                            val,
4140                            decoder,
4141                            _inner_offset,
4142                            depth
4143                        )?;
4144                    } else {
4145                        unreachable!()
4146                    }
4147                }
4148                42 => {
4149                    #[allow(irrefutable_let_patterns)]
4150                    if let Command::SetEventMask(_) = self {
4151                        // Do nothing, read the value into the object
4152                    } else {
4153                        // Initialize `self` to the right variant
4154                        *self = Command::SetEventMask(fidl::new_empty!(
4155                            SetEventMaskCmd,
4156                            fidl::encoding::DefaultFuchsiaResourceDialect
4157                        ));
4158                    }
4159                    #[allow(irrefutable_let_patterns)]
4160                    if let Command::SetEventMask(ref mut val) = self {
4161                        fidl::decode!(
4162                            SetEventMaskCmd,
4163                            fidl::encoding::DefaultFuchsiaResourceDialect,
4164                            val,
4165                            decoder,
4166                            _inner_offset,
4167                            depth
4168                        )?;
4169                    } else {
4170                        unreachable!()
4171                    }
4172                }
4173                43 => {
4174                    #[allow(irrefutable_let_patterns)]
4175                    if let Command::SetLabel(_) = self {
4176                        // Do nothing, read the value into the object
4177                    } else {
4178                        // Initialize `self` to the right variant
4179                        *self = Command::SetLabel(fidl::new_empty!(
4180                            SetLabelCmd,
4181                            fidl::encoding::DefaultFuchsiaResourceDialect
4182                        ));
4183                    }
4184                    #[allow(irrefutable_let_patterns)]
4185                    if let Command::SetLabel(ref mut val) = self {
4186                        fidl::decode!(
4187                            SetLabelCmd,
4188                            fidl::encoding::DefaultFuchsiaResourceDialect,
4189                            val,
4190                            decoder,
4191                            _inner_offset,
4192                            depth
4193                        )?;
4194                    } else {
4195                        unreachable!()
4196                    }
4197                }
4198                44 => {
4199                    #[allow(irrefutable_let_patterns)]
4200                    if let Command::SetDisableClipping(_) = self {
4201                        // Do nothing, read the value into the object
4202                    } else {
4203                        // Initialize `self` to the right variant
4204                        *self = Command::SetDisableClipping(fidl::new_empty!(
4205                            SetDisableClippingCmd,
4206                            fidl::encoding::DefaultFuchsiaResourceDialect
4207                        ));
4208                    }
4209                    #[allow(irrefutable_let_patterns)]
4210                    if let Command::SetDisableClipping(ref mut val) = self {
4211                        fidl::decode!(
4212                            SetDisableClippingCmd,
4213                            fidl::encoding::DefaultFuchsiaResourceDialect,
4214                            val,
4215                            decoder,
4216                            _inner_offset,
4217                            depth
4218                        )?;
4219                    } else {
4220                        unreachable!()
4221                    }
4222                }
4223                45 => {
4224                    #[allow(irrefutable_let_patterns)]
4225                    if let Command::SetImportFocus(_) = self {
4226                        // Do nothing, read the value into the object
4227                    } else {
4228                        // Initialize `self` to the right variant
4229                        *self = Command::SetImportFocus(fidl::new_empty!(
4230                            SetImportFocusCmdDeprecated,
4231                            fidl::encoding::DefaultFuchsiaResourceDialect
4232                        ));
4233                    }
4234                    #[allow(irrefutable_let_patterns)]
4235                    if let Command::SetImportFocus(ref mut val) = self {
4236                        fidl::decode!(
4237                            SetImportFocusCmdDeprecated,
4238                            fidl::encoding::DefaultFuchsiaResourceDialect,
4239                            val,
4240                            decoder,
4241                            _inner_offset,
4242                            depth
4243                        )?;
4244                    } else {
4245                        unreachable!()
4246                    }
4247                }
4248                46 => {
4249                    #[allow(irrefutable_let_patterns)]
4250                    if let Command::SetClipPlanes(_) = self {
4251                        // Do nothing, read the value into the object
4252                    } else {
4253                        // Initialize `self` to the right variant
4254                        *self = Command::SetClipPlanes(fidl::new_empty!(
4255                            SetClipPlanesCmd,
4256                            fidl::encoding::DefaultFuchsiaResourceDialect
4257                        ));
4258                    }
4259                    #[allow(irrefutable_let_patterns)]
4260                    if let Command::SetClipPlanes(ref mut val) = self {
4261                        fidl::decode!(
4262                            SetClipPlanesCmd,
4263                            fidl::encoding::DefaultFuchsiaResourceDialect,
4264                            val,
4265                            decoder,
4266                            _inner_offset,
4267                            depth
4268                        )?;
4269                    } else {
4270                        unreachable!()
4271                    }
4272                }
4273                47 => {
4274                    #[allow(irrefutable_let_patterns)]
4275                    if let Command::SetPointLightPosition(_) = self {
4276                        // Do nothing, read the value into the object
4277                    } else {
4278                        // Initialize `self` to the right variant
4279                        *self = Command::SetPointLightPosition(fidl::new_empty!(
4280                            SetPointLightPositionCmd,
4281                            fidl::encoding::DefaultFuchsiaResourceDialect
4282                        ));
4283                    }
4284                    #[allow(irrefutable_let_patterns)]
4285                    if let Command::SetPointLightPosition(ref mut val) = self {
4286                        fidl::decode!(
4287                            SetPointLightPositionCmd,
4288                            fidl::encoding::DefaultFuchsiaResourceDialect,
4289                            val,
4290                            decoder,
4291                            _inner_offset,
4292                            depth
4293                        )?;
4294                    } else {
4295                        unreachable!()
4296                    }
4297                }
4298                48 => {
4299                    #[allow(irrefutable_let_patterns)]
4300                    if let Command::SetPointLightFalloff(_) = self {
4301                        // Do nothing, read the value into the object
4302                    } else {
4303                        // Initialize `self` to the right variant
4304                        *self = Command::SetPointLightFalloff(fidl::new_empty!(
4305                            SetPointLightFalloffCmd,
4306                            fidl::encoding::DefaultFuchsiaResourceDialect
4307                        ));
4308                    }
4309                    #[allow(irrefutable_let_patterns)]
4310                    if let Command::SetPointLightFalloff(ref mut val) = self {
4311                        fidl::decode!(
4312                            SetPointLightFalloffCmd,
4313                            fidl::encoding::DefaultFuchsiaResourceDialect,
4314                            val,
4315                            decoder,
4316                            _inner_offset,
4317                            depth
4318                        )?;
4319                    } else {
4320                        unreachable!()
4321                    }
4322                }
4323                49 => {
4324                    #[allow(irrefutable_let_patterns)]
4325                    if let Command::Scene_AddAmbientLight(_) = self {
4326                        // Do nothing, read the value into the object
4327                    } else {
4328                        // Initialize `self` to the right variant
4329                        *self = Command::Scene_AddAmbientLight(fidl::new_empty!(
4330                            SceneAddAmbientLightCmd,
4331                            fidl::encoding::DefaultFuchsiaResourceDialect
4332                        ));
4333                    }
4334                    #[allow(irrefutable_let_patterns)]
4335                    if let Command::Scene_AddAmbientLight(ref mut val) = self {
4336                        fidl::decode!(
4337                            SceneAddAmbientLightCmd,
4338                            fidl::encoding::DefaultFuchsiaResourceDialect,
4339                            val,
4340                            decoder,
4341                            _inner_offset,
4342                            depth
4343                        )?;
4344                    } else {
4345                        unreachable!()
4346                    }
4347                }
4348                50 => {
4349                    #[allow(irrefutable_let_patterns)]
4350                    if let Command::Scene_AddDirectionalLight(_) = self {
4351                        // Do nothing, read the value into the object
4352                    } else {
4353                        // Initialize `self` to the right variant
4354                        *self = Command::Scene_AddDirectionalLight(fidl::new_empty!(
4355                            SceneAddDirectionalLightCmd,
4356                            fidl::encoding::DefaultFuchsiaResourceDialect
4357                        ));
4358                    }
4359                    #[allow(irrefutable_let_patterns)]
4360                    if let Command::Scene_AddDirectionalLight(ref mut val) = self {
4361                        fidl::decode!(
4362                            SceneAddDirectionalLightCmd,
4363                            fidl::encoding::DefaultFuchsiaResourceDialect,
4364                            val,
4365                            decoder,
4366                            _inner_offset,
4367                            depth
4368                        )?;
4369                    } else {
4370                        unreachable!()
4371                    }
4372                }
4373                51 => {
4374                    #[allow(irrefutable_let_patterns)]
4375                    if let Command::Scene_AddPointLight(_) = self {
4376                        // Do nothing, read the value into the object
4377                    } else {
4378                        // Initialize `self` to the right variant
4379                        *self = Command::Scene_AddPointLight(fidl::new_empty!(
4380                            SceneAddPointLightCmd,
4381                            fidl::encoding::DefaultFuchsiaResourceDialect
4382                        ));
4383                    }
4384                    #[allow(irrefutable_let_patterns)]
4385                    if let Command::Scene_AddPointLight(ref mut val) = self {
4386                        fidl::decode!(
4387                            SceneAddPointLightCmd,
4388                            fidl::encoding::DefaultFuchsiaResourceDialect,
4389                            val,
4390                            decoder,
4391                            _inner_offset,
4392                            depth
4393                        )?;
4394                    } else {
4395                        unreachable!()
4396                    }
4397                }
4398                52 => {
4399                    #[allow(irrefutable_let_patterns)]
4400                    if let Command::SetDisplayColorConversion(_) = self {
4401                        // Do nothing, read the value into the object
4402                    } else {
4403                        // Initialize `self` to the right variant
4404                        *self = Command::SetDisplayColorConversion(fidl::new_empty!(
4405                            SetDisplayColorConversionCmdHack,
4406                            fidl::encoding::DefaultFuchsiaResourceDialect
4407                        ));
4408                    }
4409                    #[allow(irrefutable_let_patterns)]
4410                    if let Command::SetDisplayColorConversion(ref mut val) = self {
4411                        fidl::decode!(
4412                            SetDisplayColorConversionCmdHack,
4413                            fidl::encoding::DefaultFuchsiaResourceDialect,
4414                            val,
4415                            decoder,
4416                            _inner_offset,
4417                            depth
4418                        )?;
4419                    } else {
4420                        unreachable!()
4421                    }
4422                }
4423                53 => {
4424                    #[allow(irrefutable_let_patterns)]
4425                    if let Command::SetDisplayRotation(_) = self {
4426                        // Do nothing, read the value into the object
4427                    } else {
4428                        // Initialize `self` to the right variant
4429                        *self = Command::SetDisplayRotation(fidl::new_empty!(
4430                            SetDisplayRotationCmdHack,
4431                            fidl::encoding::DefaultFuchsiaResourceDialect
4432                        ));
4433                    }
4434                    #[allow(irrefutable_let_patterns)]
4435                    if let Command::SetDisplayRotation(ref mut val) = self {
4436                        fidl::decode!(
4437                            SetDisplayRotationCmdHack,
4438                            fidl::encoding::DefaultFuchsiaResourceDialect,
4439                            val,
4440                            decoder,
4441                            _inner_offset,
4442                            depth
4443                        )?;
4444                    } else {
4445                        unreachable!()
4446                    }
4447                }
4448                54 => {
4449                    #[allow(irrefutable_let_patterns)]
4450                    if let Command::SetEnableViewDebugBounds(_) = self {
4451                        // Do nothing, read the value into the object
4452                    } else {
4453                        // Initialize `self` to the right variant
4454                        *self = Command::SetEnableViewDebugBounds(fidl::new_empty!(
4455                            SetEnableDebugViewBoundsCmd,
4456                            fidl::encoding::DefaultFuchsiaResourceDialect
4457                        ));
4458                    }
4459                    #[allow(irrefutable_let_patterns)]
4460                    if let Command::SetEnableViewDebugBounds(ref mut val) = self {
4461                        fidl::decode!(
4462                            SetEnableDebugViewBoundsCmd,
4463                            fidl::encoding::DefaultFuchsiaResourceDialect,
4464                            val,
4465                            decoder,
4466                            _inner_offset,
4467                            depth
4468                        )?;
4469                    } else {
4470                        unreachable!()
4471                    }
4472                }
4473                55 => {
4474                    #[allow(irrefutable_let_patterns)]
4475                    if let Command::SetViewHolderBoundsColor(_) = self {
4476                        // Do nothing, read the value into the object
4477                    } else {
4478                        // Initialize `self` to the right variant
4479                        *self = Command::SetViewHolderBoundsColor(fidl::new_empty!(
4480                            SetViewHolderBoundsColorCmd,
4481                            fidl::encoding::DefaultFuchsiaResourceDialect
4482                        ));
4483                    }
4484                    #[allow(irrefutable_let_patterns)]
4485                    if let Command::SetViewHolderBoundsColor(ref mut val) = self {
4486                        fidl::decode!(
4487                            SetViewHolderBoundsColorCmd,
4488                            fidl::encoding::DefaultFuchsiaResourceDialect,
4489                            val,
4490                            decoder,
4491                            _inner_offset,
4492                            depth
4493                        )?;
4494                    } else {
4495                        unreachable!()
4496                    }
4497                }
4498                56 => {
4499                    #[allow(irrefutable_let_patterns)]
4500                    if let Command::SetCameraClipSpaceTransform(_) = self {
4501                        // Do nothing, read the value into the object
4502                    } else {
4503                        // Initialize `self` to the right variant
4504                        *self = Command::SetCameraClipSpaceTransform(fidl::new_empty!(
4505                            SetCameraClipSpaceTransformCmd,
4506                            fidl::encoding::DefaultFuchsiaResourceDialect
4507                        ));
4508                    }
4509                    #[allow(irrefutable_let_patterns)]
4510                    if let Command::SetCameraClipSpaceTransform(ref mut val) = self {
4511                        fidl::decode!(
4512                            SetCameraClipSpaceTransformCmd,
4513                            fidl::encoding::DefaultFuchsiaResourceDialect,
4514                            val,
4515                            decoder,
4516                            _inner_offset,
4517                            depth
4518                        )?;
4519                    } else {
4520                        unreachable!()
4521                    }
4522                }
4523                57 => {
4524                    #[allow(irrefutable_let_patterns)]
4525                    if let Command::SetDisplayMinimumRgb(_) = self {
4526                        // Do nothing, read the value into the object
4527                    } else {
4528                        // Initialize `self` to the right variant
4529                        *self = Command::SetDisplayMinimumRgb(fidl::new_empty!(
4530                            SetDisplayMinimumRgbCmdHack,
4531                            fidl::encoding::DefaultFuchsiaResourceDialect
4532                        ));
4533                    }
4534                    #[allow(irrefutable_let_patterns)]
4535                    if let Command::SetDisplayMinimumRgb(ref mut val) = self {
4536                        fidl::decode!(
4537                            SetDisplayMinimumRgbCmdHack,
4538                            fidl::encoding::DefaultFuchsiaResourceDialect,
4539                            val,
4540                            decoder,
4541                            _inner_offset,
4542                            depth
4543                        )?;
4544                    } else {
4545                        unreachable!()
4546                    }
4547                }
4548                58 => {
4549                    #[allow(irrefutable_let_patterns)]
4550                    if let Command::SetSemanticVisibility(_) = self {
4551                        // Do nothing, read the value into the object
4552                    } else {
4553                        // Initialize `self` to the right variant
4554                        *self = Command::SetSemanticVisibility(fidl::new_empty!(
4555                            SetSemanticVisibilityCmd,
4556                            fidl::encoding::DefaultFuchsiaResourceDialect
4557                        ));
4558                    }
4559                    #[allow(irrefutable_let_patterns)]
4560                    if let Command::SetSemanticVisibility(ref mut val) = self {
4561                        fidl::decode!(
4562                            SetSemanticVisibilityCmd,
4563                            fidl::encoding::DefaultFuchsiaResourceDialect,
4564                            val,
4565                            decoder,
4566                            _inner_offset,
4567                            depth
4568                        )?;
4569                    } else {
4570                        unreachable!()
4571                    }
4572                }
4573                ordinal => panic!("unexpected ordinal {:?}", ordinal),
4574            }
4575            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4576                return Err(fidl::Error::InvalidNumBytesInEnvelope);
4577            }
4578            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4579                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4580            }
4581            Ok(())
4582        }
4583    }
4584
4585    impl fidl::encoding::ResourceTypeMarker for ResourceArgs {
4586        type Borrowed<'a> = &'a mut Self;
4587        fn take_or_borrow<'a>(
4588            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4589        ) -> Self::Borrowed<'a> {
4590            value
4591        }
4592    }
4593
4594    unsafe impl fidl::encoding::TypeMarker for ResourceArgs {
4595        type Owned = Self;
4596
4597        #[inline(always)]
4598        fn inline_align(_context: fidl::encoding::Context) -> usize {
4599            8
4600        }
4601
4602        #[inline(always)]
4603        fn inline_size(_context: fidl::encoding::Context) -> usize {
4604            16
4605        }
4606    }
4607
4608    unsafe impl fidl::encoding::Encode<ResourceArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
4609        for &mut ResourceArgs
4610    {
4611        #[inline]
4612        unsafe fn encode(
4613            self,
4614            encoder: &mut fidl::encoding::Encoder<
4615                '_,
4616                fidl::encoding::DefaultFuchsiaResourceDialect,
4617            >,
4618            offset: usize,
4619            _depth: fidl::encoding::Depth,
4620        ) -> fidl::Result<()> {
4621            encoder.debug_check_bounds::<ResourceArgs>(offset);
4622            encoder.write_num::<u64>(self.ordinal(), offset);
4623            match self {
4624                ResourceArgs::Memory(ref mut val) => fidl::encoding::encode_in_envelope::<
4625                    MemoryArgs,
4626                    fidl::encoding::DefaultFuchsiaResourceDialect,
4627                >(
4628                    <MemoryArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
4629                    encoder,
4630                    offset + 8,
4631                    _depth,
4632                ),
4633                ResourceArgs::Image(ref val) => fidl::encoding::encode_in_envelope::<
4634                    ImageArgs,
4635                    fidl::encoding::DefaultFuchsiaResourceDialect,
4636                >(
4637                    <ImageArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4638                    encoder,
4639                    offset + 8,
4640                    _depth,
4641                ),
4642                ResourceArgs::Buffer(ref val) => fidl::encoding::encode_in_envelope::<
4643                    BufferArgs,
4644                    fidl::encoding::DefaultFuchsiaResourceDialect,
4645                >(
4646                    <BufferArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4647                    encoder,
4648                    offset + 8,
4649                    _depth,
4650                ),
4651                ResourceArgs::View(ref mut val) => fidl::encoding::encode_in_envelope::<
4652                    ViewArgs,
4653                    fidl::encoding::DefaultFuchsiaResourceDialect,
4654                >(
4655                    <ViewArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
4656                    encoder,
4657                    offset + 8,
4658                    _depth,
4659                ),
4660                ResourceArgs::ViewHolder(ref mut val) => fidl::encoding::encode_in_envelope::<
4661                    ViewHolderArgs,
4662                    fidl::encoding::DefaultFuchsiaResourceDialect,
4663                >(
4664                    <ViewHolderArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
4665                    encoder,
4666                    offset + 8,
4667                    _depth,
4668                ),
4669                ResourceArgs::Rectangle(ref val) => fidl::encoding::encode_in_envelope::<
4670                    RectangleArgs,
4671                    fidl::encoding::DefaultFuchsiaResourceDialect,
4672                >(
4673                    <RectangleArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4674                    encoder,
4675                    offset + 8,
4676                    _depth,
4677                ),
4678                ResourceArgs::RoundedRectangle(ref val) => fidl::encoding::encode_in_envelope::<
4679                    RoundedRectangleArgs,
4680                    fidl::encoding::DefaultFuchsiaResourceDialect,
4681                >(
4682                    <RoundedRectangleArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4683                    encoder,
4684                    offset + 8,
4685                    _depth,
4686                ),
4687                ResourceArgs::Circle(ref val) => fidl::encoding::encode_in_envelope::<
4688                    CircleArgs,
4689                    fidl::encoding::DefaultFuchsiaResourceDialect,
4690                >(
4691                    <CircleArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4692                    encoder,
4693                    offset + 8,
4694                    _depth,
4695                ),
4696                ResourceArgs::Mesh(ref val) => fidl::encoding::encode_in_envelope::<
4697                    MeshArgs,
4698                    fidl::encoding::DefaultFuchsiaResourceDialect,
4699                >(
4700                    <MeshArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4701                    encoder,
4702                    offset + 8,
4703                    _depth,
4704                ),
4705                ResourceArgs::ShapeNode(ref val) => fidl::encoding::encode_in_envelope::<
4706                    ShapeNodeArgs,
4707                    fidl::encoding::DefaultFuchsiaResourceDialect,
4708                >(
4709                    <ShapeNodeArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4710                    encoder,
4711                    offset + 8,
4712                    _depth,
4713                ),
4714                ResourceArgs::ClipNode(ref val) => fidl::encoding::encode_in_envelope::<
4715                    ClipNodeArgs,
4716                    fidl::encoding::DefaultFuchsiaResourceDialect,
4717                >(
4718                    <ClipNodeArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4719                    encoder,
4720                    offset + 8,
4721                    _depth,
4722                ),
4723                ResourceArgs::EntityNode(ref val) => fidl::encoding::encode_in_envelope::<
4724                    EntityNodeArgs,
4725                    fidl::encoding::DefaultFuchsiaResourceDialect,
4726                >(
4727                    <EntityNodeArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4728                    encoder,
4729                    offset + 8,
4730                    _depth,
4731                ),
4732                ResourceArgs::OpacityNode(ref val) => fidl::encoding::encode_in_envelope::<
4733                    OpacityNodeArgsHack,
4734                    fidl::encoding::DefaultFuchsiaResourceDialect,
4735                >(
4736                    <OpacityNodeArgsHack as fidl::encoding::ValueTypeMarker>::borrow(val),
4737                    encoder,
4738                    offset + 8,
4739                    _depth,
4740                ),
4741                ResourceArgs::Material(ref val) => fidl::encoding::encode_in_envelope::<
4742                    MaterialArgs,
4743                    fidl::encoding::DefaultFuchsiaResourceDialect,
4744                >(
4745                    <MaterialArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4746                    encoder,
4747                    offset + 8,
4748                    _depth,
4749                ),
4750                ResourceArgs::Compositor(ref val) => fidl::encoding::encode_in_envelope::<
4751                    CompositorArgs,
4752                    fidl::encoding::DefaultFuchsiaResourceDialect,
4753                >(
4754                    <CompositorArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4755                    encoder,
4756                    offset + 8,
4757                    _depth,
4758                ),
4759                ResourceArgs::DisplayCompositor(ref val) => fidl::encoding::encode_in_envelope::<
4760                    DisplayCompositorArgs,
4761                    fidl::encoding::DefaultFuchsiaResourceDialect,
4762                >(
4763                    <DisplayCompositorArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4764                    encoder,
4765                    offset + 8,
4766                    _depth,
4767                ),
4768                ResourceArgs::LayerStack(ref val) => fidl::encoding::encode_in_envelope::<
4769                    LayerStackArgs,
4770                    fidl::encoding::DefaultFuchsiaResourceDialect,
4771                >(
4772                    <LayerStackArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4773                    encoder,
4774                    offset + 8,
4775                    _depth,
4776                ),
4777                ResourceArgs::Layer(ref val) => fidl::encoding::encode_in_envelope::<
4778                    LayerArgs,
4779                    fidl::encoding::DefaultFuchsiaResourceDialect,
4780                >(
4781                    <LayerArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4782                    encoder,
4783                    offset + 8,
4784                    _depth,
4785                ),
4786                ResourceArgs::Scene(ref val) => fidl::encoding::encode_in_envelope::<
4787                    SceneArgs,
4788                    fidl::encoding::DefaultFuchsiaResourceDialect,
4789                >(
4790                    <SceneArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4791                    encoder,
4792                    offset + 8,
4793                    _depth,
4794                ),
4795                ResourceArgs::Camera(ref val) => fidl::encoding::encode_in_envelope::<
4796                    CameraArgs,
4797                    fidl::encoding::DefaultFuchsiaResourceDialect,
4798                >(
4799                    <CameraArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4800                    encoder,
4801                    offset + 8,
4802                    _depth,
4803                ),
4804                ResourceArgs::StereoCamera(ref val) => fidl::encoding::encode_in_envelope::<
4805                    StereoCameraArgs,
4806                    fidl::encoding::DefaultFuchsiaResourceDialect,
4807                >(
4808                    <StereoCameraArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4809                    encoder,
4810                    offset + 8,
4811                    _depth,
4812                ),
4813                ResourceArgs::Renderer(ref val) => fidl::encoding::encode_in_envelope::<
4814                    RendererArgs,
4815                    fidl::encoding::DefaultFuchsiaResourceDialect,
4816                >(
4817                    <RendererArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4818                    encoder,
4819                    offset + 8,
4820                    _depth,
4821                ),
4822                ResourceArgs::AmbientLight(ref val) => fidl::encoding::encode_in_envelope::<
4823                    AmbientLightArgs,
4824                    fidl::encoding::DefaultFuchsiaResourceDialect,
4825                >(
4826                    <AmbientLightArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4827                    encoder,
4828                    offset + 8,
4829                    _depth,
4830                ),
4831                ResourceArgs::DirectionalLight(ref val) => fidl::encoding::encode_in_envelope::<
4832                    DirectionalLightArgs,
4833                    fidl::encoding::DefaultFuchsiaResourceDialect,
4834                >(
4835                    <DirectionalLightArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4836                    encoder,
4837                    offset + 8,
4838                    _depth,
4839                ),
4840                ResourceArgs::Variable(ref val) => fidl::encoding::encode_in_envelope::<
4841                    VariableArgs,
4842                    fidl::encoding::DefaultFuchsiaResourceDialect,
4843                >(
4844                    <VariableArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4845                    encoder,
4846                    offset + 8,
4847                    _depth,
4848                ),
4849                ResourceArgs::PointLight(ref val) => fidl::encoding::encode_in_envelope::<
4850                    PointLightArgs,
4851                    fidl::encoding::DefaultFuchsiaResourceDialect,
4852                >(
4853                    <PointLightArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
4854                    encoder,
4855                    offset + 8,
4856                    _depth,
4857                ),
4858                ResourceArgs::View3(ref mut val) => fidl::encoding::encode_in_envelope::<
4859                    ViewArgs3,
4860                    fidl::encoding::DefaultFuchsiaResourceDialect,
4861                >(
4862                    <ViewArgs3 as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
4863                    encoder,
4864                    offset + 8,
4865                    _depth,
4866                ),
4867                ResourceArgs::ImagePipe2(ref mut val) => fidl::encoding::encode_in_envelope::<
4868                    ImagePipe2Args,
4869                    fidl::encoding::DefaultFuchsiaResourceDialect,
4870                >(
4871                    <ImagePipe2Args as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
4872                    encoder,
4873                    offset + 8,
4874                    _depth,
4875                ),
4876                ResourceArgs::Image2(ref val) => fidl::encoding::encode_in_envelope::<
4877                    ImageArgs2,
4878                    fidl::encoding::DefaultFuchsiaResourceDialect,
4879                >(
4880                    <ImageArgs2 as fidl::encoding::ValueTypeMarker>::borrow(val),
4881                    encoder,
4882                    offset + 8,
4883                    _depth,
4884                ),
4885                ResourceArgs::Image3(ref mut val) => fidl::encoding::encode_in_envelope::<
4886                    ImageArgs3,
4887                    fidl::encoding::DefaultFuchsiaResourceDialect,
4888                >(
4889                    <ImageArgs3 as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
4890                    encoder,
4891                    offset + 8,
4892                    _depth,
4893                ),
4894            }
4895        }
4896    }
4897
4898    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ResourceArgs {
4899        #[inline(always)]
4900        fn new_empty() -> Self {
4901            Self::Memory(fidl::new_empty!(
4902                MemoryArgs,
4903                fidl::encoding::DefaultFuchsiaResourceDialect
4904            ))
4905        }
4906
4907        #[inline]
4908        unsafe fn decode(
4909            &mut self,
4910            decoder: &mut fidl::encoding::Decoder<
4911                '_,
4912                fidl::encoding::DefaultFuchsiaResourceDialect,
4913            >,
4914            offset: usize,
4915            mut depth: fidl::encoding::Depth,
4916        ) -> fidl::Result<()> {
4917            decoder.debug_check_bounds::<Self>(offset);
4918            #[allow(unused_variables)]
4919            let next_out_of_line = decoder.next_out_of_line();
4920            let handles_before = decoder.remaining_handles();
4921            let (ordinal, inlined, num_bytes, num_handles) =
4922                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4923
4924            let member_inline_size = match ordinal {
4925                1 => <MemoryArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4926                2 => <ImageArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4927                4 => <BufferArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4928                5 => <ViewArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4929                6 => <ViewHolderArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4930                7 => <RectangleArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4931                8 => <RoundedRectangleArgs as fidl::encoding::TypeMarker>::inline_size(
4932                    decoder.context,
4933                ),
4934                9 => <CircleArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4935                10 => <MeshArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4936                11 => <ShapeNodeArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4937                12 => <ClipNodeArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4938                13 => <EntityNodeArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4939                14 => <OpacityNodeArgsHack as fidl::encoding::TypeMarker>::inline_size(
4940                    decoder.context,
4941                ),
4942                15 => <MaterialArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4943                16 => <CompositorArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4944                17 => <DisplayCompositorArgs as fidl::encoding::TypeMarker>::inline_size(
4945                    decoder.context,
4946                ),
4947                19 => <LayerStackArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4948                20 => <LayerArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4949                21 => <SceneArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4950                22 => <CameraArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4951                23 => {
4952                    <StereoCameraArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context)
4953                }
4954                24 => <RendererArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4955                25 => {
4956                    <AmbientLightArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context)
4957                }
4958                26 => <DirectionalLightArgs as fidl::encoding::TypeMarker>::inline_size(
4959                    decoder.context,
4960                ),
4961                27 => <VariableArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4962                28 => <PointLightArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4963                31 => <ViewArgs3 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4964                32 => <ImagePipe2Args as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4965                33 => <ImageArgs2 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4966                34 => <ImageArgs3 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4967                _ => return Err(fidl::Error::UnknownUnionTag),
4968            };
4969
4970            if inlined != (member_inline_size <= 4) {
4971                return Err(fidl::Error::InvalidInlineBitInEnvelope);
4972            }
4973            let _inner_offset;
4974            if inlined {
4975                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4976                _inner_offset = offset + 8;
4977            } else {
4978                depth.increment()?;
4979                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4980            }
4981            match ordinal {
4982                1 => {
4983                    #[allow(irrefutable_let_patterns)]
4984                    if let ResourceArgs::Memory(_) = self {
4985                        // Do nothing, read the value into the object
4986                    } else {
4987                        // Initialize `self` to the right variant
4988                        *self = ResourceArgs::Memory(fidl::new_empty!(
4989                            MemoryArgs,
4990                            fidl::encoding::DefaultFuchsiaResourceDialect
4991                        ));
4992                    }
4993                    #[allow(irrefutable_let_patterns)]
4994                    if let ResourceArgs::Memory(ref mut val) = self {
4995                        fidl::decode!(
4996                            MemoryArgs,
4997                            fidl::encoding::DefaultFuchsiaResourceDialect,
4998                            val,
4999                            decoder,
5000                            _inner_offset,
5001                            depth
5002                        )?;
5003                    } else {
5004                        unreachable!()
5005                    }
5006                }
5007                2 => {
5008                    #[allow(irrefutable_let_patterns)]
5009                    if let ResourceArgs::Image(_) = self {
5010                        // Do nothing, read the value into the object
5011                    } else {
5012                        // Initialize `self` to the right variant
5013                        *self = ResourceArgs::Image(fidl::new_empty!(
5014                            ImageArgs,
5015                            fidl::encoding::DefaultFuchsiaResourceDialect
5016                        ));
5017                    }
5018                    #[allow(irrefutable_let_patterns)]
5019                    if let ResourceArgs::Image(ref mut val) = self {
5020                        fidl::decode!(
5021                            ImageArgs,
5022                            fidl::encoding::DefaultFuchsiaResourceDialect,
5023                            val,
5024                            decoder,
5025                            _inner_offset,
5026                            depth
5027                        )?;
5028                    } else {
5029                        unreachable!()
5030                    }
5031                }
5032                4 => {
5033                    #[allow(irrefutable_let_patterns)]
5034                    if let ResourceArgs::Buffer(_) = self {
5035                        // Do nothing, read the value into the object
5036                    } else {
5037                        // Initialize `self` to the right variant
5038                        *self = ResourceArgs::Buffer(fidl::new_empty!(
5039                            BufferArgs,
5040                            fidl::encoding::DefaultFuchsiaResourceDialect
5041                        ));
5042                    }
5043                    #[allow(irrefutable_let_patterns)]
5044                    if let ResourceArgs::Buffer(ref mut val) = self {
5045                        fidl::decode!(
5046                            BufferArgs,
5047                            fidl::encoding::DefaultFuchsiaResourceDialect,
5048                            val,
5049                            decoder,
5050                            _inner_offset,
5051                            depth
5052                        )?;
5053                    } else {
5054                        unreachable!()
5055                    }
5056                }
5057                5 => {
5058                    #[allow(irrefutable_let_patterns)]
5059                    if let ResourceArgs::View(_) = self {
5060                        // Do nothing, read the value into the object
5061                    } else {
5062                        // Initialize `self` to the right variant
5063                        *self = ResourceArgs::View(fidl::new_empty!(
5064                            ViewArgs,
5065                            fidl::encoding::DefaultFuchsiaResourceDialect
5066                        ));
5067                    }
5068                    #[allow(irrefutable_let_patterns)]
5069                    if let ResourceArgs::View(ref mut val) = self {
5070                        fidl::decode!(
5071                            ViewArgs,
5072                            fidl::encoding::DefaultFuchsiaResourceDialect,
5073                            val,
5074                            decoder,
5075                            _inner_offset,
5076                            depth
5077                        )?;
5078                    } else {
5079                        unreachable!()
5080                    }
5081                }
5082                6 => {
5083                    #[allow(irrefutable_let_patterns)]
5084                    if let ResourceArgs::ViewHolder(_) = self {
5085                        // Do nothing, read the value into the object
5086                    } else {
5087                        // Initialize `self` to the right variant
5088                        *self = ResourceArgs::ViewHolder(fidl::new_empty!(
5089                            ViewHolderArgs,
5090                            fidl::encoding::DefaultFuchsiaResourceDialect
5091                        ));
5092                    }
5093                    #[allow(irrefutable_let_patterns)]
5094                    if let ResourceArgs::ViewHolder(ref mut val) = self {
5095                        fidl::decode!(
5096                            ViewHolderArgs,
5097                            fidl::encoding::DefaultFuchsiaResourceDialect,
5098                            val,
5099                            decoder,
5100                            _inner_offset,
5101                            depth
5102                        )?;
5103                    } else {
5104                        unreachable!()
5105                    }
5106                }
5107                7 => {
5108                    #[allow(irrefutable_let_patterns)]
5109                    if let ResourceArgs::Rectangle(_) = self {
5110                        // Do nothing, read the value into the object
5111                    } else {
5112                        // Initialize `self` to the right variant
5113                        *self = ResourceArgs::Rectangle(fidl::new_empty!(
5114                            RectangleArgs,
5115                            fidl::encoding::DefaultFuchsiaResourceDialect
5116                        ));
5117                    }
5118                    #[allow(irrefutable_let_patterns)]
5119                    if let ResourceArgs::Rectangle(ref mut val) = self {
5120                        fidl::decode!(
5121                            RectangleArgs,
5122                            fidl::encoding::DefaultFuchsiaResourceDialect,
5123                            val,
5124                            decoder,
5125                            _inner_offset,
5126                            depth
5127                        )?;
5128                    } else {
5129                        unreachable!()
5130                    }
5131                }
5132                8 => {
5133                    #[allow(irrefutable_let_patterns)]
5134                    if let ResourceArgs::RoundedRectangle(_) = self {
5135                        // Do nothing, read the value into the object
5136                    } else {
5137                        // Initialize `self` to the right variant
5138                        *self = ResourceArgs::RoundedRectangle(fidl::new_empty!(
5139                            RoundedRectangleArgs,
5140                            fidl::encoding::DefaultFuchsiaResourceDialect
5141                        ));
5142                    }
5143                    #[allow(irrefutable_let_patterns)]
5144                    if let ResourceArgs::RoundedRectangle(ref mut val) = self {
5145                        fidl::decode!(
5146                            RoundedRectangleArgs,
5147                            fidl::encoding::DefaultFuchsiaResourceDialect,
5148                            val,
5149                            decoder,
5150                            _inner_offset,
5151                            depth
5152                        )?;
5153                    } else {
5154                        unreachable!()
5155                    }
5156                }
5157                9 => {
5158                    #[allow(irrefutable_let_patterns)]
5159                    if let ResourceArgs::Circle(_) = self {
5160                        // Do nothing, read the value into the object
5161                    } else {
5162                        // Initialize `self` to the right variant
5163                        *self = ResourceArgs::Circle(fidl::new_empty!(
5164                            CircleArgs,
5165                            fidl::encoding::DefaultFuchsiaResourceDialect
5166                        ));
5167                    }
5168                    #[allow(irrefutable_let_patterns)]
5169                    if let ResourceArgs::Circle(ref mut val) = self {
5170                        fidl::decode!(
5171                            CircleArgs,
5172                            fidl::encoding::DefaultFuchsiaResourceDialect,
5173                            val,
5174                            decoder,
5175                            _inner_offset,
5176                            depth
5177                        )?;
5178                    } else {
5179                        unreachable!()
5180                    }
5181                }
5182                10 => {
5183                    #[allow(irrefutable_let_patterns)]
5184                    if let ResourceArgs::Mesh(_) = self {
5185                        // Do nothing, read the value into the object
5186                    } else {
5187                        // Initialize `self` to the right variant
5188                        *self = ResourceArgs::Mesh(fidl::new_empty!(
5189                            MeshArgs,
5190                            fidl::encoding::DefaultFuchsiaResourceDialect
5191                        ));
5192                    }
5193                    #[allow(irrefutable_let_patterns)]
5194                    if let ResourceArgs::Mesh(ref mut val) = self {
5195                        fidl::decode!(
5196                            MeshArgs,
5197                            fidl::encoding::DefaultFuchsiaResourceDialect,
5198                            val,
5199                            decoder,
5200                            _inner_offset,
5201                            depth
5202                        )?;
5203                    } else {
5204                        unreachable!()
5205                    }
5206                }
5207                11 => {
5208                    #[allow(irrefutable_let_patterns)]
5209                    if let ResourceArgs::ShapeNode(_) = self {
5210                        // Do nothing, read the value into the object
5211                    } else {
5212                        // Initialize `self` to the right variant
5213                        *self = ResourceArgs::ShapeNode(fidl::new_empty!(
5214                            ShapeNodeArgs,
5215                            fidl::encoding::DefaultFuchsiaResourceDialect
5216                        ));
5217                    }
5218                    #[allow(irrefutable_let_patterns)]
5219                    if let ResourceArgs::ShapeNode(ref mut val) = self {
5220                        fidl::decode!(
5221                            ShapeNodeArgs,
5222                            fidl::encoding::DefaultFuchsiaResourceDialect,
5223                            val,
5224                            decoder,
5225                            _inner_offset,
5226                            depth
5227                        )?;
5228                    } else {
5229                        unreachable!()
5230                    }
5231                }
5232                12 => {
5233                    #[allow(irrefutable_let_patterns)]
5234                    if let ResourceArgs::ClipNode(_) = self {
5235                        // Do nothing, read the value into the object
5236                    } else {
5237                        // Initialize `self` to the right variant
5238                        *self = ResourceArgs::ClipNode(fidl::new_empty!(
5239                            ClipNodeArgs,
5240                            fidl::encoding::DefaultFuchsiaResourceDialect
5241                        ));
5242                    }
5243                    #[allow(irrefutable_let_patterns)]
5244                    if let ResourceArgs::ClipNode(ref mut val) = self {
5245                        fidl::decode!(
5246                            ClipNodeArgs,
5247                            fidl::encoding::DefaultFuchsiaResourceDialect,
5248                            val,
5249                            decoder,
5250                            _inner_offset,
5251                            depth
5252                        )?;
5253                    } else {
5254                        unreachable!()
5255                    }
5256                }
5257                13 => {
5258                    #[allow(irrefutable_let_patterns)]
5259                    if let ResourceArgs::EntityNode(_) = self {
5260                        // Do nothing, read the value into the object
5261                    } else {
5262                        // Initialize `self` to the right variant
5263                        *self = ResourceArgs::EntityNode(fidl::new_empty!(
5264                            EntityNodeArgs,
5265                            fidl::encoding::DefaultFuchsiaResourceDialect
5266                        ));
5267                    }
5268                    #[allow(irrefutable_let_patterns)]
5269                    if let ResourceArgs::EntityNode(ref mut val) = self {
5270                        fidl::decode!(
5271                            EntityNodeArgs,
5272                            fidl::encoding::DefaultFuchsiaResourceDialect,
5273                            val,
5274                            decoder,
5275                            _inner_offset,
5276                            depth
5277                        )?;
5278                    } else {
5279                        unreachable!()
5280                    }
5281                }
5282                14 => {
5283                    #[allow(irrefutable_let_patterns)]
5284                    if let ResourceArgs::OpacityNode(_) = self {
5285                        // Do nothing, read the value into the object
5286                    } else {
5287                        // Initialize `self` to the right variant
5288                        *self = ResourceArgs::OpacityNode(fidl::new_empty!(
5289                            OpacityNodeArgsHack,
5290                            fidl::encoding::DefaultFuchsiaResourceDialect
5291                        ));
5292                    }
5293                    #[allow(irrefutable_let_patterns)]
5294                    if let ResourceArgs::OpacityNode(ref mut val) = self {
5295                        fidl::decode!(
5296                            OpacityNodeArgsHack,
5297                            fidl::encoding::DefaultFuchsiaResourceDialect,
5298                            val,
5299                            decoder,
5300                            _inner_offset,
5301                            depth
5302                        )?;
5303                    } else {
5304                        unreachable!()
5305                    }
5306                }
5307                15 => {
5308                    #[allow(irrefutable_let_patterns)]
5309                    if let ResourceArgs::Material(_) = self {
5310                        // Do nothing, read the value into the object
5311                    } else {
5312                        // Initialize `self` to the right variant
5313                        *self = ResourceArgs::Material(fidl::new_empty!(
5314                            MaterialArgs,
5315                            fidl::encoding::DefaultFuchsiaResourceDialect
5316                        ));
5317                    }
5318                    #[allow(irrefutable_let_patterns)]
5319                    if let ResourceArgs::Material(ref mut val) = self {
5320                        fidl::decode!(
5321                            MaterialArgs,
5322                            fidl::encoding::DefaultFuchsiaResourceDialect,
5323                            val,
5324                            decoder,
5325                            _inner_offset,
5326                            depth
5327                        )?;
5328                    } else {
5329                        unreachable!()
5330                    }
5331                }
5332                16 => {
5333                    #[allow(irrefutable_let_patterns)]
5334                    if let ResourceArgs::Compositor(_) = self {
5335                        // Do nothing, read the value into the object
5336                    } else {
5337                        // Initialize `self` to the right variant
5338                        *self = ResourceArgs::Compositor(fidl::new_empty!(
5339                            CompositorArgs,
5340                            fidl::encoding::DefaultFuchsiaResourceDialect
5341                        ));
5342                    }
5343                    #[allow(irrefutable_let_patterns)]
5344                    if let ResourceArgs::Compositor(ref mut val) = self {
5345                        fidl::decode!(
5346                            CompositorArgs,
5347                            fidl::encoding::DefaultFuchsiaResourceDialect,
5348                            val,
5349                            decoder,
5350                            _inner_offset,
5351                            depth
5352                        )?;
5353                    } else {
5354                        unreachable!()
5355                    }
5356                }
5357                17 => {
5358                    #[allow(irrefutable_let_patterns)]
5359                    if let ResourceArgs::DisplayCompositor(_) = self {
5360                        // Do nothing, read the value into the object
5361                    } else {
5362                        // Initialize `self` to the right variant
5363                        *self = ResourceArgs::DisplayCompositor(fidl::new_empty!(
5364                            DisplayCompositorArgs,
5365                            fidl::encoding::DefaultFuchsiaResourceDialect
5366                        ));
5367                    }
5368                    #[allow(irrefutable_let_patterns)]
5369                    if let ResourceArgs::DisplayCompositor(ref mut val) = self {
5370                        fidl::decode!(
5371                            DisplayCompositorArgs,
5372                            fidl::encoding::DefaultFuchsiaResourceDialect,
5373                            val,
5374                            decoder,
5375                            _inner_offset,
5376                            depth
5377                        )?;
5378                    } else {
5379                        unreachable!()
5380                    }
5381                }
5382                19 => {
5383                    #[allow(irrefutable_let_patterns)]
5384                    if let ResourceArgs::LayerStack(_) = self {
5385                        // Do nothing, read the value into the object
5386                    } else {
5387                        // Initialize `self` to the right variant
5388                        *self = ResourceArgs::LayerStack(fidl::new_empty!(
5389                            LayerStackArgs,
5390                            fidl::encoding::DefaultFuchsiaResourceDialect
5391                        ));
5392                    }
5393                    #[allow(irrefutable_let_patterns)]
5394                    if let ResourceArgs::LayerStack(ref mut val) = self {
5395                        fidl::decode!(
5396                            LayerStackArgs,
5397                            fidl::encoding::DefaultFuchsiaResourceDialect,
5398                            val,
5399                            decoder,
5400                            _inner_offset,
5401                            depth
5402                        )?;
5403                    } else {
5404                        unreachable!()
5405                    }
5406                }
5407                20 => {
5408                    #[allow(irrefutable_let_patterns)]
5409                    if let ResourceArgs::Layer(_) = self {
5410                        // Do nothing, read the value into the object
5411                    } else {
5412                        // Initialize `self` to the right variant
5413                        *self = ResourceArgs::Layer(fidl::new_empty!(
5414                            LayerArgs,
5415                            fidl::encoding::DefaultFuchsiaResourceDialect
5416                        ));
5417                    }
5418                    #[allow(irrefutable_let_patterns)]
5419                    if let ResourceArgs::Layer(ref mut val) = self {
5420                        fidl::decode!(
5421                            LayerArgs,
5422                            fidl::encoding::DefaultFuchsiaResourceDialect,
5423                            val,
5424                            decoder,
5425                            _inner_offset,
5426                            depth
5427                        )?;
5428                    } else {
5429                        unreachable!()
5430                    }
5431                }
5432                21 => {
5433                    #[allow(irrefutable_let_patterns)]
5434                    if let ResourceArgs::Scene(_) = self {
5435                        // Do nothing, read the value into the object
5436                    } else {
5437                        // Initialize `self` to the right variant
5438                        *self = ResourceArgs::Scene(fidl::new_empty!(
5439                            SceneArgs,
5440                            fidl::encoding::DefaultFuchsiaResourceDialect
5441                        ));
5442                    }
5443                    #[allow(irrefutable_let_patterns)]
5444                    if let ResourceArgs::Scene(ref mut val) = self {
5445                        fidl::decode!(
5446                            SceneArgs,
5447                            fidl::encoding::DefaultFuchsiaResourceDialect,
5448                            val,
5449                            decoder,
5450                            _inner_offset,
5451                            depth
5452                        )?;
5453                    } else {
5454                        unreachable!()
5455                    }
5456                }
5457                22 => {
5458                    #[allow(irrefutable_let_patterns)]
5459                    if let ResourceArgs::Camera(_) = self {
5460                        // Do nothing, read the value into the object
5461                    } else {
5462                        // Initialize `self` to the right variant
5463                        *self = ResourceArgs::Camera(fidl::new_empty!(
5464                            CameraArgs,
5465                            fidl::encoding::DefaultFuchsiaResourceDialect
5466                        ));
5467                    }
5468                    #[allow(irrefutable_let_patterns)]
5469                    if let ResourceArgs::Camera(ref mut val) = self {
5470                        fidl::decode!(
5471                            CameraArgs,
5472                            fidl::encoding::DefaultFuchsiaResourceDialect,
5473                            val,
5474                            decoder,
5475                            _inner_offset,
5476                            depth
5477                        )?;
5478                    } else {
5479                        unreachable!()
5480                    }
5481                }
5482                23 => {
5483                    #[allow(irrefutable_let_patterns)]
5484                    if let ResourceArgs::StereoCamera(_) = self {
5485                        // Do nothing, read the value into the object
5486                    } else {
5487                        // Initialize `self` to the right variant
5488                        *self = ResourceArgs::StereoCamera(fidl::new_empty!(
5489                            StereoCameraArgs,
5490                            fidl::encoding::DefaultFuchsiaResourceDialect
5491                        ));
5492                    }
5493                    #[allow(irrefutable_let_patterns)]
5494                    if let ResourceArgs::StereoCamera(ref mut val) = self {
5495                        fidl::decode!(
5496                            StereoCameraArgs,
5497                            fidl::encoding::DefaultFuchsiaResourceDialect,
5498                            val,
5499                            decoder,
5500                            _inner_offset,
5501                            depth
5502                        )?;
5503                    } else {
5504                        unreachable!()
5505                    }
5506                }
5507                24 => {
5508                    #[allow(irrefutable_let_patterns)]
5509                    if let ResourceArgs::Renderer(_) = self {
5510                        // Do nothing, read the value into the object
5511                    } else {
5512                        // Initialize `self` to the right variant
5513                        *self = ResourceArgs::Renderer(fidl::new_empty!(
5514                            RendererArgs,
5515                            fidl::encoding::DefaultFuchsiaResourceDialect
5516                        ));
5517                    }
5518                    #[allow(irrefutable_let_patterns)]
5519                    if let ResourceArgs::Renderer(ref mut val) = self {
5520                        fidl::decode!(
5521                            RendererArgs,
5522                            fidl::encoding::DefaultFuchsiaResourceDialect,
5523                            val,
5524                            decoder,
5525                            _inner_offset,
5526                            depth
5527                        )?;
5528                    } else {
5529                        unreachable!()
5530                    }
5531                }
5532                25 => {
5533                    #[allow(irrefutable_let_patterns)]
5534                    if let ResourceArgs::AmbientLight(_) = self {
5535                        // Do nothing, read the value into the object
5536                    } else {
5537                        // Initialize `self` to the right variant
5538                        *self = ResourceArgs::AmbientLight(fidl::new_empty!(
5539                            AmbientLightArgs,
5540                            fidl::encoding::DefaultFuchsiaResourceDialect
5541                        ));
5542                    }
5543                    #[allow(irrefutable_let_patterns)]
5544                    if let ResourceArgs::AmbientLight(ref mut val) = self {
5545                        fidl::decode!(
5546                            AmbientLightArgs,
5547                            fidl::encoding::DefaultFuchsiaResourceDialect,
5548                            val,
5549                            decoder,
5550                            _inner_offset,
5551                            depth
5552                        )?;
5553                    } else {
5554                        unreachable!()
5555                    }
5556                }
5557                26 => {
5558                    #[allow(irrefutable_let_patterns)]
5559                    if let ResourceArgs::DirectionalLight(_) = self {
5560                        // Do nothing, read the value into the object
5561                    } else {
5562                        // Initialize `self` to the right variant
5563                        *self = ResourceArgs::DirectionalLight(fidl::new_empty!(
5564                            DirectionalLightArgs,
5565                            fidl::encoding::DefaultFuchsiaResourceDialect
5566                        ));
5567                    }
5568                    #[allow(irrefutable_let_patterns)]
5569                    if let ResourceArgs::DirectionalLight(ref mut val) = self {
5570                        fidl::decode!(
5571                            DirectionalLightArgs,
5572                            fidl::encoding::DefaultFuchsiaResourceDialect,
5573                            val,
5574                            decoder,
5575                            _inner_offset,
5576                            depth
5577                        )?;
5578                    } else {
5579                        unreachable!()
5580                    }
5581                }
5582                27 => {
5583                    #[allow(irrefutable_let_patterns)]
5584                    if let ResourceArgs::Variable(_) = self {
5585                        // Do nothing, read the value into the object
5586                    } else {
5587                        // Initialize `self` to the right variant
5588                        *self = ResourceArgs::Variable(fidl::new_empty!(
5589                            VariableArgs,
5590                            fidl::encoding::DefaultFuchsiaResourceDialect
5591                        ));
5592                    }
5593                    #[allow(irrefutable_let_patterns)]
5594                    if let ResourceArgs::Variable(ref mut val) = self {
5595                        fidl::decode!(
5596                            VariableArgs,
5597                            fidl::encoding::DefaultFuchsiaResourceDialect,
5598                            val,
5599                            decoder,
5600                            _inner_offset,
5601                            depth
5602                        )?;
5603                    } else {
5604                        unreachable!()
5605                    }
5606                }
5607                28 => {
5608                    #[allow(irrefutable_let_patterns)]
5609                    if let ResourceArgs::PointLight(_) = self {
5610                        // Do nothing, read the value into the object
5611                    } else {
5612                        // Initialize `self` to the right variant
5613                        *self = ResourceArgs::PointLight(fidl::new_empty!(
5614                            PointLightArgs,
5615                            fidl::encoding::DefaultFuchsiaResourceDialect
5616                        ));
5617                    }
5618                    #[allow(irrefutable_let_patterns)]
5619                    if let ResourceArgs::PointLight(ref mut val) = self {
5620                        fidl::decode!(
5621                            PointLightArgs,
5622                            fidl::encoding::DefaultFuchsiaResourceDialect,
5623                            val,
5624                            decoder,
5625                            _inner_offset,
5626                            depth
5627                        )?;
5628                    } else {
5629                        unreachable!()
5630                    }
5631                }
5632                31 => {
5633                    #[allow(irrefutable_let_patterns)]
5634                    if let ResourceArgs::View3(_) = self {
5635                        // Do nothing, read the value into the object
5636                    } else {
5637                        // Initialize `self` to the right variant
5638                        *self = ResourceArgs::View3(fidl::new_empty!(
5639                            ViewArgs3,
5640                            fidl::encoding::DefaultFuchsiaResourceDialect
5641                        ));
5642                    }
5643                    #[allow(irrefutable_let_patterns)]
5644                    if let ResourceArgs::View3(ref mut val) = self {
5645                        fidl::decode!(
5646                            ViewArgs3,
5647                            fidl::encoding::DefaultFuchsiaResourceDialect,
5648                            val,
5649                            decoder,
5650                            _inner_offset,
5651                            depth
5652                        )?;
5653                    } else {
5654                        unreachable!()
5655                    }
5656                }
5657                32 => {
5658                    #[allow(irrefutable_let_patterns)]
5659                    if let ResourceArgs::ImagePipe2(_) = self {
5660                        // Do nothing, read the value into the object
5661                    } else {
5662                        // Initialize `self` to the right variant
5663                        *self = ResourceArgs::ImagePipe2(fidl::new_empty!(
5664                            ImagePipe2Args,
5665                            fidl::encoding::DefaultFuchsiaResourceDialect
5666                        ));
5667                    }
5668                    #[allow(irrefutable_let_patterns)]
5669                    if let ResourceArgs::ImagePipe2(ref mut val) = self {
5670                        fidl::decode!(
5671                            ImagePipe2Args,
5672                            fidl::encoding::DefaultFuchsiaResourceDialect,
5673                            val,
5674                            decoder,
5675                            _inner_offset,
5676                            depth
5677                        )?;
5678                    } else {
5679                        unreachable!()
5680                    }
5681                }
5682                33 => {
5683                    #[allow(irrefutable_let_patterns)]
5684                    if let ResourceArgs::Image2(_) = self {
5685                        // Do nothing, read the value into the object
5686                    } else {
5687                        // Initialize `self` to the right variant
5688                        *self = ResourceArgs::Image2(fidl::new_empty!(
5689                            ImageArgs2,
5690                            fidl::encoding::DefaultFuchsiaResourceDialect
5691                        ));
5692                    }
5693                    #[allow(irrefutable_let_patterns)]
5694                    if let ResourceArgs::Image2(ref mut val) = self {
5695                        fidl::decode!(
5696                            ImageArgs2,
5697                            fidl::encoding::DefaultFuchsiaResourceDialect,
5698                            val,
5699                            decoder,
5700                            _inner_offset,
5701                            depth
5702                        )?;
5703                    } else {
5704                        unreachable!()
5705                    }
5706                }
5707                34 => {
5708                    #[allow(irrefutable_let_patterns)]
5709                    if let ResourceArgs::Image3(_) = self {
5710                        // Do nothing, read the value into the object
5711                    } else {
5712                        // Initialize `self` to the right variant
5713                        *self = ResourceArgs::Image3(fidl::new_empty!(
5714                            ImageArgs3,
5715                            fidl::encoding::DefaultFuchsiaResourceDialect
5716                        ));
5717                    }
5718                    #[allow(irrefutable_let_patterns)]
5719                    if let ResourceArgs::Image3(ref mut val) = self {
5720                        fidl::decode!(
5721                            ImageArgs3,
5722                            fidl::encoding::DefaultFuchsiaResourceDialect,
5723                            val,
5724                            decoder,
5725                            _inner_offset,
5726                            depth
5727                        )?;
5728                    } else {
5729                        unreachable!()
5730                    }
5731                }
5732                ordinal => panic!("unexpected ordinal {:?}", ordinal),
5733            }
5734            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5735                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5736            }
5737            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5738                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5739            }
5740            Ok(())
5741        }
5742    }
5743}
fidl_fuchsia_ui_gfx/fidl_fuchsia_ui_gfx.rs

fidl_fuchsia_ui_gfx/
fidl_fuchsia_ui_gfx.rs
