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

fidl_fuchsia_ui_gfx/
fidl_fuchsia_ui_gfx.rs
