fidl_fuchsia_ui_gfx/
fidl_fuchsia_ui_gfx.rs

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

fidl_fuchsia_ui_gfx/
fidl_fuchsia_ui_gfx.rs
