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

fidl_fuchsia_ui_gfx/
fidl_fuchsia_ui_gfx.rs
