1#![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_fidl_test_compatibility_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ArraysStruct {
16 pub bools: [bool; 3],
17 pub int8s: [i8; 3],
18 pub int16s: [i16; 3],
19 pub int32s: [i32; 3],
20 pub int64s: [i64; 3],
21 pub uint8s: [u8; 3],
22 pub uint16s: [u16; 3],
23 pub uint32s: [u32; 3],
24 pub uint64s: [u64; 3],
25 pub float32s: [f32; 3],
26 pub float64s: [f64; 3],
27 pub enums: [DefaultEnum; 3],
28 pub bits: [DefaultBits; 3],
29 pub handles: [fidl::Handle; 3],
30 pub nullable_handles: [Option<fidl::Handle>; 3],
31 pub strings: [String; 3],
32 pub nullable_strings: [Option<String>; 3],
33 pub structs: [ThisIsAStruct; 3],
34 pub nullable_structs: [Option<Box<ThisIsAStruct>>; 3],
35 pub unions: [ThisIsAUnion; 3],
36 pub nullable_unions: [Option<Box<ThisIsAUnion>>; 3],
37 pub arrays: [[u32; 3]; 3],
38 pub vectors: [Vec<u32>; 3],
39 pub nullable_vectors: [Option<Vec<u32>>; 3],
40 pub tables: [ThisIsATable; 3],
41 pub xunions: [ThisIsAXunion; 3],
42}
43
44impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {}
45
46#[derive(Debug, PartialEq)]
47pub struct EchoEchoArraysRequest {
48 pub value: ArraysStruct,
49 pub forward_to_server: String,
50}
51
52impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoArraysRequest {}
53
54#[derive(Debug, PartialEq)]
55pub struct EchoEchoArraysResponse {
56 pub value: ArraysStruct,
57}
58
59impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoArraysResponse {}
60
61#[derive(Debug, PartialEq)]
62pub struct EchoEchoArraysWithErrorRequest {
63 pub value: ArraysStruct,
64 pub result_err: DefaultEnum,
65 pub forward_to_server: String,
66 pub result_variant: RespondWith,
67}
68
69impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
70 for EchoEchoArraysWithErrorRequest
71{
72}
73
74#[derive(Debug, PartialEq)]
75pub struct EchoEchoEventRequest {
76 pub value: Struct,
77}
78
79impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoEventRequest {}
80
81#[derive(Debug, PartialEq)]
82pub struct EchoEchoStructNoRetValRequest {
83 pub value: Struct,
84 pub forward_to_server: String,
85}
86
87impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
88 for EchoEchoStructNoRetValRequest
89{
90}
91
92#[derive(Debug, PartialEq)]
93pub struct EchoEchoStructRequest {
94 pub value: Struct,
95 pub forward_to_server: String,
96}
97
98impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoStructRequest {}
99
100#[derive(Debug, PartialEq)]
101pub struct EchoEchoStructResponse {
102 pub value: Struct,
103}
104
105impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoStructResponse {}
106
107#[derive(Debug, PartialEq)]
108pub struct EchoEchoStructWithErrorRequest {
109 pub value: Struct,
110 pub result_err: DefaultEnum,
111 pub forward_to_server: String,
112 pub result_variant: RespondWith,
113}
114
115impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
116 for EchoEchoStructWithErrorRequest
117{
118}
119
120#[derive(Debug, PartialEq)]
121pub struct EchoEchoTableRequest {
122 pub value: AllTypesTable,
123 pub forward_to_server: String,
124}
125
126impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoTableRequest {}
127
128#[derive(Debug, PartialEq)]
129pub struct EchoEchoTableResponse {
130 pub value: AllTypesTable,
131}
132
133impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoTableResponse {}
134
135#[derive(Debug, PartialEq)]
136pub struct EchoEchoTableWithErrorRequest {
137 pub value: AllTypesTable,
138 pub result_err: DefaultEnum,
139 pub forward_to_server: String,
140 pub result_variant: RespondWith,
141}
142
143impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
144 for EchoEchoTableWithErrorRequest
145{
146}
147
148#[derive(Debug, PartialEq)]
149pub struct EchoEchoVectorsRequest {
150 pub value: VectorsStruct,
151 pub forward_to_server: String,
152}
153
154impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoVectorsRequest {}
155
156#[derive(Debug, PartialEq)]
157pub struct EchoEchoVectorsResponse {
158 pub value: VectorsStruct,
159}
160
161impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoVectorsResponse {}
162
163#[derive(Debug, PartialEq)]
164pub struct EchoEchoVectorsWithErrorRequest {
165 pub value: VectorsStruct,
166 pub result_err: DefaultEnum,
167 pub forward_to_server: String,
168 pub result_variant: RespondWith,
169}
170
171impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
172 for EchoEchoVectorsWithErrorRequest
173{
174}
175
176#[derive(Debug, PartialEq)]
177pub struct EchoEchoXunionsRequest {
178 pub value: Vec<AllTypesXunion>,
179 pub forward_to_server: String,
180}
181
182impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoXunionsRequest {}
183
184#[derive(Debug, PartialEq)]
185pub struct EchoEchoXunionsResponse {
186 pub value: Vec<AllTypesXunion>,
187}
188
189impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoXunionsResponse {}
190
191#[derive(Debug, PartialEq)]
192pub struct EchoEchoXunionsWithErrorRequest {
193 pub value: Vec<AllTypesXunion>,
194 pub result_err: DefaultEnum,
195 pub forward_to_server: String,
196 pub result_variant: RespondWith,
197}
198
199impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
200 for EchoEchoXunionsWithErrorRequest
201{
202}
203
204#[derive(Debug, PartialEq)]
205pub struct EchoEchoArraysWithErrorResponse {
206 pub value: ArraysStruct,
207}
208
209impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
210 for EchoEchoArraysWithErrorResponse
211{
212}
213
214#[derive(Debug, PartialEq)]
215pub struct EchoEchoStructWithErrorResponse {
216 pub value: Struct,
217}
218
219impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
220 for EchoEchoStructWithErrorResponse
221{
222}
223
224#[derive(Debug, PartialEq)]
225pub struct EchoEchoTableWithErrorResponse {
226 pub value: AllTypesTable,
227}
228
229impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
230 for EchoEchoTableWithErrorResponse
231{
232}
233
234#[derive(Debug, PartialEq)]
235pub struct EchoEchoVectorsWithErrorResponse {
236 pub value: VectorsStruct,
237}
238
239impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
240 for EchoEchoVectorsWithErrorResponse
241{
242}
243
244#[derive(Debug, PartialEq)]
245pub struct EchoEchoXunionsWithErrorResponse {
246 pub value: Vec<AllTypesXunion>,
247}
248
249impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
250 for EchoEchoXunionsWithErrorResponse
251{
252}
253
254#[derive(Debug, PartialEq)]
255pub struct Struct {
256 pub primitive_types: PrimitiveTypes,
257 pub default_values: DefaultValues,
258 pub arrays: Arrays,
259 pub arrays_2d: Arrays2d,
260 pub vectors: Vectors,
261 pub handles: Handles,
262 pub strings: Strings,
263 pub default_enum: DefaultEnum,
264 pub i8_enum: I8Enum,
265 pub i16_enum: I16Enum,
266 pub i32_enum: I32Enum,
267 pub i64_enum: I64Enum,
268 pub u8_enum: U8Enum,
269 pub u16_enum: U16Enum,
270 pub u32_enum: U32Enum,
271 pub u64_enum: U64Enum,
272 pub default_bits: DefaultBits,
273 pub u8_bits: U8Bits,
274 pub u16_bits: U16Bits,
275 pub u32_bits: U32Bits,
276 pub u64_bits: U64Bits,
277 pub structs: Structs,
278 pub unions: Unions,
279 pub table: ThisIsATable,
280 pub xunion: ThisIsAXunion,
281 pub b: bool,
282}
283
284impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {}
285
286#[derive(Debug, PartialEq)]
287pub struct VectorsStruct {
288 pub bools: Vec<bool>,
289 pub int8s: Vec<i8>,
290 pub int16s: Vec<i16>,
291 pub int32s: Vec<i32>,
292 pub int64s: Vec<i64>,
293 pub uint8s: Vec<u8>,
294 pub uint16s: Vec<u16>,
295 pub uint32s: Vec<u32>,
296 pub uint64s: Vec<u64>,
297 pub float32s: Vec<f32>,
298 pub float64s: Vec<f64>,
299 pub enums: Vec<DefaultEnum>,
300 pub bits: Vec<DefaultBits>,
301 pub handles: Vec<fidl::Handle>,
302 pub nullable_handles: Vec<Option<fidl::Handle>>,
303 pub strings: Vec<String>,
304 pub nullable_strings: Vec<Option<String>>,
305 pub structs: Vec<ThisIsAStruct>,
306 pub nullable_structs: Vec<Option<Box<ThisIsAStruct>>>,
307 pub unions: Vec<ThisIsAUnion>,
308 pub nullable_unions: Vec<Option<Box<ThisIsAUnion>>>,
309 pub arrays: Vec<[u32; 3]>,
310 pub vectors: Vec<Vec<u32>>,
311 pub nullable_vectors: Vec<Option<Vec<u32>>>,
312 pub tables: Vec<ThisIsATable>,
313 pub xunions: Vec<ThisIsAXunion>,
314}
315
316impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {}
317
318#[derive(Debug, PartialEq, PartialOrd)]
319pub struct Arrays {
320 pub b_0: [bool; 1],
321 pub i8_0: [i8; 1],
322 pub i16_0: [i16; 1],
323 pub i32_0: [i32; 1],
324 pub i64_0: [i64; 1],
325 pub u8_0: [u8; 1],
326 pub u16_0: [u16; 1],
327 pub u32_0: [u32; 1],
328 pub u64_0: [u64; 1],
329 pub f32_0: [f32; 1],
330 pub f64_0: [f64; 1],
331 pub handle_0: [fidl::Handle; 1],
332 pub b_1: [bool; 3],
333 pub i8_1: [i8; 3],
334 pub i16_1: [i16; 3],
335 pub i32_1: [i32; 3],
336 pub i64_1: [i64; 3],
337 pub u8_1: [u8; 3],
338 pub u16_1: [u16; 3],
339 pub u32_1: [u32; 3],
340 pub u64_1: [u64; 3],
341 pub f32_1: [f32; 3],
342 pub f64_1: [f64; 3],
343 pub handle_1: [fidl::Handle; 3],
344}
345
346impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {}
347
348#[derive(Debug, PartialEq, PartialOrd)]
349pub struct Arrays2d {
350 pub b: [[bool; 2]; 3],
351 pub i8: [[i8; 2]; 3],
352 pub i16: [[i16; 2]; 3],
353 pub i32: [[i32; 2]; 3],
354 pub i64: [[i64; 2]; 3],
355 pub u8: [[u8; 2]; 3],
356 pub u16: [[u16; 2]; 3],
357 pub u32: [[u32; 2]; 3],
358 pub u64: [[u64; 2]; 3],
359 pub f32: [[f32; 2]; 3],
360 pub f64: [[f64; 2]; 3],
361 pub handle_handle: [[fidl::Handle; 2]; 3],
362}
363
364impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {}
365
366#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
367pub struct Handles {
368 pub handle_handle: fidl::Handle,
369 pub process_handle: fidl::Process,
370 pub thread_handle: fidl::Thread,
371 pub vmo_handle: fidl::Vmo,
372 pub event_handle: fidl::Event,
373 pub port_handle: fidl::Port,
374 pub socket_handle: fidl::Socket,
375 pub eventpair_handle: fidl::EventPair,
376 pub job_handle: fidl::Job,
377 pub vmar_handle: fidl::Vmar,
378 pub fifo_handle: fidl::Fifo,
379 pub timer_handle: fidl::Timer,
380 pub nullable_handle_handle: Option<fidl::Handle>,
381 pub nullable_process_handle: Option<fidl::Process>,
382 pub nullable_thread_handle: Option<fidl::Thread>,
383 pub nullable_vmo_handle: Option<fidl::Vmo>,
384 pub nullable_channel_handle: Option<fidl::Channel>,
385 pub nullable_event_handle: Option<fidl::Event>,
386 pub nullable_port_handle: Option<fidl::Port>,
387 pub nullable_interrupt_handle: Option<fidl::Interrupt>,
388 pub nullable_log_handle: Option<fidl::DebugLog>,
389 pub nullable_socket_handle: Option<fidl::Socket>,
390 pub nullable_eventpair_handle: Option<fidl::EventPair>,
391 pub nullable_job_handle: Option<fidl::Job>,
392 pub nullable_vmar_handle: Option<fidl::Vmar>,
393 pub nullable_fifo_handle: Option<fidl::Fifo>,
394 pub nullable_timer_handle: Option<fidl::Timer>,
395}
396
397impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {}
398
399#[derive(Debug, PartialEq, PartialOrd)]
400pub struct Vectors {
401 pub b_0: Vec<bool>,
402 pub i8_0: Vec<i8>,
403 pub i16_0: Vec<i16>,
404 pub i32_0: Vec<i32>,
405 pub i64_0: Vec<i64>,
406 pub u8_0: Vec<u8>,
407 pub u16_0: Vec<u16>,
408 pub u32_0: Vec<u32>,
409 pub u64_0: Vec<u64>,
410 pub f32_0: Vec<f32>,
411 pub f64_0: Vec<f64>,
412 pub handle_0: Vec<fidl::Handle>,
413 pub b_1: Vec<Vec<bool>>,
414 pub i8_1: Vec<Vec<i8>>,
415 pub i16_1: Vec<Vec<i16>>,
416 pub i32_1: Vec<Vec<i32>>,
417 pub i64_1: Vec<Vec<i64>>,
418 pub u8_1: Vec<Vec<u8>>,
419 pub u16_1: Vec<Vec<u16>>,
420 pub u32_1: Vec<Vec<u32>>,
421 pub u64_1: Vec<Vec<u64>>,
422 pub f32_1: Vec<Vec<f32>>,
423 pub f64_1: Vec<Vec<f64>>,
424 pub handle_1: Vec<Vec<fidl::Handle>>,
425 pub b_sized_0: Vec<bool>,
426 pub i8_sized_0: Vec<i8>,
427 pub i16_sized_0: Vec<i16>,
428 pub i32_sized_0: Vec<i32>,
429 pub i64_sized_0: Vec<i64>,
430 pub u8_sized_0: Vec<u8>,
431 pub u16_sized_0: Vec<u16>,
432 pub u32_sized_0: Vec<u32>,
433 pub u64_sized_0: Vec<u64>,
434 pub f32_sized_0: Vec<f32>,
435 pub f64_sized_0: Vec<f64>,
436 pub handle_sized_0: Vec<fidl::Handle>,
437 pub b_sized_1: Vec<bool>,
438 pub i8_sized_1: Vec<i8>,
439 pub i16_sized_1: Vec<i16>,
440 pub i32_sized_1: Vec<i32>,
441 pub i64_sized_1: Vec<i64>,
442 pub u8_sized_1: Vec<u8>,
443 pub u16_sized_1: Vec<u16>,
444 pub u32_sized_1: Vec<u32>,
445 pub u64_sized_1: Vec<u64>,
446 pub f32_sized_1: Vec<f32>,
447 pub f64_sized_1: Vec<f64>,
448 pub handle_sized_1: Vec<fidl::Handle>,
449 pub b_sized_2: Vec<Vec<bool>>,
450 pub i8_sized_2: Vec<Vec<i8>>,
451 pub i16_sized_2: Vec<Vec<i16>>,
452 pub i32_sized_2: Vec<Vec<i32>>,
453 pub i64_sized_2: Vec<Vec<i64>>,
454 pub u8_sized_2: Vec<Vec<u8>>,
455 pub u16_sized_2: Vec<Vec<u16>>,
456 pub u32_sized_2: Vec<Vec<u32>>,
457 pub u64_sized_2: Vec<Vec<u64>>,
458 pub f32_sized_2: Vec<Vec<f32>>,
459 pub f64_sized_2: Vec<Vec<f64>>,
460 pub handle_sized_2: Vec<Vec<fidl::Handle>>,
461 pub b_nullable_0: Option<Vec<bool>>,
462 pub i8_nullable_0: Option<Vec<i8>>,
463 pub i16_nullable_0: Option<Vec<i16>>,
464 pub i32_nullable_0: Option<Vec<i32>>,
465 pub i64_nullable_0: Option<Vec<i64>>,
466 pub u8_nullable_0: Option<Vec<u8>>,
467 pub u16_nullable_0: Option<Vec<u16>>,
468 pub u32_nullable_0: Option<Vec<u32>>,
469 pub u64_nullable_0: Option<Vec<u64>>,
470 pub f32_nullable_0: Option<Vec<f32>>,
471 pub f64_nullable_0: Option<Vec<f64>>,
472 pub handle_nullable_0: Option<Vec<fidl::Handle>>,
473 pub b_nullable_1: Option<Vec<Vec<bool>>>,
474 pub i8_nullable_1: Option<Vec<Vec<i8>>>,
475 pub i16_nullable_1: Option<Vec<Vec<i16>>>,
476 pub i32_nullable_1: Option<Vec<Vec<i32>>>,
477 pub i64_nullable_1: Option<Vec<Vec<i64>>>,
478 pub u8_nullable_1: Option<Vec<Vec<u8>>>,
479 pub u16_nullable_1: Option<Vec<Vec<u16>>>,
480 pub u32_nullable_1: Option<Vec<Vec<u32>>>,
481 pub u64_nullable_1: Option<Vec<Vec<u64>>>,
482 pub f32_nullable_1: Option<Vec<Vec<f32>>>,
483 pub f64_nullable_1: Option<Vec<Vec<f64>>>,
484 pub handle_nullable_1: Option<Vec<Vec<fidl::Handle>>>,
485 pub b_nullable_sized_0: Option<Vec<bool>>,
486 pub i8_nullable_sized_0: Option<Vec<i8>>,
487 pub i16_nullable_sized_0: Option<Vec<i16>>,
488 pub i32_nullable_sized_0: Option<Vec<i32>>,
489 pub i64_nullable_sized_0: Option<Vec<i64>>,
490 pub u8_nullable_sized_0: Option<Vec<u8>>,
491 pub u16_nullable_sized_0: Option<Vec<u16>>,
492 pub u32_nullable_sized_0: Option<Vec<u32>>,
493 pub u64_nullable_sized_0: Option<Vec<u64>>,
494 pub f32_nullable_sized_0: Option<Vec<f32>>,
495 pub f64_nullable_sized_0: Option<Vec<f64>>,
496 pub handle_nullable_sized_0: Option<Vec<fidl::Handle>>,
497 pub b_nullable_sized_1: Option<Vec<bool>>,
498 pub i8_nullable_sized_1: Option<Vec<i8>>,
499 pub i16_nullable_sized_1: Option<Vec<i16>>,
500 pub i32_nullable_sized_1: Option<Vec<i32>>,
501 pub i64_nullable_sized_1: Option<Vec<i64>>,
502 pub u8_nullable_sized_1: Option<Vec<u8>>,
503 pub u16_nullable_sized_1: Option<Vec<u16>>,
504 pub u32_nullable_sized_1: Option<Vec<u32>>,
505 pub u64_nullable_sized_1: Option<Vec<u64>>,
506 pub f32_nullable_sized_1: Option<Vec<f32>>,
507 pub f64_nullable_sized_1: Option<Vec<f64>>,
508 pub handle_nullable_sized_1: Option<Vec<fidl::Handle>>,
509 pub b_nullable_sized_2: Option<Vec<Vec<bool>>>,
510 pub i8_nullable_sized_2: Option<Vec<Vec<i8>>>,
511 pub i16_nullable_sized_2: Option<Vec<Vec<i16>>>,
512 pub i32_nullable_sized_2: Option<Vec<Vec<i32>>>,
513 pub i64_nullable_sized_2: Option<Vec<Vec<i64>>>,
514 pub u8_nullable_sized_2: Option<Vec<Vec<u8>>>,
515 pub u16_nullable_sized_2: Option<Vec<Vec<u16>>>,
516 pub u32_nullable_sized_2: Option<Vec<Vec<u32>>>,
517 pub u64_nullable_sized_2: Option<Vec<Vec<u64>>>,
518 pub f32_nullable_sized_2: Option<Vec<Vec<f32>>>,
519 pub f64_nullable_sized_2: Option<Vec<Vec<f64>>>,
520 pub handle_nullable_sized_2: Option<Vec<Vec<fidl::Handle>>>,
521}
522
523impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {}
524
525#[derive(Debug, Default, PartialEq)]
526pub struct AllTypesTable {
527 pub bool_member: Option<bool>,
528 pub int8_member: Option<i8>,
529 pub int16_member: Option<i16>,
530 pub int32_member: Option<i32>,
531 pub int64_member: Option<i64>,
532 pub uint8_member: Option<u8>,
533 pub uint16_member: Option<u16>,
534 pub uint32_member: Option<u32>,
535 pub uint64_member: Option<u64>,
536 pub float32_member: Option<f32>,
537 pub float64_member: Option<f64>,
538 pub enum_member: Option<DefaultEnum>,
539 pub bits_member: Option<DefaultBits>,
540 pub handle_member: Option<fidl::Handle>,
541 pub string_member: Option<String>,
542 pub struct_member: Option<ThisIsAStruct>,
543 pub union_member: Option<ThisIsAUnion>,
544 pub array_member: Option<[u32; 3]>,
545 pub vector_member: Option<Vec<u32>>,
546 pub table_member: Option<ThisIsATable>,
547 pub xunion_member: Option<ThisIsAXunion>,
548 #[doc(hidden)]
549 pub __source_breaking: fidl::marker::SourceBreaking,
550}
551
552impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {}
553
554#[derive(Debug)]
555pub enum AllTypesXunion {
556 BoolMember(bool),
557 Int8Member(i8),
558 Int16Member(i16),
559 Int32Member(i32),
560 Int64Member(i64),
561 Uint8Member(u8),
562 Uint16Member(u16),
563 Uint32Member(u32),
564 Uint64Member(u64),
565 Float32Member(f32),
566 Float64Member(f64),
567 EnumMember(DefaultEnum),
568 BitsMember(DefaultBits),
569 HandleMember(fidl::Handle),
570 StringMember(String),
571 StructMember(ThisIsAStruct),
572 UnionMember(ThisIsAUnion),
573 ArrayMember([u32; 3]),
574 VectorMember(Vec<u32>),
575 TableMember(ThisIsATable),
576 XunionMember(ThisIsAXunion),
577 #[doc(hidden)]
578 __SourceBreaking {
579 unknown_ordinal: u64,
580 },
581}
582
583#[macro_export]
585macro_rules! AllTypesXunionUnknown {
586 () => {
587 _
588 };
589}
590
591impl PartialEq for AllTypesXunion {
593 fn eq(&self, other: &Self) -> bool {
594 match (self, other) {
595 (Self::BoolMember(x), Self::BoolMember(y)) => *x == *y,
596 (Self::Int8Member(x), Self::Int8Member(y)) => *x == *y,
597 (Self::Int16Member(x), Self::Int16Member(y)) => *x == *y,
598 (Self::Int32Member(x), Self::Int32Member(y)) => *x == *y,
599 (Self::Int64Member(x), Self::Int64Member(y)) => *x == *y,
600 (Self::Uint8Member(x), Self::Uint8Member(y)) => *x == *y,
601 (Self::Uint16Member(x), Self::Uint16Member(y)) => *x == *y,
602 (Self::Uint32Member(x), Self::Uint32Member(y)) => *x == *y,
603 (Self::Uint64Member(x), Self::Uint64Member(y)) => *x == *y,
604 (Self::Float32Member(x), Self::Float32Member(y)) => *x == *y,
605 (Self::Float64Member(x), Self::Float64Member(y)) => *x == *y,
606 (Self::EnumMember(x), Self::EnumMember(y)) => *x == *y,
607 (Self::BitsMember(x), Self::BitsMember(y)) => *x == *y,
608 (Self::HandleMember(x), Self::HandleMember(y)) => *x == *y,
609 (Self::StringMember(x), Self::StringMember(y)) => *x == *y,
610 (Self::StructMember(x), Self::StructMember(y)) => *x == *y,
611 (Self::UnionMember(x), Self::UnionMember(y)) => *x == *y,
612 (Self::ArrayMember(x), Self::ArrayMember(y)) => *x == *y,
613 (Self::VectorMember(x), Self::VectorMember(y)) => *x == *y,
614 (Self::TableMember(x), Self::TableMember(y)) => *x == *y,
615 (Self::XunionMember(x), Self::XunionMember(y)) => *x == *y,
616 _ => false,
617 }
618 }
619}
620
621impl AllTypesXunion {
622 #[inline]
623 pub fn ordinal(&self) -> u64 {
624 match *self {
625 Self::BoolMember(_) => 1,
626 Self::Int8Member(_) => 2,
627 Self::Int16Member(_) => 3,
628 Self::Int32Member(_) => 4,
629 Self::Int64Member(_) => 5,
630 Self::Uint8Member(_) => 6,
631 Self::Uint16Member(_) => 7,
632 Self::Uint32Member(_) => 8,
633 Self::Uint64Member(_) => 9,
634 Self::Float32Member(_) => 10,
635 Self::Float64Member(_) => 11,
636 Self::EnumMember(_) => 12,
637 Self::BitsMember(_) => 13,
638 Self::HandleMember(_) => 14,
639 Self::StringMember(_) => 15,
640 Self::StructMember(_) => 16,
641 Self::UnionMember(_) => 17,
642 Self::ArrayMember(_) => 18,
643 Self::VectorMember(_) => 19,
644 Self::TableMember(_) => 20,
645 Self::XunionMember(_) => 21,
646 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
647 }
648 }
649
650 #[inline]
651 pub fn unknown_variant_for_testing() -> Self {
652 Self::__SourceBreaking { unknown_ordinal: 0 }
653 }
654
655 #[inline]
656 pub fn is_unknown(&self) -> bool {
657 match self {
658 Self::__SourceBreaking { .. } => true,
659 _ => false,
660 }
661 }
662}
663
664impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesXunion {}
665
666#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
667pub struct ConfigMarker;
668
669impl fidl::endpoints::ProtocolMarker for ConfigMarker {
670 type Proxy = ConfigProxy;
671 type RequestStream = ConfigRequestStream;
672 #[cfg(target_os = "fuchsia")]
673 type SynchronousProxy = ConfigSynchronousProxy;
674
675 const DEBUG_NAME: &'static str = "fidl.test.compatibility.Config";
676}
677impl fidl::endpoints::DiscoverableProtocolMarker for ConfigMarker {}
678
679pub trait ConfigProxyInterface: Send + Sync {
680 type GetImplsResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>> + Send;
681 fn r#get_impls(&self) -> Self::GetImplsResponseFut;
682}
683#[derive(Debug)]
684#[cfg(target_os = "fuchsia")]
685pub struct ConfigSynchronousProxy {
686 client: fidl::client::sync::Client,
687}
688
689#[cfg(target_os = "fuchsia")]
690impl fidl::endpoints::SynchronousProxy for ConfigSynchronousProxy {
691 type Proxy = ConfigProxy;
692 type Protocol = ConfigMarker;
693
694 fn from_channel(inner: fidl::Channel) -> Self {
695 Self::new(inner)
696 }
697
698 fn into_channel(self) -> fidl::Channel {
699 self.client.into_channel()
700 }
701
702 fn as_channel(&self) -> &fidl::Channel {
703 self.client.as_channel()
704 }
705}
706
707#[cfg(target_os = "fuchsia")]
708impl ConfigSynchronousProxy {
709 pub fn new(channel: fidl::Channel) -> Self {
710 let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
711 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
712 }
713
714 pub fn into_channel(self) -> fidl::Channel {
715 self.client.into_channel()
716 }
717
718 pub fn wait_for_event(
721 &self,
722 deadline: zx::MonotonicInstant,
723 ) -> Result<ConfigEvent, fidl::Error> {
724 ConfigEvent::decode(self.client.wait_for_event(deadline)?)
725 }
726
727 pub fn r#get_impls(
728 &self,
729 ___deadline: zx::MonotonicInstant,
730 ) -> Result<Vec<String>, fidl::Error> {
731 let _response =
732 self.client.send_query::<fidl::encoding::EmptyPayload, ConfigGetImplsResponse>(
733 (),
734 0x3b360c86a6dbdfe0,
735 fidl::encoding::DynamicFlags::empty(),
736 ___deadline,
737 )?;
738 Ok(_response.impls)
739 }
740}
741
742#[cfg(target_os = "fuchsia")]
743impl From<ConfigSynchronousProxy> for zx::Handle {
744 fn from(value: ConfigSynchronousProxy) -> Self {
745 value.into_channel().into()
746 }
747}
748
749#[cfg(target_os = "fuchsia")]
750impl From<fidl::Channel> for ConfigSynchronousProxy {
751 fn from(value: fidl::Channel) -> Self {
752 Self::new(value)
753 }
754}
755
756#[derive(Debug, Clone)]
757pub struct ConfigProxy {
758 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
759}
760
761impl fidl::endpoints::Proxy for ConfigProxy {
762 type Protocol = ConfigMarker;
763
764 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
765 Self::new(inner)
766 }
767
768 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
769 self.client.into_channel().map_err(|client| Self { client })
770 }
771
772 fn as_channel(&self) -> &::fidl::AsyncChannel {
773 self.client.as_channel()
774 }
775}
776
777impl ConfigProxy {
778 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
780 let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
781 Self { client: fidl::client::Client::new(channel, protocol_name) }
782 }
783
784 pub fn take_event_stream(&self) -> ConfigEventStream {
790 ConfigEventStream { event_receiver: self.client.take_event_receiver() }
791 }
792
793 pub fn r#get_impls(
794 &self,
795 ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
796 {
797 ConfigProxyInterface::r#get_impls(self)
798 }
799}
800
801impl ConfigProxyInterface for ConfigProxy {
802 type GetImplsResponseFut =
803 fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
804 fn r#get_impls(&self) -> Self::GetImplsResponseFut {
805 fn _decode(
806 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
807 ) -> Result<Vec<String>, fidl::Error> {
808 let _response = fidl::client::decode_transaction_body::<
809 ConfigGetImplsResponse,
810 fidl::encoding::DefaultFuchsiaResourceDialect,
811 0x3b360c86a6dbdfe0,
812 >(_buf?)?;
813 Ok(_response.impls)
814 }
815 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
816 (),
817 0x3b360c86a6dbdfe0,
818 fidl::encoding::DynamicFlags::empty(),
819 _decode,
820 )
821 }
822}
823
824pub struct ConfigEventStream {
825 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
826}
827
828impl std::marker::Unpin for ConfigEventStream {}
829
830impl futures::stream::FusedStream for ConfigEventStream {
831 fn is_terminated(&self) -> bool {
832 self.event_receiver.is_terminated()
833 }
834}
835
836impl futures::Stream for ConfigEventStream {
837 type Item = Result<ConfigEvent, fidl::Error>;
838
839 fn poll_next(
840 mut self: std::pin::Pin<&mut Self>,
841 cx: &mut std::task::Context<'_>,
842 ) -> std::task::Poll<Option<Self::Item>> {
843 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
844 &mut self.event_receiver,
845 cx
846 )?) {
847 Some(buf) => std::task::Poll::Ready(Some(ConfigEvent::decode(buf))),
848 None => std::task::Poll::Ready(None),
849 }
850 }
851}
852
853#[derive(Debug)]
854pub enum ConfigEvent {}
855
856impl ConfigEvent {
857 fn decode(
859 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
860 ) -> Result<ConfigEvent, fidl::Error> {
861 let (bytes, _handles) = buf.split_mut();
862 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
863 debug_assert_eq!(tx_header.tx_id, 0);
864 match tx_header.ordinal {
865 _ => Err(fidl::Error::UnknownOrdinal {
866 ordinal: tx_header.ordinal,
867 protocol_name: <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
868 }),
869 }
870 }
871}
872
873pub struct ConfigRequestStream {
875 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
876 is_terminated: bool,
877}
878
879impl std::marker::Unpin for ConfigRequestStream {}
880
881impl futures::stream::FusedStream for ConfigRequestStream {
882 fn is_terminated(&self) -> bool {
883 self.is_terminated
884 }
885}
886
887impl fidl::endpoints::RequestStream for ConfigRequestStream {
888 type Protocol = ConfigMarker;
889 type ControlHandle = ConfigControlHandle;
890
891 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
892 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
893 }
894
895 fn control_handle(&self) -> Self::ControlHandle {
896 ConfigControlHandle { inner: self.inner.clone() }
897 }
898
899 fn into_inner(
900 self,
901 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
902 {
903 (self.inner, self.is_terminated)
904 }
905
906 fn from_inner(
907 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
908 is_terminated: bool,
909 ) -> Self {
910 Self { inner, is_terminated }
911 }
912}
913
914impl futures::Stream for ConfigRequestStream {
915 type Item = Result<ConfigRequest, fidl::Error>;
916
917 fn poll_next(
918 mut self: std::pin::Pin<&mut Self>,
919 cx: &mut std::task::Context<'_>,
920 ) -> std::task::Poll<Option<Self::Item>> {
921 let this = &mut *self;
922 if this.inner.check_shutdown(cx) {
923 this.is_terminated = true;
924 return std::task::Poll::Ready(None);
925 }
926 if this.is_terminated {
927 panic!("polled ConfigRequestStream after completion");
928 }
929 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
930 |bytes, handles| {
931 match this.inner.channel().read_etc(cx, bytes, handles) {
932 std::task::Poll::Ready(Ok(())) => {}
933 std::task::Poll::Pending => return std::task::Poll::Pending,
934 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
935 this.is_terminated = true;
936 return std::task::Poll::Ready(None);
937 }
938 std::task::Poll::Ready(Err(e)) => {
939 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
940 e.into(),
941 ))))
942 }
943 }
944
945 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
947
948 std::task::Poll::Ready(Some(match header.ordinal {
949 0x3b360c86a6dbdfe0 => {
950 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
951 let mut req = fidl::new_empty!(
952 fidl::encoding::EmptyPayload,
953 fidl::encoding::DefaultFuchsiaResourceDialect
954 );
955 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
956 let control_handle = ConfigControlHandle { inner: this.inner.clone() };
957 Ok(ConfigRequest::GetImpls {
958 responder: ConfigGetImplsResponder {
959 control_handle: std::mem::ManuallyDrop::new(control_handle),
960 tx_id: header.tx_id,
961 },
962 })
963 }
964 _ => Err(fidl::Error::UnknownOrdinal {
965 ordinal: header.ordinal,
966 protocol_name:
967 <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
968 }),
969 }))
970 },
971 )
972 }
973}
974
975#[derive(Debug)]
976pub enum ConfigRequest {
977 GetImpls { responder: ConfigGetImplsResponder },
978}
979
980impl ConfigRequest {
981 #[allow(irrefutable_let_patterns)]
982 pub fn into_get_impls(self) -> Option<(ConfigGetImplsResponder)> {
983 if let ConfigRequest::GetImpls { responder } = self {
984 Some((responder))
985 } else {
986 None
987 }
988 }
989
990 pub fn method_name(&self) -> &'static str {
992 match *self {
993 ConfigRequest::GetImpls { .. } => "get_impls",
994 }
995 }
996}
997
998#[derive(Debug, Clone)]
999pub struct ConfigControlHandle {
1000 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1001}
1002
1003impl fidl::endpoints::ControlHandle for ConfigControlHandle {
1004 fn shutdown(&self) {
1005 self.inner.shutdown()
1006 }
1007 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1008 self.inner.shutdown_with_epitaph(status)
1009 }
1010
1011 fn is_closed(&self) -> bool {
1012 self.inner.channel().is_closed()
1013 }
1014 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1015 self.inner.channel().on_closed()
1016 }
1017
1018 #[cfg(target_os = "fuchsia")]
1019 fn signal_peer(
1020 &self,
1021 clear_mask: zx::Signals,
1022 set_mask: zx::Signals,
1023 ) -> Result<(), zx_status::Status> {
1024 use fidl::Peered;
1025 self.inner.channel().signal_peer(clear_mask, set_mask)
1026 }
1027}
1028
1029impl ConfigControlHandle {}
1030
1031#[must_use = "FIDL methods require a response to be sent"]
1032#[derive(Debug)]
1033pub struct ConfigGetImplsResponder {
1034 control_handle: std::mem::ManuallyDrop<ConfigControlHandle>,
1035 tx_id: u32,
1036}
1037
1038impl std::ops::Drop for ConfigGetImplsResponder {
1042 fn drop(&mut self) {
1043 self.control_handle.shutdown();
1044 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1046 }
1047}
1048
1049impl fidl::endpoints::Responder for ConfigGetImplsResponder {
1050 type ControlHandle = ConfigControlHandle;
1051
1052 fn control_handle(&self) -> &ConfigControlHandle {
1053 &self.control_handle
1054 }
1055
1056 fn drop_without_shutdown(mut self) {
1057 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1059 std::mem::forget(self);
1061 }
1062}
1063
1064impl ConfigGetImplsResponder {
1065 pub fn send(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1069 let _result = self.send_raw(impls);
1070 if _result.is_err() {
1071 self.control_handle.shutdown();
1072 }
1073 self.drop_without_shutdown();
1074 _result
1075 }
1076
1077 pub fn send_no_shutdown_on_err(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1079 let _result = self.send_raw(impls);
1080 self.drop_without_shutdown();
1081 _result
1082 }
1083
1084 fn send_raw(&self, mut impls: &[String]) -> Result<(), fidl::Error> {
1085 self.control_handle.inner.send::<ConfigGetImplsResponse>(
1086 (impls,),
1087 self.tx_id,
1088 0x3b360c86a6dbdfe0,
1089 fidl::encoding::DynamicFlags::empty(),
1090 )
1091 }
1092}
1093
1094#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1095pub struct EchoMarker;
1096
1097impl fidl::endpoints::ProtocolMarker for EchoMarker {
1098 type Proxy = EchoProxy;
1099 type RequestStream = EchoRequestStream;
1100 #[cfg(target_os = "fuchsia")]
1101 type SynchronousProxy = EchoSynchronousProxy;
1102
1103 const DEBUG_NAME: &'static str = "fidl.test.compatibility.Echo";
1104}
1105impl fidl::endpoints::DiscoverableProtocolMarker for EchoMarker {}
1106pub type EchoEchoMinimalWithErrorResult = Result<(), u32>;
1107pub type EchoEchoStructWithErrorResult = Result<Struct, DefaultEnum>;
1108pub type EchoEchoArraysWithErrorResult = Result<ArraysStruct, DefaultEnum>;
1109pub type EchoEchoVectorsWithErrorResult = Result<VectorsStruct, DefaultEnum>;
1110pub type EchoEchoTableWithErrorResult = Result<AllTypesTable, DefaultEnum>;
1111pub type EchoEchoXunionsWithErrorResult = Result<Vec<AllTypesXunion>, DefaultEnum>;
1112pub type EchoEchoNamedStructWithErrorResult = Result<fidl_fidl_test_imported::SimpleStruct, u32>;
1113pub type EchoEchoTablePayloadWithErrorResult = Result<ResponseTable, DefaultEnum>;
1114pub type EchoEchoUnionPayloadWithErrorResult = Result<ResponseUnion, DefaultEnum>;
1115
1116pub trait EchoProxyInterface: Send + Sync {
1117 type EchoTableRequestComposedResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1118 + Send;
1119 fn r#echo_table_request_composed(
1120 &self,
1121 payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1122 ) -> Self::EchoTableRequestComposedResponseFut;
1123 type EchoUnionResponseWithErrorComposedResponseFut: std::future::Future<
1124 Output = Result<
1125 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1126 fidl::Error,
1127 >,
1128 > + Send;
1129 fn r#echo_union_response_with_error_composed(
1130 &self,
1131 value: i64,
1132 want_absolute_value: bool,
1133 forward_to_server: &str,
1134 result_err: u32,
1135 result_variant: fidl_fidl_test_imported::WantResponse,
1136 ) -> Self::EchoUnionResponseWithErrorComposedResponseFut;
1137 type EchoMinimalResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1138 fn r#echo_minimal(&self, forward_to_server: &str) -> Self::EchoMinimalResponseFut;
1139 type EchoMinimalWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoMinimalWithErrorResult, fidl::Error>>
1140 + Send;
1141 fn r#echo_minimal_with_error(
1142 &self,
1143 forward_to_server: &str,
1144 result_variant: RespondWith,
1145 ) -> Self::EchoMinimalWithErrorResponseFut;
1146 fn r#echo_minimal_no_ret_val(&self, forward_to_server: &str) -> Result<(), fidl::Error>;
1147 type EchoStructResponseFut: std::future::Future<Output = Result<Struct, fidl::Error>> + Send;
1148 fn r#echo_struct(&self, value: Struct, forward_to_server: &str) -> Self::EchoStructResponseFut;
1149 type EchoStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoStructWithErrorResult, fidl::Error>>
1150 + Send;
1151 fn r#echo_struct_with_error(
1152 &self,
1153 value: Struct,
1154 result_err: DefaultEnum,
1155 forward_to_server: &str,
1156 result_variant: RespondWith,
1157 ) -> Self::EchoStructWithErrorResponseFut;
1158 fn r#echo_struct_no_ret_val(
1159 &self,
1160 value: Struct,
1161 forward_to_server: &str,
1162 ) -> Result<(), fidl::Error>;
1163 type EchoArraysResponseFut: std::future::Future<Output = Result<ArraysStruct, fidl::Error>>
1164 + Send;
1165 fn r#echo_arrays(
1166 &self,
1167 value: ArraysStruct,
1168 forward_to_server: &str,
1169 ) -> Self::EchoArraysResponseFut;
1170 type EchoArraysWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoArraysWithErrorResult, fidl::Error>>
1171 + Send;
1172 fn r#echo_arrays_with_error(
1173 &self,
1174 value: ArraysStruct,
1175 result_err: DefaultEnum,
1176 forward_to_server: &str,
1177 result_variant: RespondWith,
1178 ) -> Self::EchoArraysWithErrorResponseFut;
1179 type EchoVectorsResponseFut: std::future::Future<Output = Result<VectorsStruct, fidl::Error>>
1180 + Send;
1181 fn r#echo_vectors(
1182 &self,
1183 value: VectorsStruct,
1184 forward_to_server: &str,
1185 ) -> Self::EchoVectorsResponseFut;
1186 type EchoVectorsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoVectorsWithErrorResult, fidl::Error>>
1187 + Send;
1188 fn r#echo_vectors_with_error(
1189 &self,
1190 value: VectorsStruct,
1191 result_err: DefaultEnum,
1192 forward_to_server: &str,
1193 result_variant: RespondWith,
1194 ) -> Self::EchoVectorsWithErrorResponseFut;
1195 type EchoTableResponseFut: std::future::Future<Output = Result<AllTypesTable, fidl::Error>>
1196 + Send;
1197 fn r#echo_table(
1198 &self,
1199 value: AllTypesTable,
1200 forward_to_server: &str,
1201 ) -> Self::EchoTableResponseFut;
1202 type EchoTableWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTableWithErrorResult, fidl::Error>>
1203 + Send;
1204 fn r#echo_table_with_error(
1205 &self,
1206 value: AllTypesTable,
1207 result_err: DefaultEnum,
1208 forward_to_server: &str,
1209 result_variant: RespondWith,
1210 ) -> Self::EchoTableWithErrorResponseFut;
1211 type EchoXunionsResponseFut: std::future::Future<Output = Result<Vec<AllTypesXunion>, fidl::Error>>
1212 + Send;
1213 fn r#echo_xunions(
1214 &self,
1215 value: Vec<AllTypesXunion>,
1216 forward_to_server: &str,
1217 ) -> Self::EchoXunionsResponseFut;
1218 type EchoXunionsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoXunionsWithErrorResult, fidl::Error>>
1219 + Send;
1220 fn r#echo_xunions_with_error(
1221 &self,
1222 value: Vec<AllTypesXunion>,
1223 result_err: DefaultEnum,
1224 forward_to_server: &str,
1225 result_variant: RespondWith,
1226 ) -> Self::EchoXunionsWithErrorResponseFut;
1227 type EchoNamedStructResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1228 + Send;
1229 fn r#echo_named_struct(
1230 &self,
1231 value: &fidl_fidl_test_imported::SimpleStruct,
1232 forward_to_server: &str,
1233 ) -> Self::EchoNamedStructResponseFut;
1234 type EchoNamedStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoNamedStructWithErrorResult, fidl::Error>>
1235 + Send;
1236 fn r#echo_named_struct_with_error(
1237 &self,
1238 value: &fidl_fidl_test_imported::SimpleStruct,
1239 result_err: u32,
1240 forward_to_server: &str,
1241 result_variant: fidl_fidl_test_imported::WantResponse,
1242 ) -> Self::EchoNamedStructWithErrorResponseFut;
1243 fn r#echo_named_struct_no_ret_val(
1244 &self,
1245 value: &fidl_fidl_test_imported::SimpleStruct,
1246 forward_to_server: &str,
1247 ) -> Result<(), fidl::Error>;
1248 type EchoTablePayloadResponseFut: std::future::Future<Output = Result<ResponseTable, fidl::Error>>
1249 + Send;
1250 fn r#echo_table_payload(&self, payload: &RequestTable) -> Self::EchoTablePayloadResponseFut;
1251 type EchoTablePayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTablePayloadWithErrorResult, fidl::Error>>
1252 + Send;
1253 fn r#echo_table_payload_with_error(
1254 &self,
1255 payload: &EchoEchoTablePayloadWithErrorRequest,
1256 ) -> Self::EchoTablePayloadWithErrorResponseFut;
1257 fn r#echo_table_payload_no_ret_val(&self, payload: &RequestTable) -> Result<(), fidl::Error>;
1258 type EchoUnionPayloadResponseFut: std::future::Future<Output = Result<ResponseUnion, fidl::Error>>
1259 + Send;
1260 fn r#echo_union_payload(&self, payload: &RequestUnion) -> Self::EchoUnionPayloadResponseFut;
1261 type EchoUnionPayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error>>
1262 + Send;
1263 fn r#echo_union_payload_with_error(
1264 &self,
1265 payload: &EchoEchoUnionPayloadWithErrorRequest,
1266 ) -> Self::EchoUnionPayloadWithErrorResponseFut;
1267 fn r#echo_union_payload_no_ret_val(&self, payload: &RequestUnion) -> Result<(), fidl::Error>;
1268}
1269#[derive(Debug)]
1270#[cfg(target_os = "fuchsia")]
1271pub struct EchoSynchronousProxy {
1272 client: fidl::client::sync::Client,
1273}
1274
1275#[cfg(target_os = "fuchsia")]
1276impl fidl::endpoints::SynchronousProxy for EchoSynchronousProxy {
1277 type Proxy = EchoProxy;
1278 type Protocol = EchoMarker;
1279
1280 fn from_channel(inner: fidl::Channel) -> Self {
1281 Self::new(inner)
1282 }
1283
1284 fn into_channel(self) -> fidl::Channel {
1285 self.client.into_channel()
1286 }
1287
1288 fn as_channel(&self) -> &fidl::Channel {
1289 self.client.as_channel()
1290 }
1291}
1292
1293#[cfg(target_os = "fuchsia")]
1294impl EchoSynchronousProxy {
1295 pub fn new(channel: fidl::Channel) -> Self {
1296 let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1297 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1298 }
1299
1300 pub fn into_channel(self) -> fidl::Channel {
1301 self.client.into_channel()
1302 }
1303
1304 pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<EchoEvent, fidl::Error> {
1307 EchoEvent::decode(self.client.wait_for_event(deadline)?)
1308 }
1309
1310 pub fn r#echo_table_request_composed(
1311 &self,
1312 mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1313 ___deadline: zx::MonotonicInstant,
1314 ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1315 let _response = self.client.send_query::<
1316 fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1317 fidl_fidl_test_imported::ResponseStruct,
1318 >(
1319 payload,
1320 0x1d545c738c7a8ee,
1321 fidl::encoding::DynamicFlags::empty(),
1322 ___deadline,
1323 )?;
1324 Ok(_response.value)
1325 }
1326
1327 pub fn r#echo_union_response_with_error_composed(
1328 &self,
1329 mut value: i64,
1330 mut want_absolute_value: bool,
1331 mut forward_to_server: &str,
1332 mut result_err: u32,
1333 mut result_variant: fidl_fidl_test_imported::WantResponse,
1334 ___deadline: zx::MonotonicInstant,
1335 ) -> Result<
1336 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1337 fidl::Error,
1338 > {
1339 let _response = self.client.send_query::<
1340 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
1341 fidl::encoding::ResultType<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse, u32>,
1342 >(
1343 (value, want_absolute_value, forward_to_server, result_err, result_variant,),
1344 0x38a67e88d6106443,
1345 fidl::encoding::DynamicFlags::empty(),
1346 ___deadline,
1347 )?;
1348 Ok(_response.map(|x| x))
1349 }
1350
1351 pub fn r#echo_minimal(
1352 &self,
1353 mut forward_to_server: &str,
1354 ___deadline: zx::MonotonicInstant,
1355 ) -> Result<(), fidl::Error> {
1356 let _response =
1357 self.client.send_query::<EchoEchoMinimalRequest, fidl::encoding::EmptyPayload>(
1358 (forward_to_server,),
1359 0x39edd68c837482ec,
1360 fidl::encoding::DynamicFlags::empty(),
1361 ___deadline,
1362 )?;
1363 Ok(_response)
1364 }
1365
1366 pub fn r#echo_minimal_with_error(
1367 &self,
1368 mut forward_to_server: &str,
1369 mut result_variant: RespondWith,
1370 ___deadline: zx::MonotonicInstant,
1371 ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
1372 let _response = self.client.send_query::<
1373 EchoEchoMinimalWithErrorRequest,
1374 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
1375 >(
1376 (forward_to_server, result_variant,),
1377 0x36f4695996e35acc,
1378 fidl::encoding::DynamicFlags::empty(),
1379 ___deadline,
1380 )?;
1381 Ok(_response.map(|x| x))
1382 }
1383
1384 pub fn r#echo_minimal_no_ret_val(
1385 &self,
1386 mut forward_to_server: &str,
1387 ) -> Result<(), fidl::Error> {
1388 self.client.send::<EchoEchoMinimalNoRetValRequest>(
1389 (forward_to_server,),
1390 0x42693c143e2c3694,
1391 fidl::encoding::DynamicFlags::empty(),
1392 )
1393 }
1394
1395 pub fn r#echo_struct(
1396 &self,
1397 mut value: Struct,
1398 mut forward_to_server: &str,
1399 ___deadline: zx::MonotonicInstant,
1400 ) -> Result<Struct, fidl::Error> {
1401 let _response = self.client.send_query::<EchoEchoStructRequest, EchoEchoStructResponse>(
1402 (&mut value, forward_to_server),
1403 0x4c2f85818cc53f37,
1404 fidl::encoding::DynamicFlags::empty(),
1405 ___deadline,
1406 )?;
1407 Ok(_response.value)
1408 }
1409
1410 pub fn r#echo_struct_with_error(
1411 &self,
1412 mut value: Struct,
1413 mut result_err: DefaultEnum,
1414 mut forward_to_server: &str,
1415 mut result_variant: RespondWith,
1416 ___deadline: zx::MonotonicInstant,
1417 ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
1418 let _response = self.client.send_query::<
1419 EchoEchoStructWithErrorRequest,
1420 fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
1421 >(
1422 (&mut value, result_err, forward_to_server, result_variant,),
1423 0x46cb32652c4c0899,
1424 fidl::encoding::DynamicFlags::empty(),
1425 ___deadline,
1426 )?;
1427 Ok(_response.map(|x| x.value))
1428 }
1429
1430 pub fn r#echo_struct_no_ret_val(
1431 &self,
1432 mut value: Struct,
1433 mut forward_to_server: &str,
1434 ) -> Result<(), fidl::Error> {
1435 self.client.send::<EchoEchoStructNoRetValRequest>(
1436 (&mut value, forward_to_server),
1437 0x1f763e602cf5892a,
1438 fidl::encoding::DynamicFlags::empty(),
1439 )
1440 }
1441
1442 pub fn r#echo_arrays(
1443 &self,
1444 mut value: ArraysStruct,
1445 mut forward_to_server: &str,
1446 ___deadline: zx::MonotonicInstant,
1447 ) -> Result<ArraysStruct, fidl::Error> {
1448 let _response = self.client.send_query::<EchoEchoArraysRequest, EchoEchoArraysResponse>(
1449 (&mut value, forward_to_server),
1450 0x1b6019d5611f2470,
1451 fidl::encoding::DynamicFlags::empty(),
1452 ___deadline,
1453 )?;
1454 Ok(_response.value)
1455 }
1456
1457 pub fn r#echo_arrays_with_error(
1458 &self,
1459 mut value: ArraysStruct,
1460 mut result_err: DefaultEnum,
1461 mut forward_to_server: &str,
1462 mut result_variant: RespondWith,
1463 ___deadline: zx::MonotonicInstant,
1464 ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
1465 let _response = self.client.send_query::<
1466 EchoEchoArraysWithErrorRequest,
1467 fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
1468 >(
1469 (&mut value, result_err, forward_to_server, result_variant,),
1470 0x6dbf26e67e253afa,
1471 fidl::encoding::DynamicFlags::empty(),
1472 ___deadline,
1473 )?;
1474 Ok(_response.map(|x| x.value))
1475 }
1476
1477 pub fn r#echo_vectors(
1478 &self,
1479 mut value: VectorsStruct,
1480 mut forward_to_server: &str,
1481 ___deadline: zx::MonotonicInstant,
1482 ) -> Result<VectorsStruct, fidl::Error> {
1483 let _response = self.client.send_query::<EchoEchoVectorsRequest, EchoEchoVectorsResponse>(
1484 (&mut value, forward_to_server),
1485 0x1582623f0d9f6e5e,
1486 fidl::encoding::DynamicFlags::empty(),
1487 ___deadline,
1488 )?;
1489 Ok(_response.value)
1490 }
1491
1492 pub fn r#echo_vectors_with_error(
1493 &self,
1494 mut value: VectorsStruct,
1495 mut result_err: DefaultEnum,
1496 mut forward_to_server: &str,
1497 mut result_variant: RespondWith,
1498 ___deadline: zx::MonotonicInstant,
1499 ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
1500 let _response = self.client.send_query::<
1501 EchoEchoVectorsWithErrorRequest,
1502 fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
1503 >(
1504 (&mut value, result_err, forward_to_server, result_variant,),
1505 0x730f163401e2b3e5,
1506 fidl::encoding::DynamicFlags::empty(),
1507 ___deadline,
1508 )?;
1509 Ok(_response.map(|x| x.value))
1510 }
1511
1512 pub fn r#echo_table(
1513 &self,
1514 mut value: AllTypesTable,
1515 mut forward_to_server: &str,
1516 ___deadline: zx::MonotonicInstant,
1517 ) -> Result<AllTypesTable, fidl::Error> {
1518 let _response = self.client.send_query::<EchoEchoTableRequest, EchoEchoTableResponse>(
1519 (&mut value, forward_to_server),
1520 0x4f1fb0a512f47c4b,
1521 fidl::encoding::DynamicFlags::empty(),
1522 ___deadline,
1523 )?;
1524 Ok(_response.value)
1525 }
1526
1527 pub fn r#echo_table_with_error(
1528 &self,
1529 mut value: AllTypesTable,
1530 mut result_err: DefaultEnum,
1531 mut forward_to_server: &str,
1532 mut result_variant: RespondWith,
1533 ___deadline: zx::MonotonicInstant,
1534 ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
1535 let _response = self.client.send_query::<
1536 EchoEchoTableWithErrorRequest,
1537 fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
1538 >(
1539 (&mut value, result_err, forward_to_server, result_variant,),
1540 0x44e835cb1eb9a931,
1541 fidl::encoding::DynamicFlags::empty(),
1542 ___deadline,
1543 )?;
1544 Ok(_response.map(|x| x.value))
1545 }
1546
1547 pub fn r#echo_xunions(
1548 &self,
1549 mut value: Vec<AllTypesXunion>,
1550 mut forward_to_server: &str,
1551 ___deadline: zx::MonotonicInstant,
1552 ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
1553 let _response = self.client.send_query::<EchoEchoXunionsRequest, EchoEchoXunionsResponse>(
1554 (value.as_mut(), forward_to_server),
1555 0x3dc181909041a583,
1556 fidl::encoding::DynamicFlags::empty(),
1557 ___deadline,
1558 )?;
1559 Ok(_response.value)
1560 }
1561
1562 pub fn r#echo_xunions_with_error(
1563 &self,
1564 mut value: Vec<AllTypesXunion>,
1565 mut result_err: DefaultEnum,
1566 mut forward_to_server: &str,
1567 mut result_variant: RespondWith,
1568 ___deadline: zx::MonotonicInstant,
1569 ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
1570 let _response = self.client.send_query::<
1571 EchoEchoXunionsWithErrorRequest,
1572 fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
1573 >(
1574 (value.as_mut(), result_err, forward_to_server, result_variant,),
1575 0x75184102667fa766,
1576 fidl::encoding::DynamicFlags::empty(),
1577 ___deadline,
1578 )?;
1579 Ok(_response.map(|x| x.value))
1580 }
1581
1582 pub fn r#echo_named_struct(
1583 &self,
1584 mut value: &fidl_fidl_test_imported::SimpleStruct,
1585 mut forward_to_server: &str,
1586 ___deadline: zx::MonotonicInstant,
1587 ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1588 let _response = self.client.send_query::<
1589 fidl_fidl_test_imported::RequestStruct,
1590 fidl_fidl_test_imported::ResponseStruct,
1591 >(
1592 (value, forward_to_server,),
1593 0xf2d4aa9e65f7111,
1594 fidl::encoding::DynamicFlags::empty(),
1595 ___deadline,
1596 )?;
1597 Ok(_response.value)
1598 }
1599
1600 pub fn r#echo_named_struct_with_error(
1601 &self,
1602 mut value: &fidl_fidl_test_imported::SimpleStruct,
1603 mut result_err: u32,
1604 mut forward_to_server: &str,
1605 mut result_variant: fidl_fidl_test_imported::WantResponse,
1606 ___deadline: zx::MonotonicInstant,
1607 ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
1608 let _response = self.client.send_query::<
1609 fidl_fidl_test_imported::ErrorableRequestStruct,
1610 fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
1611 >(
1612 (value, result_err, forward_to_server, result_variant,),
1613 0x5766fee9e74442e8,
1614 fidl::encoding::DynamicFlags::empty(),
1615 ___deadline,
1616 )?;
1617 Ok(_response.map(|x| x.value))
1618 }
1619
1620 pub fn r#echo_named_struct_no_ret_val(
1621 &self,
1622 mut value: &fidl_fidl_test_imported::SimpleStruct,
1623 mut forward_to_server: &str,
1624 ) -> Result<(), fidl::Error> {
1625 self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
1626 (value, forward_to_server),
1627 0x3a50bbf7d2113ad7,
1628 fidl::encoding::DynamicFlags::empty(),
1629 )
1630 }
1631
1632 pub fn r#echo_table_payload(
1633 &self,
1634 mut payload: &RequestTable,
1635 ___deadline: zx::MonotonicInstant,
1636 ) -> Result<ResponseTable, fidl::Error> {
1637 let _response = self.client.send_query::<RequestTable, ResponseTable>(
1638 payload,
1639 0x641d98087378c003,
1640 fidl::encoding::DynamicFlags::empty(),
1641 ___deadline,
1642 )?;
1643 Ok(_response)
1644 }
1645
1646 pub fn r#echo_table_payload_with_error(
1647 &self,
1648 mut payload: &EchoEchoTablePayloadWithErrorRequest,
1649 ___deadline: zx::MonotonicInstant,
1650 ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
1651 let _response = self.client.send_query::<
1652 EchoEchoTablePayloadWithErrorRequest,
1653 fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
1654 >(
1655 payload,
1656 0x636ed243761ab66d,
1657 fidl::encoding::DynamicFlags::empty(),
1658 ___deadline,
1659 )?;
1660 Ok(_response.map(|x| x))
1661 }
1662
1663 pub fn r#echo_table_payload_no_ret_val(
1664 &self,
1665 mut payload: &RequestTable,
1666 ) -> Result<(), fidl::Error> {
1667 self.client.send::<RequestTable>(
1668 payload,
1669 0x32961f7d718569f8,
1670 fidl::encoding::DynamicFlags::empty(),
1671 )
1672 }
1673
1674 pub fn r#echo_union_payload(
1675 &self,
1676 mut payload: &RequestUnion,
1677 ___deadline: zx::MonotonicInstant,
1678 ) -> Result<ResponseUnion, fidl::Error> {
1679 let _response = self.client.send_query::<RequestUnion, ResponseUnion>(
1680 payload,
1681 0x66def9e793f10c55,
1682 fidl::encoding::DynamicFlags::empty(),
1683 ___deadline,
1684 )?;
1685 Ok(_response)
1686 }
1687
1688 pub fn r#echo_union_payload_with_error(
1689 &self,
1690 mut payload: &EchoEchoUnionPayloadWithErrorRequest,
1691 ___deadline: zx::MonotonicInstant,
1692 ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
1693 let _response = self.client.send_query::<
1694 EchoEchoUnionPayloadWithErrorRequest,
1695 fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
1696 >(
1697 payload,
1698 0x1be890d6e68ef063,
1699 fidl::encoding::DynamicFlags::empty(),
1700 ___deadline,
1701 )?;
1702 Ok(_response.map(|x| x))
1703 }
1704
1705 pub fn r#echo_union_payload_no_ret_val(
1706 &self,
1707 mut payload: &RequestUnion,
1708 ) -> Result<(), fidl::Error> {
1709 self.client.send::<RequestUnion>(
1710 payload,
1711 0x11518bf346430040,
1712 fidl::encoding::DynamicFlags::empty(),
1713 )
1714 }
1715}
1716
1717#[cfg(target_os = "fuchsia")]
1718impl From<EchoSynchronousProxy> for zx::Handle {
1719 fn from(value: EchoSynchronousProxy) -> Self {
1720 value.into_channel().into()
1721 }
1722}
1723
1724#[cfg(target_os = "fuchsia")]
1725impl From<fidl::Channel> for EchoSynchronousProxy {
1726 fn from(value: fidl::Channel) -> Self {
1727 Self::new(value)
1728 }
1729}
1730
1731#[derive(Debug, Clone)]
1732pub struct EchoProxy {
1733 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1734}
1735
1736impl fidl::endpoints::Proxy for EchoProxy {
1737 type Protocol = EchoMarker;
1738
1739 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1740 Self::new(inner)
1741 }
1742
1743 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1744 self.client.into_channel().map_err(|client| Self { client })
1745 }
1746
1747 fn as_channel(&self) -> &::fidl::AsyncChannel {
1748 self.client.as_channel()
1749 }
1750}
1751
1752impl EchoProxy {
1753 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1755 let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1756 Self { client: fidl::client::Client::new(channel, protocol_name) }
1757 }
1758
1759 pub fn take_event_stream(&self) -> EchoEventStream {
1765 EchoEventStream { event_receiver: self.client.take_event_receiver() }
1766 }
1767
1768 pub fn r#echo_table_request_composed(
1769 &self,
1770 mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1771 ) -> fidl::client::QueryResponseFut<
1772 fidl_fidl_test_imported::SimpleStruct,
1773 fidl::encoding::DefaultFuchsiaResourceDialect,
1774 > {
1775 EchoProxyInterface::r#echo_table_request_composed(self, payload)
1776 }
1777
1778 pub fn r#echo_union_response_with_error_composed(
1779 &self,
1780 mut value: i64,
1781 mut want_absolute_value: bool,
1782 mut forward_to_server: &str,
1783 mut result_err: u32,
1784 mut result_variant: fidl_fidl_test_imported::WantResponse,
1785 ) -> fidl::client::QueryResponseFut<
1786 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1787 fidl::encoding::DefaultFuchsiaResourceDialect,
1788 > {
1789 EchoProxyInterface::r#echo_union_response_with_error_composed(
1790 self,
1791 value,
1792 want_absolute_value,
1793 forward_to_server,
1794 result_err,
1795 result_variant,
1796 )
1797 }
1798
1799 pub fn r#echo_minimal(
1800 &self,
1801 mut forward_to_server: &str,
1802 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1803 EchoProxyInterface::r#echo_minimal(self, forward_to_server)
1804 }
1805
1806 pub fn r#echo_minimal_with_error(
1807 &self,
1808 mut forward_to_server: &str,
1809 mut result_variant: RespondWith,
1810 ) -> fidl::client::QueryResponseFut<
1811 EchoEchoMinimalWithErrorResult,
1812 fidl::encoding::DefaultFuchsiaResourceDialect,
1813 > {
1814 EchoProxyInterface::r#echo_minimal_with_error(self, forward_to_server, result_variant)
1815 }
1816
1817 pub fn r#echo_minimal_no_ret_val(
1818 &self,
1819 mut forward_to_server: &str,
1820 ) -> Result<(), fidl::Error> {
1821 EchoProxyInterface::r#echo_minimal_no_ret_val(self, forward_to_server)
1822 }
1823
1824 pub fn r#echo_struct(
1825 &self,
1826 mut value: Struct,
1827 mut forward_to_server: &str,
1828 ) -> fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect> {
1829 EchoProxyInterface::r#echo_struct(self, value, forward_to_server)
1830 }
1831
1832 pub fn r#echo_struct_with_error(
1833 &self,
1834 mut value: Struct,
1835 mut result_err: DefaultEnum,
1836 mut forward_to_server: &str,
1837 mut result_variant: RespondWith,
1838 ) -> fidl::client::QueryResponseFut<
1839 EchoEchoStructWithErrorResult,
1840 fidl::encoding::DefaultFuchsiaResourceDialect,
1841 > {
1842 EchoProxyInterface::r#echo_struct_with_error(
1843 self,
1844 value,
1845 result_err,
1846 forward_to_server,
1847 result_variant,
1848 )
1849 }
1850
1851 pub fn r#echo_struct_no_ret_val(
1852 &self,
1853 mut value: Struct,
1854 mut forward_to_server: &str,
1855 ) -> Result<(), fidl::Error> {
1856 EchoProxyInterface::r#echo_struct_no_ret_val(self, value, forward_to_server)
1857 }
1858
1859 pub fn r#echo_arrays(
1860 &self,
1861 mut value: ArraysStruct,
1862 mut forward_to_server: &str,
1863 ) -> fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1864 {
1865 EchoProxyInterface::r#echo_arrays(self, value, forward_to_server)
1866 }
1867
1868 pub fn r#echo_arrays_with_error(
1869 &self,
1870 mut value: ArraysStruct,
1871 mut result_err: DefaultEnum,
1872 mut forward_to_server: &str,
1873 mut result_variant: RespondWith,
1874 ) -> fidl::client::QueryResponseFut<
1875 EchoEchoArraysWithErrorResult,
1876 fidl::encoding::DefaultFuchsiaResourceDialect,
1877 > {
1878 EchoProxyInterface::r#echo_arrays_with_error(
1879 self,
1880 value,
1881 result_err,
1882 forward_to_server,
1883 result_variant,
1884 )
1885 }
1886
1887 pub fn r#echo_vectors(
1888 &self,
1889 mut value: VectorsStruct,
1890 mut forward_to_server: &str,
1891 ) -> fidl::client::QueryResponseFut<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1892 {
1893 EchoProxyInterface::r#echo_vectors(self, value, forward_to_server)
1894 }
1895
1896 pub fn r#echo_vectors_with_error(
1897 &self,
1898 mut value: VectorsStruct,
1899 mut result_err: DefaultEnum,
1900 mut forward_to_server: &str,
1901 mut result_variant: RespondWith,
1902 ) -> fidl::client::QueryResponseFut<
1903 EchoEchoVectorsWithErrorResult,
1904 fidl::encoding::DefaultFuchsiaResourceDialect,
1905 > {
1906 EchoProxyInterface::r#echo_vectors_with_error(
1907 self,
1908 value,
1909 result_err,
1910 forward_to_server,
1911 result_variant,
1912 )
1913 }
1914
1915 pub fn r#echo_table(
1916 &self,
1917 mut value: AllTypesTable,
1918 mut forward_to_server: &str,
1919 ) -> fidl::client::QueryResponseFut<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
1920 {
1921 EchoProxyInterface::r#echo_table(self, value, forward_to_server)
1922 }
1923
1924 pub fn r#echo_table_with_error(
1925 &self,
1926 mut value: AllTypesTable,
1927 mut result_err: DefaultEnum,
1928 mut forward_to_server: &str,
1929 mut result_variant: RespondWith,
1930 ) -> fidl::client::QueryResponseFut<
1931 EchoEchoTableWithErrorResult,
1932 fidl::encoding::DefaultFuchsiaResourceDialect,
1933 > {
1934 EchoProxyInterface::r#echo_table_with_error(
1935 self,
1936 value,
1937 result_err,
1938 forward_to_server,
1939 result_variant,
1940 )
1941 }
1942
1943 pub fn r#echo_xunions(
1944 &self,
1945 mut value: Vec<AllTypesXunion>,
1946 mut forward_to_server: &str,
1947 ) -> fidl::client::QueryResponseFut<
1948 Vec<AllTypesXunion>,
1949 fidl::encoding::DefaultFuchsiaResourceDialect,
1950 > {
1951 EchoProxyInterface::r#echo_xunions(self, value, forward_to_server)
1952 }
1953
1954 pub fn r#echo_xunions_with_error(
1955 &self,
1956 mut value: Vec<AllTypesXunion>,
1957 mut result_err: DefaultEnum,
1958 mut forward_to_server: &str,
1959 mut result_variant: RespondWith,
1960 ) -> fidl::client::QueryResponseFut<
1961 EchoEchoXunionsWithErrorResult,
1962 fidl::encoding::DefaultFuchsiaResourceDialect,
1963 > {
1964 EchoProxyInterface::r#echo_xunions_with_error(
1965 self,
1966 value,
1967 result_err,
1968 forward_to_server,
1969 result_variant,
1970 )
1971 }
1972
1973 pub fn r#echo_named_struct(
1974 &self,
1975 mut value: &fidl_fidl_test_imported::SimpleStruct,
1976 mut forward_to_server: &str,
1977 ) -> fidl::client::QueryResponseFut<
1978 fidl_fidl_test_imported::SimpleStruct,
1979 fidl::encoding::DefaultFuchsiaResourceDialect,
1980 > {
1981 EchoProxyInterface::r#echo_named_struct(self, value, forward_to_server)
1982 }
1983
1984 pub fn r#echo_named_struct_with_error(
1985 &self,
1986 mut value: &fidl_fidl_test_imported::SimpleStruct,
1987 mut result_err: u32,
1988 mut forward_to_server: &str,
1989 mut result_variant: fidl_fidl_test_imported::WantResponse,
1990 ) -> fidl::client::QueryResponseFut<
1991 EchoEchoNamedStructWithErrorResult,
1992 fidl::encoding::DefaultFuchsiaResourceDialect,
1993 > {
1994 EchoProxyInterface::r#echo_named_struct_with_error(
1995 self,
1996 value,
1997 result_err,
1998 forward_to_server,
1999 result_variant,
2000 )
2001 }
2002
2003 pub fn r#echo_named_struct_no_ret_val(
2004 &self,
2005 mut value: &fidl_fidl_test_imported::SimpleStruct,
2006 mut forward_to_server: &str,
2007 ) -> Result<(), fidl::Error> {
2008 EchoProxyInterface::r#echo_named_struct_no_ret_val(self, value, forward_to_server)
2009 }
2010
2011 pub fn r#echo_table_payload(
2012 &self,
2013 mut payload: &RequestTable,
2014 ) -> fidl::client::QueryResponseFut<ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect>
2015 {
2016 EchoProxyInterface::r#echo_table_payload(self, payload)
2017 }
2018
2019 pub fn r#echo_table_payload_with_error(
2020 &self,
2021 mut payload: &EchoEchoTablePayloadWithErrorRequest,
2022 ) -> fidl::client::QueryResponseFut<
2023 EchoEchoTablePayloadWithErrorResult,
2024 fidl::encoding::DefaultFuchsiaResourceDialect,
2025 > {
2026 EchoProxyInterface::r#echo_table_payload_with_error(self, payload)
2027 }
2028
2029 pub fn r#echo_table_payload_no_ret_val(
2030 &self,
2031 mut payload: &RequestTable,
2032 ) -> Result<(), fidl::Error> {
2033 EchoProxyInterface::r#echo_table_payload_no_ret_val(self, payload)
2034 }
2035
2036 pub fn r#echo_union_payload(
2037 &self,
2038 mut payload: &RequestUnion,
2039 ) -> fidl::client::QueryResponseFut<ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
2040 {
2041 EchoProxyInterface::r#echo_union_payload(self, payload)
2042 }
2043
2044 pub fn r#echo_union_payload_with_error(
2045 &self,
2046 mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2047 ) -> fidl::client::QueryResponseFut<
2048 EchoEchoUnionPayloadWithErrorResult,
2049 fidl::encoding::DefaultFuchsiaResourceDialect,
2050 > {
2051 EchoProxyInterface::r#echo_union_payload_with_error(self, payload)
2052 }
2053
2054 pub fn r#echo_union_payload_no_ret_val(
2055 &self,
2056 mut payload: &RequestUnion,
2057 ) -> Result<(), fidl::Error> {
2058 EchoProxyInterface::r#echo_union_payload_no_ret_val(self, payload)
2059 }
2060}
2061
2062impl EchoProxyInterface for EchoProxy {
2063 type EchoTableRequestComposedResponseFut = fidl::client::QueryResponseFut<
2064 fidl_fidl_test_imported::SimpleStruct,
2065 fidl::encoding::DefaultFuchsiaResourceDialect,
2066 >;
2067 fn r#echo_table_request_composed(
2068 &self,
2069 mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2070 ) -> Self::EchoTableRequestComposedResponseFut {
2071 fn _decode(
2072 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2073 ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2074 let _response = fidl::client::decode_transaction_body::<
2075 fidl_fidl_test_imported::ResponseStruct,
2076 fidl::encoding::DefaultFuchsiaResourceDialect,
2077 0x1d545c738c7a8ee,
2078 >(_buf?)?;
2079 Ok(_response.value)
2080 }
2081 self.client.send_query_and_decode::<
2082 fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2083 fidl_fidl_test_imported::SimpleStruct,
2084 >(
2085 payload,
2086 0x1d545c738c7a8ee,
2087 fidl::encoding::DynamicFlags::empty(),
2088 _decode,
2089 )
2090 }
2091
2092 type EchoUnionResponseWithErrorComposedResponseFut = fidl::client::QueryResponseFut<
2093 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2094 fidl::encoding::DefaultFuchsiaResourceDialect,
2095 >;
2096 fn r#echo_union_response_with_error_composed(
2097 &self,
2098 mut value: i64,
2099 mut want_absolute_value: bool,
2100 mut forward_to_server: &str,
2101 mut result_err: u32,
2102 mut result_variant: fidl_fidl_test_imported::WantResponse,
2103 ) -> Self::EchoUnionResponseWithErrorComposedResponseFut {
2104 fn _decode(
2105 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2106 ) -> Result<
2107 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2108 fidl::Error,
2109 > {
2110 let _response = fidl::client::decode_transaction_body::<
2111 fidl::encoding::ResultType<
2112 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
2113 u32,
2114 >,
2115 fidl::encoding::DefaultFuchsiaResourceDialect,
2116 0x38a67e88d6106443,
2117 >(_buf?)?;
2118 Ok(_response.map(|x| x))
2119 }
2120 self.client.send_query_and_decode::<
2121 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
2122 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2123 >(
2124 (value, want_absolute_value, forward_to_server, result_err, result_variant,),
2125 0x38a67e88d6106443,
2126 fidl::encoding::DynamicFlags::empty(),
2127 _decode,
2128 )
2129 }
2130
2131 type EchoMinimalResponseFut =
2132 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2133 fn r#echo_minimal(&self, mut forward_to_server: &str) -> Self::EchoMinimalResponseFut {
2134 fn _decode(
2135 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2136 ) -> Result<(), fidl::Error> {
2137 let _response = fidl::client::decode_transaction_body::<
2138 fidl::encoding::EmptyPayload,
2139 fidl::encoding::DefaultFuchsiaResourceDialect,
2140 0x39edd68c837482ec,
2141 >(_buf?)?;
2142 Ok(_response)
2143 }
2144 self.client.send_query_and_decode::<EchoEchoMinimalRequest, ()>(
2145 (forward_to_server,),
2146 0x39edd68c837482ec,
2147 fidl::encoding::DynamicFlags::empty(),
2148 _decode,
2149 )
2150 }
2151
2152 type EchoMinimalWithErrorResponseFut = fidl::client::QueryResponseFut<
2153 EchoEchoMinimalWithErrorResult,
2154 fidl::encoding::DefaultFuchsiaResourceDialect,
2155 >;
2156 fn r#echo_minimal_with_error(
2157 &self,
2158 mut forward_to_server: &str,
2159 mut result_variant: RespondWith,
2160 ) -> Self::EchoMinimalWithErrorResponseFut {
2161 fn _decode(
2162 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2163 ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
2164 let _response = fidl::client::decode_transaction_body::<
2165 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
2166 fidl::encoding::DefaultFuchsiaResourceDialect,
2167 0x36f4695996e35acc,
2168 >(_buf?)?;
2169 Ok(_response.map(|x| x))
2170 }
2171 self.client.send_query_and_decode::<
2172 EchoEchoMinimalWithErrorRequest,
2173 EchoEchoMinimalWithErrorResult,
2174 >(
2175 (forward_to_server, result_variant,),
2176 0x36f4695996e35acc,
2177 fidl::encoding::DynamicFlags::empty(),
2178 _decode,
2179 )
2180 }
2181
2182 fn r#echo_minimal_no_ret_val(&self, mut forward_to_server: &str) -> Result<(), fidl::Error> {
2183 self.client.send::<EchoEchoMinimalNoRetValRequest>(
2184 (forward_to_server,),
2185 0x42693c143e2c3694,
2186 fidl::encoding::DynamicFlags::empty(),
2187 )
2188 }
2189
2190 type EchoStructResponseFut =
2191 fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2192 fn r#echo_struct(
2193 &self,
2194 mut value: Struct,
2195 mut forward_to_server: &str,
2196 ) -> Self::EchoStructResponseFut {
2197 fn _decode(
2198 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2199 ) -> Result<Struct, fidl::Error> {
2200 let _response = fidl::client::decode_transaction_body::<
2201 EchoEchoStructResponse,
2202 fidl::encoding::DefaultFuchsiaResourceDialect,
2203 0x4c2f85818cc53f37,
2204 >(_buf?)?;
2205 Ok(_response.value)
2206 }
2207 self.client.send_query_and_decode::<EchoEchoStructRequest, Struct>(
2208 (&mut value, forward_to_server),
2209 0x4c2f85818cc53f37,
2210 fidl::encoding::DynamicFlags::empty(),
2211 _decode,
2212 )
2213 }
2214
2215 type EchoStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2216 EchoEchoStructWithErrorResult,
2217 fidl::encoding::DefaultFuchsiaResourceDialect,
2218 >;
2219 fn r#echo_struct_with_error(
2220 &self,
2221 mut value: Struct,
2222 mut result_err: DefaultEnum,
2223 mut forward_to_server: &str,
2224 mut result_variant: RespondWith,
2225 ) -> Self::EchoStructWithErrorResponseFut {
2226 fn _decode(
2227 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2228 ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
2229 let _response = fidl::client::decode_transaction_body::<
2230 fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
2231 fidl::encoding::DefaultFuchsiaResourceDialect,
2232 0x46cb32652c4c0899,
2233 >(_buf?)?;
2234 Ok(_response.map(|x| x.value))
2235 }
2236 self.client
2237 .send_query_and_decode::<EchoEchoStructWithErrorRequest, EchoEchoStructWithErrorResult>(
2238 (&mut value, result_err, forward_to_server, result_variant),
2239 0x46cb32652c4c0899,
2240 fidl::encoding::DynamicFlags::empty(),
2241 _decode,
2242 )
2243 }
2244
2245 fn r#echo_struct_no_ret_val(
2246 &self,
2247 mut value: Struct,
2248 mut forward_to_server: &str,
2249 ) -> Result<(), fidl::Error> {
2250 self.client.send::<EchoEchoStructNoRetValRequest>(
2251 (&mut value, forward_to_server),
2252 0x1f763e602cf5892a,
2253 fidl::encoding::DynamicFlags::empty(),
2254 )
2255 }
2256
2257 type EchoArraysResponseFut =
2258 fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2259 fn r#echo_arrays(
2260 &self,
2261 mut value: ArraysStruct,
2262 mut forward_to_server: &str,
2263 ) -> Self::EchoArraysResponseFut {
2264 fn _decode(
2265 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2266 ) -> Result<ArraysStruct, fidl::Error> {
2267 let _response = fidl::client::decode_transaction_body::<
2268 EchoEchoArraysResponse,
2269 fidl::encoding::DefaultFuchsiaResourceDialect,
2270 0x1b6019d5611f2470,
2271 >(_buf?)?;
2272 Ok(_response.value)
2273 }
2274 self.client.send_query_and_decode::<EchoEchoArraysRequest, ArraysStruct>(
2275 (&mut value, forward_to_server),
2276 0x1b6019d5611f2470,
2277 fidl::encoding::DynamicFlags::empty(),
2278 _decode,
2279 )
2280 }
2281
2282 type EchoArraysWithErrorResponseFut = fidl::client::QueryResponseFut<
2283 EchoEchoArraysWithErrorResult,
2284 fidl::encoding::DefaultFuchsiaResourceDialect,
2285 >;
2286 fn r#echo_arrays_with_error(
2287 &self,
2288 mut value: ArraysStruct,
2289 mut result_err: DefaultEnum,
2290 mut forward_to_server: &str,
2291 mut result_variant: RespondWith,
2292 ) -> Self::EchoArraysWithErrorResponseFut {
2293 fn _decode(
2294 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2295 ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
2296 let _response = fidl::client::decode_transaction_body::<
2297 fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
2298 fidl::encoding::DefaultFuchsiaResourceDialect,
2299 0x6dbf26e67e253afa,
2300 >(_buf?)?;
2301 Ok(_response.map(|x| x.value))
2302 }
2303 self.client
2304 .send_query_and_decode::<EchoEchoArraysWithErrorRequest, EchoEchoArraysWithErrorResult>(
2305 (&mut value, result_err, forward_to_server, result_variant),
2306 0x6dbf26e67e253afa,
2307 fidl::encoding::DynamicFlags::empty(),
2308 _decode,
2309 )
2310 }
2311
2312 type EchoVectorsResponseFut = fidl::client::QueryResponseFut<
2313 VectorsStruct,
2314 fidl::encoding::DefaultFuchsiaResourceDialect,
2315 >;
2316 fn r#echo_vectors(
2317 &self,
2318 mut value: VectorsStruct,
2319 mut forward_to_server: &str,
2320 ) -> Self::EchoVectorsResponseFut {
2321 fn _decode(
2322 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2323 ) -> Result<VectorsStruct, fidl::Error> {
2324 let _response = fidl::client::decode_transaction_body::<
2325 EchoEchoVectorsResponse,
2326 fidl::encoding::DefaultFuchsiaResourceDialect,
2327 0x1582623f0d9f6e5e,
2328 >(_buf?)?;
2329 Ok(_response.value)
2330 }
2331 self.client.send_query_and_decode::<EchoEchoVectorsRequest, VectorsStruct>(
2332 (&mut value, forward_to_server),
2333 0x1582623f0d9f6e5e,
2334 fidl::encoding::DynamicFlags::empty(),
2335 _decode,
2336 )
2337 }
2338
2339 type EchoVectorsWithErrorResponseFut = fidl::client::QueryResponseFut<
2340 EchoEchoVectorsWithErrorResult,
2341 fidl::encoding::DefaultFuchsiaResourceDialect,
2342 >;
2343 fn r#echo_vectors_with_error(
2344 &self,
2345 mut value: VectorsStruct,
2346 mut result_err: DefaultEnum,
2347 mut forward_to_server: &str,
2348 mut result_variant: RespondWith,
2349 ) -> Self::EchoVectorsWithErrorResponseFut {
2350 fn _decode(
2351 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2352 ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
2353 let _response = fidl::client::decode_transaction_body::<
2354 fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
2355 fidl::encoding::DefaultFuchsiaResourceDialect,
2356 0x730f163401e2b3e5,
2357 >(_buf?)?;
2358 Ok(_response.map(|x| x.value))
2359 }
2360 self.client.send_query_and_decode::<
2361 EchoEchoVectorsWithErrorRequest,
2362 EchoEchoVectorsWithErrorResult,
2363 >(
2364 (&mut value, result_err, forward_to_server, result_variant,),
2365 0x730f163401e2b3e5,
2366 fidl::encoding::DynamicFlags::empty(),
2367 _decode,
2368 )
2369 }
2370
2371 type EchoTableResponseFut = fidl::client::QueryResponseFut<
2372 AllTypesTable,
2373 fidl::encoding::DefaultFuchsiaResourceDialect,
2374 >;
2375 fn r#echo_table(
2376 &self,
2377 mut value: AllTypesTable,
2378 mut forward_to_server: &str,
2379 ) -> Self::EchoTableResponseFut {
2380 fn _decode(
2381 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2382 ) -> Result<AllTypesTable, fidl::Error> {
2383 let _response = fidl::client::decode_transaction_body::<
2384 EchoEchoTableResponse,
2385 fidl::encoding::DefaultFuchsiaResourceDialect,
2386 0x4f1fb0a512f47c4b,
2387 >(_buf?)?;
2388 Ok(_response.value)
2389 }
2390 self.client.send_query_and_decode::<EchoEchoTableRequest, AllTypesTable>(
2391 (&mut value, forward_to_server),
2392 0x4f1fb0a512f47c4b,
2393 fidl::encoding::DynamicFlags::empty(),
2394 _decode,
2395 )
2396 }
2397
2398 type EchoTableWithErrorResponseFut = fidl::client::QueryResponseFut<
2399 EchoEchoTableWithErrorResult,
2400 fidl::encoding::DefaultFuchsiaResourceDialect,
2401 >;
2402 fn r#echo_table_with_error(
2403 &self,
2404 mut value: AllTypesTable,
2405 mut result_err: DefaultEnum,
2406 mut forward_to_server: &str,
2407 mut result_variant: RespondWith,
2408 ) -> Self::EchoTableWithErrorResponseFut {
2409 fn _decode(
2410 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2411 ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
2412 let _response = fidl::client::decode_transaction_body::<
2413 fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
2414 fidl::encoding::DefaultFuchsiaResourceDialect,
2415 0x44e835cb1eb9a931,
2416 >(_buf?)?;
2417 Ok(_response.map(|x| x.value))
2418 }
2419 self.client
2420 .send_query_and_decode::<EchoEchoTableWithErrorRequest, EchoEchoTableWithErrorResult>(
2421 (&mut value, result_err, forward_to_server, result_variant),
2422 0x44e835cb1eb9a931,
2423 fidl::encoding::DynamicFlags::empty(),
2424 _decode,
2425 )
2426 }
2427
2428 type EchoXunionsResponseFut = fidl::client::QueryResponseFut<
2429 Vec<AllTypesXunion>,
2430 fidl::encoding::DefaultFuchsiaResourceDialect,
2431 >;
2432 fn r#echo_xunions(
2433 &self,
2434 mut value: Vec<AllTypesXunion>,
2435 mut forward_to_server: &str,
2436 ) -> Self::EchoXunionsResponseFut {
2437 fn _decode(
2438 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2439 ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
2440 let _response = fidl::client::decode_transaction_body::<
2441 EchoEchoXunionsResponse,
2442 fidl::encoding::DefaultFuchsiaResourceDialect,
2443 0x3dc181909041a583,
2444 >(_buf?)?;
2445 Ok(_response.value)
2446 }
2447 self.client.send_query_and_decode::<EchoEchoXunionsRequest, Vec<AllTypesXunion>>(
2448 (value.as_mut(), forward_to_server),
2449 0x3dc181909041a583,
2450 fidl::encoding::DynamicFlags::empty(),
2451 _decode,
2452 )
2453 }
2454
2455 type EchoXunionsWithErrorResponseFut = fidl::client::QueryResponseFut<
2456 EchoEchoXunionsWithErrorResult,
2457 fidl::encoding::DefaultFuchsiaResourceDialect,
2458 >;
2459 fn r#echo_xunions_with_error(
2460 &self,
2461 mut value: Vec<AllTypesXunion>,
2462 mut result_err: DefaultEnum,
2463 mut forward_to_server: &str,
2464 mut result_variant: RespondWith,
2465 ) -> Self::EchoXunionsWithErrorResponseFut {
2466 fn _decode(
2467 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2468 ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
2469 let _response = fidl::client::decode_transaction_body::<
2470 fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
2471 fidl::encoding::DefaultFuchsiaResourceDialect,
2472 0x75184102667fa766,
2473 >(_buf?)?;
2474 Ok(_response.map(|x| x.value))
2475 }
2476 self.client.send_query_and_decode::<
2477 EchoEchoXunionsWithErrorRequest,
2478 EchoEchoXunionsWithErrorResult,
2479 >(
2480 (value.as_mut(), result_err, forward_to_server, result_variant,),
2481 0x75184102667fa766,
2482 fidl::encoding::DynamicFlags::empty(),
2483 _decode,
2484 )
2485 }
2486
2487 type EchoNamedStructResponseFut = fidl::client::QueryResponseFut<
2488 fidl_fidl_test_imported::SimpleStruct,
2489 fidl::encoding::DefaultFuchsiaResourceDialect,
2490 >;
2491 fn r#echo_named_struct(
2492 &self,
2493 mut value: &fidl_fidl_test_imported::SimpleStruct,
2494 mut forward_to_server: &str,
2495 ) -> Self::EchoNamedStructResponseFut {
2496 fn _decode(
2497 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2498 ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2499 let _response = fidl::client::decode_transaction_body::<
2500 fidl_fidl_test_imported::ResponseStruct,
2501 fidl::encoding::DefaultFuchsiaResourceDialect,
2502 0xf2d4aa9e65f7111,
2503 >(_buf?)?;
2504 Ok(_response.value)
2505 }
2506 self.client.send_query_and_decode::<
2507 fidl_fidl_test_imported::RequestStruct,
2508 fidl_fidl_test_imported::SimpleStruct,
2509 >(
2510 (value, forward_to_server,),
2511 0xf2d4aa9e65f7111,
2512 fidl::encoding::DynamicFlags::empty(),
2513 _decode,
2514 )
2515 }
2516
2517 type EchoNamedStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2518 EchoEchoNamedStructWithErrorResult,
2519 fidl::encoding::DefaultFuchsiaResourceDialect,
2520 >;
2521 fn r#echo_named_struct_with_error(
2522 &self,
2523 mut value: &fidl_fidl_test_imported::SimpleStruct,
2524 mut result_err: u32,
2525 mut forward_to_server: &str,
2526 mut result_variant: fidl_fidl_test_imported::WantResponse,
2527 ) -> Self::EchoNamedStructWithErrorResponseFut {
2528 fn _decode(
2529 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2530 ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
2531 let _response = fidl::client::decode_transaction_body::<
2532 fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
2533 fidl::encoding::DefaultFuchsiaResourceDialect,
2534 0x5766fee9e74442e8,
2535 >(_buf?)?;
2536 Ok(_response.map(|x| x.value))
2537 }
2538 self.client.send_query_and_decode::<
2539 fidl_fidl_test_imported::ErrorableRequestStruct,
2540 EchoEchoNamedStructWithErrorResult,
2541 >(
2542 (value, result_err, forward_to_server, result_variant,),
2543 0x5766fee9e74442e8,
2544 fidl::encoding::DynamicFlags::empty(),
2545 _decode,
2546 )
2547 }
2548
2549 fn r#echo_named_struct_no_ret_val(
2550 &self,
2551 mut value: &fidl_fidl_test_imported::SimpleStruct,
2552 mut forward_to_server: &str,
2553 ) -> Result<(), fidl::Error> {
2554 self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
2555 (value, forward_to_server),
2556 0x3a50bbf7d2113ad7,
2557 fidl::encoding::DynamicFlags::empty(),
2558 )
2559 }
2560
2561 type EchoTablePayloadResponseFut = fidl::client::QueryResponseFut<
2562 ResponseTable,
2563 fidl::encoding::DefaultFuchsiaResourceDialect,
2564 >;
2565 fn r#echo_table_payload(
2566 &self,
2567 mut payload: &RequestTable,
2568 ) -> Self::EchoTablePayloadResponseFut {
2569 fn _decode(
2570 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2571 ) -> Result<ResponseTable, fidl::Error> {
2572 let _response = fidl::client::decode_transaction_body::<
2573 ResponseTable,
2574 fidl::encoding::DefaultFuchsiaResourceDialect,
2575 0x641d98087378c003,
2576 >(_buf?)?;
2577 Ok(_response)
2578 }
2579 self.client.send_query_and_decode::<RequestTable, ResponseTable>(
2580 payload,
2581 0x641d98087378c003,
2582 fidl::encoding::DynamicFlags::empty(),
2583 _decode,
2584 )
2585 }
2586
2587 type EchoTablePayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2588 EchoEchoTablePayloadWithErrorResult,
2589 fidl::encoding::DefaultFuchsiaResourceDialect,
2590 >;
2591 fn r#echo_table_payload_with_error(
2592 &self,
2593 mut payload: &EchoEchoTablePayloadWithErrorRequest,
2594 ) -> Self::EchoTablePayloadWithErrorResponseFut {
2595 fn _decode(
2596 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2597 ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
2598 let _response = fidl::client::decode_transaction_body::<
2599 fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
2600 fidl::encoding::DefaultFuchsiaResourceDialect,
2601 0x636ed243761ab66d,
2602 >(_buf?)?;
2603 Ok(_response.map(|x| x))
2604 }
2605 self.client.send_query_and_decode::<
2606 EchoEchoTablePayloadWithErrorRequest,
2607 EchoEchoTablePayloadWithErrorResult,
2608 >(
2609 payload,
2610 0x636ed243761ab66d,
2611 fidl::encoding::DynamicFlags::empty(),
2612 _decode,
2613 )
2614 }
2615
2616 fn r#echo_table_payload_no_ret_val(
2617 &self,
2618 mut payload: &RequestTable,
2619 ) -> Result<(), fidl::Error> {
2620 self.client.send::<RequestTable>(
2621 payload,
2622 0x32961f7d718569f8,
2623 fidl::encoding::DynamicFlags::empty(),
2624 )
2625 }
2626
2627 type EchoUnionPayloadResponseFut = fidl::client::QueryResponseFut<
2628 ResponseUnion,
2629 fidl::encoding::DefaultFuchsiaResourceDialect,
2630 >;
2631 fn r#echo_union_payload(
2632 &self,
2633 mut payload: &RequestUnion,
2634 ) -> Self::EchoUnionPayloadResponseFut {
2635 fn _decode(
2636 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2637 ) -> Result<ResponseUnion, fidl::Error> {
2638 let _response = fidl::client::decode_transaction_body::<
2639 ResponseUnion,
2640 fidl::encoding::DefaultFuchsiaResourceDialect,
2641 0x66def9e793f10c55,
2642 >(_buf?)?;
2643 Ok(_response)
2644 }
2645 self.client.send_query_and_decode::<RequestUnion, ResponseUnion>(
2646 payload,
2647 0x66def9e793f10c55,
2648 fidl::encoding::DynamicFlags::empty(),
2649 _decode,
2650 )
2651 }
2652
2653 type EchoUnionPayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2654 EchoEchoUnionPayloadWithErrorResult,
2655 fidl::encoding::DefaultFuchsiaResourceDialect,
2656 >;
2657 fn r#echo_union_payload_with_error(
2658 &self,
2659 mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2660 ) -> Self::EchoUnionPayloadWithErrorResponseFut {
2661 fn _decode(
2662 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2663 ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
2664 let _response = fidl::client::decode_transaction_body::<
2665 fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
2666 fidl::encoding::DefaultFuchsiaResourceDialect,
2667 0x1be890d6e68ef063,
2668 >(_buf?)?;
2669 Ok(_response.map(|x| x))
2670 }
2671 self.client.send_query_and_decode::<
2672 EchoEchoUnionPayloadWithErrorRequest,
2673 EchoEchoUnionPayloadWithErrorResult,
2674 >(
2675 payload,
2676 0x1be890d6e68ef063,
2677 fidl::encoding::DynamicFlags::empty(),
2678 _decode,
2679 )
2680 }
2681
2682 fn r#echo_union_payload_no_ret_val(
2683 &self,
2684 mut payload: &RequestUnion,
2685 ) -> Result<(), fidl::Error> {
2686 self.client.send::<RequestUnion>(
2687 payload,
2688 0x11518bf346430040,
2689 fidl::encoding::DynamicFlags::empty(),
2690 )
2691 }
2692}
2693
2694pub struct EchoEventStream {
2695 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2696}
2697
2698impl std::marker::Unpin for EchoEventStream {}
2699
2700impl futures::stream::FusedStream for EchoEventStream {
2701 fn is_terminated(&self) -> bool {
2702 self.event_receiver.is_terminated()
2703 }
2704}
2705
2706impl futures::Stream for EchoEventStream {
2707 type Item = Result<EchoEvent, fidl::Error>;
2708
2709 fn poll_next(
2710 mut self: std::pin::Pin<&mut Self>,
2711 cx: &mut std::task::Context<'_>,
2712 ) -> std::task::Poll<Option<Self::Item>> {
2713 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2714 &mut self.event_receiver,
2715 cx
2716 )?) {
2717 Some(buf) => std::task::Poll::Ready(Some(EchoEvent::decode(buf))),
2718 None => std::task::Poll::Ready(None),
2719 }
2720 }
2721}
2722
2723#[derive(Debug)]
2724pub enum EchoEvent {
2725 EchoMinimalEvent {},
2726 EchoEvent { value: Struct },
2727 OnEchoNamedEvent { value: fidl_fidl_test_imported::SimpleStruct },
2728 OnEchoTablePayloadEvent { payload: ResponseTable },
2729 OnEchoUnionPayloadEvent { payload: ResponseUnion },
2730}
2731
2732impl EchoEvent {
2733 #[allow(irrefutable_let_patterns)]
2734 pub fn into_echo_minimal_event(self) -> Option<()> {
2735 if let EchoEvent::EchoMinimalEvent {} = self {
2736 Some(())
2737 } else {
2738 None
2739 }
2740 }
2741 #[allow(irrefutable_let_patterns)]
2742 pub fn into_echo_event(self) -> Option<Struct> {
2743 if let EchoEvent::EchoEvent { value } = self {
2744 Some((value))
2745 } else {
2746 None
2747 }
2748 }
2749 #[allow(irrefutable_let_patterns)]
2750 pub fn into_on_echo_named_event(self) -> Option<fidl_fidl_test_imported::SimpleStruct> {
2751 if let EchoEvent::OnEchoNamedEvent { value } = self {
2752 Some((value))
2753 } else {
2754 None
2755 }
2756 }
2757 #[allow(irrefutable_let_patterns)]
2758 pub fn into_on_echo_table_payload_event(self) -> Option<ResponseTable> {
2759 if let EchoEvent::OnEchoTablePayloadEvent { payload } = self {
2760 Some((payload))
2761 } else {
2762 None
2763 }
2764 }
2765 #[allow(irrefutable_let_patterns)]
2766 pub fn into_on_echo_union_payload_event(self) -> Option<ResponseUnion> {
2767 if let EchoEvent::OnEchoUnionPayloadEvent { payload } = self {
2768 Some((payload))
2769 } else {
2770 None
2771 }
2772 }
2773
2774 fn decode(
2776 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2777 ) -> Result<EchoEvent, fidl::Error> {
2778 let (bytes, _handles) = buf.split_mut();
2779 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2780 debug_assert_eq!(tx_header.tx_id, 0);
2781 match tx_header.ordinal {
2782 0x273b2029f1a0aee2 => {
2783 let mut out = fidl::new_empty!(
2784 fidl::encoding::EmptyPayload,
2785 fidl::encoding::DefaultFuchsiaResourceDialect
2786 );
2787 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
2788 Ok((EchoEvent::EchoMinimalEvent {}))
2789 }
2790 0x1219e12e0450024 => {
2791 let mut out = fidl::new_empty!(
2792 EchoEchoEventRequest,
2793 fidl::encoding::DefaultFuchsiaResourceDialect
2794 );
2795 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoEventRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
2796 Ok((EchoEvent::EchoEvent { value: out.value }))
2797 }
2798 0x749ebde83348a374 => {
2799 let mut out = fidl::new_empty!(
2800 fidl_fidl_test_imported::ResponseStruct,
2801 fidl::encoding::DefaultFuchsiaResourceDialect
2802 );
2803 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ResponseStruct>(&tx_header, _body_bytes, _handles, &mut out)?;
2804 Ok((EchoEvent::OnEchoNamedEvent { value: out.value }))
2805 }
2806 0x708dddea1cb98430 => {
2807 let mut out =
2808 fidl::new_empty!(ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect);
2809 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseTable>(&tx_header, _body_bytes, _handles, &mut out)?;
2810 Ok((EchoEvent::OnEchoTablePayloadEvent { payload: out }))
2811 }
2812 0x642f4c265a05f4c0 => {
2813 let mut out =
2814 fidl::new_empty!(ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect);
2815 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseUnion>(&tx_header, _body_bytes, _handles, &mut out)?;
2816 Ok((EchoEvent::OnEchoUnionPayloadEvent { payload: out }))
2817 }
2818 _ => Err(fidl::Error::UnknownOrdinal {
2819 ordinal: tx_header.ordinal,
2820 protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2821 }),
2822 }
2823 }
2824}
2825
2826pub struct EchoRequestStream {
2828 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2829 is_terminated: bool,
2830}
2831
2832impl std::marker::Unpin for EchoRequestStream {}
2833
2834impl futures::stream::FusedStream for EchoRequestStream {
2835 fn is_terminated(&self) -> bool {
2836 self.is_terminated
2837 }
2838}
2839
2840impl fidl::endpoints::RequestStream for EchoRequestStream {
2841 type Protocol = EchoMarker;
2842 type ControlHandle = EchoControlHandle;
2843
2844 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2845 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2846 }
2847
2848 fn control_handle(&self) -> Self::ControlHandle {
2849 EchoControlHandle { inner: self.inner.clone() }
2850 }
2851
2852 fn into_inner(
2853 self,
2854 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2855 {
2856 (self.inner, self.is_terminated)
2857 }
2858
2859 fn from_inner(
2860 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2861 is_terminated: bool,
2862 ) -> Self {
2863 Self { inner, is_terminated }
2864 }
2865}
2866
2867impl futures::Stream for EchoRequestStream {
2868 type Item = Result<EchoRequest, fidl::Error>;
2869
2870 fn poll_next(
2871 mut self: std::pin::Pin<&mut Self>,
2872 cx: &mut std::task::Context<'_>,
2873 ) -> std::task::Poll<Option<Self::Item>> {
2874 let this = &mut *self;
2875 if this.inner.check_shutdown(cx) {
2876 this.is_terminated = true;
2877 return std::task::Poll::Ready(None);
2878 }
2879 if this.is_terminated {
2880 panic!("polled EchoRequestStream after completion");
2881 }
2882 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2883 |bytes, handles| {
2884 match this.inner.channel().read_etc(cx, bytes, handles) {
2885 std::task::Poll::Ready(Ok(())) => {}
2886 std::task::Poll::Pending => return std::task::Poll::Pending,
2887 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2888 this.is_terminated = true;
2889 return std::task::Poll::Ready(None);
2890 }
2891 std::task::Poll::Ready(Err(e)) => {
2892 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2893 e.into(),
2894 ))))
2895 }
2896 }
2897
2898 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2900
2901 std::task::Poll::Ready(Some(match header.ordinal {
2902 0x1d545c738c7a8ee => {
2903 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2904 let mut req = fidl::new_empty!(
2905 fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2906 fidl::encoding::DefaultFuchsiaResourceDialect
2907 );
2908 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2909 let control_handle = EchoControlHandle { inner: this.inner.clone() };
2910 Ok(EchoRequest::EchoTableRequestComposed {
2911 payload: req,
2912 responder: EchoEchoTableRequestComposedResponder {
2913 control_handle: std::mem::ManuallyDrop::new(control_handle),
2914 tx_id: header.tx_id,
2915 },
2916 })
2917 }
2918 0x38a67e88d6106443 => {
2919 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2920 let mut req = fidl::new_empty!(fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2921 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2922 let control_handle = EchoControlHandle { inner: this.inner.clone() };
2923 Ok(EchoRequest::EchoUnionResponseWithErrorComposed {
2924 value: req.value,
2925 want_absolute_value: req.want_absolute_value,
2926 forward_to_server: req.forward_to_server,
2927 result_err: req.result_err,
2928 result_variant: req.result_variant,
2929
2930 responder: EchoEchoUnionResponseWithErrorComposedResponder {
2931 control_handle: std::mem::ManuallyDrop::new(control_handle),
2932 tx_id: header.tx_id,
2933 },
2934 })
2935 }
2936 0x39edd68c837482ec => {
2937 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2938 let mut req = fidl::new_empty!(
2939 EchoEchoMinimalRequest,
2940 fidl::encoding::DefaultFuchsiaResourceDialect
2941 );
2942 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalRequest>(&header, _body_bytes, handles, &mut req)?;
2943 let control_handle = EchoControlHandle { inner: this.inner.clone() };
2944 Ok(EchoRequest::EchoMinimal {
2945 forward_to_server: req.forward_to_server,
2946
2947 responder: EchoEchoMinimalResponder {
2948 control_handle: std::mem::ManuallyDrop::new(control_handle),
2949 tx_id: header.tx_id,
2950 },
2951 })
2952 }
2953 0x36f4695996e35acc => {
2954 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2955 let mut req = fidl::new_empty!(
2956 EchoEchoMinimalWithErrorRequest,
2957 fidl::encoding::DefaultFuchsiaResourceDialect
2958 );
2959 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
2960 let control_handle = EchoControlHandle { inner: this.inner.clone() };
2961 Ok(EchoRequest::EchoMinimalWithError {
2962 forward_to_server: req.forward_to_server,
2963 result_variant: req.result_variant,
2964
2965 responder: EchoEchoMinimalWithErrorResponder {
2966 control_handle: std::mem::ManuallyDrop::new(control_handle),
2967 tx_id: header.tx_id,
2968 },
2969 })
2970 }
2971 0x42693c143e2c3694 => {
2972 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2973 let mut req = fidl::new_empty!(
2974 EchoEchoMinimalNoRetValRequest,
2975 fidl::encoding::DefaultFuchsiaResourceDialect
2976 );
2977 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
2978 let control_handle = EchoControlHandle { inner: this.inner.clone() };
2979 Ok(EchoRequest::EchoMinimalNoRetVal {
2980 forward_to_server: req.forward_to_server,
2981
2982 control_handle,
2983 })
2984 }
2985 0x4c2f85818cc53f37 => {
2986 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2987 let mut req = fidl::new_empty!(
2988 EchoEchoStructRequest,
2989 fidl::encoding::DefaultFuchsiaResourceDialect
2990 );
2991 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructRequest>(&header, _body_bytes, handles, &mut req)?;
2992 let control_handle = EchoControlHandle { inner: this.inner.clone() };
2993 Ok(EchoRequest::EchoStruct {
2994 value: req.value,
2995 forward_to_server: req.forward_to_server,
2996
2997 responder: EchoEchoStructResponder {
2998 control_handle: std::mem::ManuallyDrop::new(control_handle),
2999 tx_id: header.tx_id,
3000 },
3001 })
3002 }
3003 0x46cb32652c4c0899 => {
3004 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3005 let mut req = fidl::new_empty!(
3006 EchoEchoStructWithErrorRequest,
3007 fidl::encoding::DefaultFuchsiaResourceDialect
3008 );
3009 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3010 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3011 Ok(EchoRequest::EchoStructWithError {
3012 value: req.value,
3013 result_err: req.result_err,
3014 forward_to_server: req.forward_to_server,
3015 result_variant: req.result_variant,
3016
3017 responder: EchoEchoStructWithErrorResponder {
3018 control_handle: std::mem::ManuallyDrop::new(control_handle),
3019 tx_id: header.tx_id,
3020 },
3021 })
3022 }
3023 0x1f763e602cf5892a => {
3024 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3025 let mut req = fidl::new_empty!(
3026 EchoEchoStructNoRetValRequest,
3027 fidl::encoding::DefaultFuchsiaResourceDialect
3028 );
3029 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3030 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3031 Ok(EchoRequest::EchoStructNoRetVal {
3032 value: req.value,
3033 forward_to_server: req.forward_to_server,
3034
3035 control_handle,
3036 })
3037 }
3038 0x1b6019d5611f2470 => {
3039 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3040 let mut req = fidl::new_empty!(
3041 EchoEchoArraysRequest,
3042 fidl::encoding::DefaultFuchsiaResourceDialect
3043 );
3044 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysRequest>(&header, _body_bytes, handles, &mut req)?;
3045 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3046 Ok(EchoRequest::EchoArrays {
3047 value: req.value,
3048 forward_to_server: req.forward_to_server,
3049
3050 responder: EchoEchoArraysResponder {
3051 control_handle: std::mem::ManuallyDrop::new(control_handle),
3052 tx_id: header.tx_id,
3053 },
3054 })
3055 }
3056 0x6dbf26e67e253afa => {
3057 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3058 let mut req = fidl::new_empty!(
3059 EchoEchoArraysWithErrorRequest,
3060 fidl::encoding::DefaultFuchsiaResourceDialect
3061 );
3062 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3063 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3064 Ok(EchoRequest::EchoArraysWithError {
3065 value: req.value,
3066 result_err: req.result_err,
3067 forward_to_server: req.forward_to_server,
3068 result_variant: req.result_variant,
3069
3070 responder: EchoEchoArraysWithErrorResponder {
3071 control_handle: std::mem::ManuallyDrop::new(control_handle),
3072 tx_id: header.tx_id,
3073 },
3074 })
3075 }
3076 0x1582623f0d9f6e5e => {
3077 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3078 let mut req = fidl::new_empty!(
3079 EchoEchoVectorsRequest,
3080 fidl::encoding::DefaultFuchsiaResourceDialect
3081 );
3082 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsRequest>(&header, _body_bytes, handles, &mut req)?;
3083 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3084 Ok(EchoRequest::EchoVectors {
3085 value: req.value,
3086 forward_to_server: req.forward_to_server,
3087
3088 responder: EchoEchoVectorsResponder {
3089 control_handle: std::mem::ManuallyDrop::new(control_handle),
3090 tx_id: header.tx_id,
3091 },
3092 })
3093 }
3094 0x730f163401e2b3e5 => {
3095 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3096 let mut req = fidl::new_empty!(
3097 EchoEchoVectorsWithErrorRequest,
3098 fidl::encoding::DefaultFuchsiaResourceDialect
3099 );
3100 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3101 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3102 Ok(EchoRequest::EchoVectorsWithError {
3103 value: req.value,
3104 result_err: req.result_err,
3105 forward_to_server: req.forward_to_server,
3106 result_variant: req.result_variant,
3107
3108 responder: EchoEchoVectorsWithErrorResponder {
3109 control_handle: std::mem::ManuallyDrop::new(control_handle),
3110 tx_id: header.tx_id,
3111 },
3112 })
3113 }
3114 0x4f1fb0a512f47c4b => {
3115 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3116 let mut req = fidl::new_empty!(
3117 EchoEchoTableRequest,
3118 fidl::encoding::DefaultFuchsiaResourceDialect
3119 );
3120 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableRequest>(&header, _body_bytes, handles, &mut req)?;
3121 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3122 Ok(EchoRequest::EchoTable {
3123 value: req.value,
3124 forward_to_server: req.forward_to_server,
3125
3126 responder: EchoEchoTableResponder {
3127 control_handle: std::mem::ManuallyDrop::new(control_handle),
3128 tx_id: header.tx_id,
3129 },
3130 })
3131 }
3132 0x44e835cb1eb9a931 => {
3133 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3134 let mut req = fidl::new_empty!(
3135 EchoEchoTableWithErrorRequest,
3136 fidl::encoding::DefaultFuchsiaResourceDialect
3137 );
3138 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3139 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3140 Ok(EchoRequest::EchoTableWithError {
3141 value: req.value,
3142 result_err: req.result_err,
3143 forward_to_server: req.forward_to_server,
3144 result_variant: req.result_variant,
3145
3146 responder: EchoEchoTableWithErrorResponder {
3147 control_handle: std::mem::ManuallyDrop::new(control_handle),
3148 tx_id: header.tx_id,
3149 },
3150 })
3151 }
3152 0x3dc181909041a583 => {
3153 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3154 let mut req = fidl::new_empty!(
3155 EchoEchoXunionsRequest,
3156 fidl::encoding::DefaultFuchsiaResourceDialect
3157 );
3158 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsRequest>(&header, _body_bytes, handles, &mut req)?;
3159 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3160 Ok(EchoRequest::EchoXunions {
3161 value: req.value,
3162 forward_to_server: req.forward_to_server,
3163
3164 responder: EchoEchoXunionsResponder {
3165 control_handle: std::mem::ManuallyDrop::new(control_handle),
3166 tx_id: header.tx_id,
3167 },
3168 })
3169 }
3170 0x75184102667fa766 => {
3171 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3172 let mut req = fidl::new_empty!(
3173 EchoEchoXunionsWithErrorRequest,
3174 fidl::encoding::DefaultFuchsiaResourceDialect
3175 );
3176 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3177 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3178 Ok(EchoRequest::EchoXunionsWithError {
3179 value: req.value,
3180 result_err: req.result_err,
3181 forward_to_server: req.forward_to_server,
3182 result_variant: req.result_variant,
3183
3184 responder: EchoEchoXunionsWithErrorResponder {
3185 control_handle: std::mem::ManuallyDrop::new(control_handle),
3186 tx_id: header.tx_id,
3187 },
3188 })
3189 }
3190 0xf2d4aa9e65f7111 => {
3191 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3192 let mut req = fidl::new_empty!(
3193 fidl_fidl_test_imported::RequestStruct,
3194 fidl::encoding::DefaultFuchsiaResourceDialect
3195 );
3196 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::RequestStruct>(&header, _body_bytes, handles, &mut req)?;
3197 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3198 Ok(EchoRequest::EchoNamedStruct {
3199 value: req.value,
3200 forward_to_server: req.forward_to_server,
3201
3202 responder: EchoEchoNamedStructResponder {
3203 control_handle: std::mem::ManuallyDrop::new(control_handle),
3204 tx_id: header.tx_id,
3205 },
3206 })
3207 }
3208 0x5766fee9e74442e8 => {
3209 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3210 let mut req = fidl::new_empty!(
3211 fidl_fidl_test_imported::ErrorableRequestStruct,
3212 fidl::encoding::DefaultFuchsiaResourceDialect
3213 );
3214 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ErrorableRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3215 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3216 Ok(EchoRequest::EchoNamedStructWithError {
3217 value: req.value,
3218 result_err: req.result_err,
3219 forward_to_server: req.forward_to_server,
3220 result_variant: req.result_variant,
3221
3222 responder: EchoEchoNamedStructWithErrorResponder {
3223 control_handle: std::mem::ManuallyDrop::new(control_handle),
3224 tx_id: header.tx_id,
3225 },
3226 })
3227 }
3228 0x3a50bbf7d2113ad7 => {
3229 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3230 let mut req = fidl::new_empty!(
3231 fidl_fidl_test_imported::EventTriggeringRequestStruct,
3232 fidl::encoding::DefaultFuchsiaResourceDialect
3233 );
3234 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3235 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3236 Ok(EchoRequest::EchoNamedStructNoRetVal {
3237 value: req.value,
3238 forward_to_server: req.forward_to_server,
3239
3240 control_handle,
3241 })
3242 }
3243 0x641d98087378c003 => {
3244 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3245 let mut req = fidl::new_empty!(
3246 RequestTable,
3247 fidl::encoding::DefaultFuchsiaResourceDialect
3248 );
3249 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3250 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3251 Ok(EchoRequest::EchoTablePayload {
3252 payload: req,
3253 responder: EchoEchoTablePayloadResponder {
3254 control_handle: std::mem::ManuallyDrop::new(control_handle),
3255 tx_id: header.tx_id,
3256 },
3257 })
3258 }
3259 0x636ed243761ab66d => {
3260 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3261 let mut req = fidl::new_empty!(
3262 EchoEchoTablePayloadWithErrorRequest,
3263 fidl::encoding::DefaultFuchsiaResourceDialect
3264 );
3265 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTablePayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3266 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3267 Ok(EchoRequest::EchoTablePayloadWithError {
3268 payload: req,
3269 responder: EchoEchoTablePayloadWithErrorResponder {
3270 control_handle: std::mem::ManuallyDrop::new(control_handle),
3271 tx_id: header.tx_id,
3272 },
3273 })
3274 }
3275 0x32961f7d718569f8 => {
3276 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3277 let mut req = fidl::new_empty!(
3278 RequestTable,
3279 fidl::encoding::DefaultFuchsiaResourceDialect
3280 );
3281 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3282 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3283 Ok(EchoRequest::EchoTablePayloadNoRetVal { payload: req, control_handle })
3284 }
3285 0x66def9e793f10c55 => {
3286 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3287 let mut req = fidl::new_empty!(
3288 RequestUnion,
3289 fidl::encoding::DefaultFuchsiaResourceDialect
3290 );
3291 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3292 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3293 Ok(EchoRequest::EchoUnionPayload {
3294 payload: req,
3295 responder: EchoEchoUnionPayloadResponder {
3296 control_handle: std::mem::ManuallyDrop::new(control_handle),
3297 tx_id: header.tx_id,
3298 },
3299 })
3300 }
3301 0x1be890d6e68ef063 => {
3302 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3303 let mut req = fidl::new_empty!(
3304 EchoEchoUnionPayloadWithErrorRequest,
3305 fidl::encoding::DefaultFuchsiaResourceDialect
3306 );
3307 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoUnionPayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3308 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3309 Ok(EchoRequest::EchoUnionPayloadWithError {
3310 payload: req,
3311 responder: EchoEchoUnionPayloadWithErrorResponder {
3312 control_handle: std::mem::ManuallyDrop::new(control_handle),
3313 tx_id: header.tx_id,
3314 },
3315 })
3316 }
3317 0x11518bf346430040 => {
3318 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3319 let mut req = fidl::new_empty!(
3320 RequestUnion,
3321 fidl::encoding::DefaultFuchsiaResourceDialect
3322 );
3323 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3324 let control_handle = EchoControlHandle { inner: this.inner.clone() };
3325 Ok(EchoRequest::EchoUnionPayloadNoRetVal { payload: req, control_handle })
3326 }
3327 _ => Err(fidl::Error::UnknownOrdinal {
3328 ordinal: header.ordinal,
3329 protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3330 }),
3331 }))
3332 },
3333 )
3334 }
3335}
3336
3337#[derive(Debug)]
3338pub enum EchoRequest {
3339 EchoTableRequestComposed {
3340 payload: fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3341 responder: EchoEchoTableRequestComposedResponder,
3342 },
3343 EchoUnionResponseWithErrorComposed {
3344 value: i64,
3345 want_absolute_value: bool,
3346 forward_to_server: String,
3347 result_err: u32,
3348 result_variant: fidl_fidl_test_imported::WantResponse,
3349 responder: EchoEchoUnionResponseWithErrorComposedResponder,
3350 },
3351 EchoMinimal {
3352 forward_to_server: String,
3353 responder: EchoEchoMinimalResponder,
3354 },
3355 EchoMinimalWithError {
3356 forward_to_server: String,
3357 result_variant: RespondWith,
3358 responder: EchoEchoMinimalWithErrorResponder,
3359 },
3360 EchoMinimalNoRetVal {
3361 forward_to_server: String,
3362 control_handle: EchoControlHandle,
3363 },
3364 EchoStruct {
3365 value: Struct,
3366 forward_to_server: String,
3367 responder: EchoEchoStructResponder,
3368 },
3369 EchoStructWithError {
3370 value: Struct,
3371 result_err: DefaultEnum,
3372 forward_to_server: String,
3373 result_variant: RespondWith,
3374 responder: EchoEchoStructWithErrorResponder,
3375 },
3376 EchoStructNoRetVal {
3377 value: Struct,
3378 forward_to_server: String,
3379 control_handle: EchoControlHandle,
3380 },
3381 EchoArrays {
3382 value: ArraysStruct,
3383 forward_to_server: String,
3384 responder: EchoEchoArraysResponder,
3385 },
3386 EchoArraysWithError {
3387 value: ArraysStruct,
3388 result_err: DefaultEnum,
3389 forward_to_server: String,
3390 result_variant: RespondWith,
3391 responder: EchoEchoArraysWithErrorResponder,
3392 },
3393 EchoVectors {
3394 value: VectorsStruct,
3395 forward_to_server: String,
3396 responder: EchoEchoVectorsResponder,
3397 },
3398 EchoVectorsWithError {
3399 value: VectorsStruct,
3400 result_err: DefaultEnum,
3401 forward_to_server: String,
3402 result_variant: RespondWith,
3403 responder: EchoEchoVectorsWithErrorResponder,
3404 },
3405 EchoTable {
3406 value: AllTypesTable,
3407 forward_to_server: String,
3408 responder: EchoEchoTableResponder,
3409 },
3410 EchoTableWithError {
3411 value: AllTypesTable,
3412 result_err: DefaultEnum,
3413 forward_to_server: String,
3414 result_variant: RespondWith,
3415 responder: EchoEchoTableWithErrorResponder,
3416 },
3417 EchoXunions {
3418 value: Vec<AllTypesXunion>,
3419 forward_to_server: String,
3420 responder: EchoEchoXunionsResponder,
3421 },
3422 EchoXunionsWithError {
3423 value: Vec<AllTypesXunion>,
3424 result_err: DefaultEnum,
3425 forward_to_server: String,
3426 result_variant: RespondWith,
3427 responder: EchoEchoXunionsWithErrorResponder,
3428 },
3429 EchoNamedStruct {
3430 value: fidl_fidl_test_imported::SimpleStruct,
3431 forward_to_server: String,
3432 responder: EchoEchoNamedStructResponder,
3433 },
3434 EchoNamedStructWithError {
3435 value: fidl_fidl_test_imported::SimpleStruct,
3436 result_err: u32,
3437 forward_to_server: String,
3438 result_variant: fidl_fidl_test_imported::WantResponse,
3439 responder: EchoEchoNamedStructWithErrorResponder,
3440 },
3441 EchoNamedStructNoRetVal {
3442 value: fidl_fidl_test_imported::SimpleStruct,
3443 forward_to_server: String,
3444 control_handle: EchoControlHandle,
3445 },
3446 EchoTablePayload {
3447 payload: RequestTable,
3448 responder: EchoEchoTablePayloadResponder,
3449 },
3450 EchoTablePayloadWithError {
3451 payload: EchoEchoTablePayloadWithErrorRequest,
3452 responder: EchoEchoTablePayloadWithErrorResponder,
3453 },
3454 EchoTablePayloadNoRetVal {
3455 payload: RequestTable,
3456 control_handle: EchoControlHandle,
3457 },
3458 EchoUnionPayload {
3459 payload: RequestUnion,
3460 responder: EchoEchoUnionPayloadResponder,
3461 },
3462 EchoUnionPayloadWithError {
3463 payload: EchoEchoUnionPayloadWithErrorRequest,
3464 responder: EchoEchoUnionPayloadWithErrorResponder,
3465 },
3466 EchoUnionPayloadNoRetVal {
3467 payload: RequestUnion,
3468 control_handle: EchoControlHandle,
3469 },
3470}
3471
3472impl EchoRequest {
3473 #[allow(irrefutable_let_patterns)]
3474 pub fn into_echo_table_request_composed(
3475 self,
3476 ) -> Option<(
3477 fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3478 EchoEchoTableRequestComposedResponder,
3479 )> {
3480 if let EchoRequest::EchoTableRequestComposed { payload, responder } = self {
3481 Some((payload, responder))
3482 } else {
3483 None
3484 }
3485 }
3486
3487 #[allow(irrefutable_let_patterns)]
3488 pub fn into_echo_union_response_with_error_composed(
3489 self,
3490 ) -> Option<(
3491 i64,
3492 bool,
3493 String,
3494 u32,
3495 fidl_fidl_test_imported::WantResponse,
3496 EchoEchoUnionResponseWithErrorComposedResponder,
3497 )> {
3498 if let EchoRequest::EchoUnionResponseWithErrorComposed {
3499 value,
3500 want_absolute_value,
3501 forward_to_server,
3502 result_err,
3503 result_variant,
3504 responder,
3505 } = self
3506 {
3507 Some((
3508 value,
3509 want_absolute_value,
3510 forward_to_server,
3511 result_err,
3512 result_variant,
3513 responder,
3514 ))
3515 } else {
3516 None
3517 }
3518 }
3519
3520 #[allow(irrefutable_let_patterns)]
3521 pub fn into_echo_minimal(self) -> Option<(String, EchoEchoMinimalResponder)> {
3522 if let EchoRequest::EchoMinimal { forward_to_server, responder } = self {
3523 Some((forward_to_server, responder))
3524 } else {
3525 None
3526 }
3527 }
3528
3529 #[allow(irrefutable_let_patterns)]
3530 pub fn into_echo_minimal_with_error(
3531 self,
3532 ) -> Option<(String, RespondWith, EchoEchoMinimalWithErrorResponder)> {
3533 if let EchoRequest::EchoMinimalWithError { forward_to_server, result_variant, responder } =
3534 self
3535 {
3536 Some((forward_to_server, result_variant, responder))
3537 } else {
3538 None
3539 }
3540 }
3541
3542 #[allow(irrefutable_let_patterns)]
3543 pub fn into_echo_minimal_no_ret_val(self) -> Option<(String, EchoControlHandle)> {
3544 if let EchoRequest::EchoMinimalNoRetVal { forward_to_server, control_handle } = self {
3545 Some((forward_to_server, control_handle))
3546 } else {
3547 None
3548 }
3549 }
3550
3551 #[allow(irrefutable_let_patterns)]
3552 pub fn into_echo_struct(self) -> Option<(Struct, String, EchoEchoStructResponder)> {
3553 if let EchoRequest::EchoStruct { value, forward_to_server, responder } = self {
3554 Some((value, forward_to_server, responder))
3555 } else {
3556 None
3557 }
3558 }
3559
3560 #[allow(irrefutable_let_patterns)]
3561 pub fn into_echo_struct_with_error(
3562 self,
3563 ) -> Option<(Struct, DefaultEnum, String, RespondWith, EchoEchoStructWithErrorResponder)> {
3564 if let EchoRequest::EchoStructWithError {
3565 value,
3566 result_err,
3567 forward_to_server,
3568 result_variant,
3569 responder,
3570 } = self
3571 {
3572 Some((value, result_err, forward_to_server, result_variant, responder))
3573 } else {
3574 None
3575 }
3576 }
3577
3578 #[allow(irrefutable_let_patterns)]
3579 pub fn into_echo_struct_no_ret_val(self) -> Option<(Struct, String, EchoControlHandle)> {
3580 if let EchoRequest::EchoStructNoRetVal { value, forward_to_server, control_handle } = self {
3581 Some((value, forward_to_server, control_handle))
3582 } else {
3583 None
3584 }
3585 }
3586
3587 #[allow(irrefutable_let_patterns)]
3588 pub fn into_echo_arrays(self) -> Option<(ArraysStruct, String, EchoEchoArraysResponder)> {
3589 if let EchoRequest::EchoArrays { value, forward_to_server, responder } = self {
3590 Some((value, forward_to_server, responder))
3591 } else {
3592 None
3593 }
3594 }
3595
3596 #[allow(irrefutable_let_patterns)]
3597 pub fn into_echo_arrays_with_error(
3598 self,
3599 ) -> Option<(ArraysStruct, DefaultEnum, String, RespondWith, EchoEchoArraysWithErrorResponder)>
3600 {
3601 if let EchoRequest::EchoArraysWithError {
3602 value,
3603 result_err,
3604 forward_to_server,
3605 result_variant,
3606 responder,
3607 } = self
3608 {
3609 Some((value, result_err, forward_to_server, result_variant, responder))
3610 } else {
3611 None
3612 }
3613 }
3614
3615 #[allow(irrefutable_let_patterns)]
3616 pub fn into_echo_vectors(self) -> Option<(VectorsStruct, String, EchoEchoVectorsResponder)> {
3617 if let EchoRequest::EchoVectors { value, forward_to_server, responder } = self {
3618 Some((value, forward_to_server, responder))
3619 } else {
3620 None
3621 }
3622 }
3623
3624 #[allow(irrefutable_let_patterns)]
3625 pub fn into_echo_vectors_with_error(
3626 self,
3627 ) -> Option<(VectorsStruct, DefaultEnum, String, RespondWith, EchoEchoVectorsWithErrorResponder)>
3628 {
3629 if let EchoRequest::EchoVectorsWithError {
3630 value,
3631 result_err,
3632 forward_to_server,
3633 result_variant,
3634 responder,
3635 } = self
3636 {
3637 Some((value, result_err, forward_to_server, result_variant, responder))
3638 } else {
3639 None
3640 }
3641 }
3642
3643 #[allow(irrefutable_let_patterns)]
3644 pub fn into_echo_table(self) -> Option<(AllTypesTable, String, EchoEchoTableResponder)> {
3645 if let EchoRequest::EchoTable { value, forward_to_server, responder } = self {
3646 Some((value, forward_to_server, responder))
3647 } else {
3648 None
3649 }
3650 }
3651
3652 #[allow(irrefutable_let_patterns)]
3653 pub fn into_echo_table_with_error(
3654 self,
3655 ) -> Option<(AllTypesTable, DefaultEnum, String, RespondWith, EchoEchoTableWithErrorResponder)>
3656 {
3657 if let EchoRequest::EchoTableWithError {
3658 value,
3659 result_err,
3660 forward_to_server,
3661 result_variant,
3662 responder,
3663 } = self
3664 {
3665 Some((value, result_err, forward_to_server, result_variant, responder))
3666 } else {
3667 None
3668 }
3669 }
3670
3671 #[allow(irrefutable_let_patterns)]
3672 pub fn into_echo_xunions(
3673 self,
3674 ) -> Option<(Vec<AllTypesXunion>, String, EchoEchoXunionsResponder)> {
3675 if let EchoRequest::EchoXunions { value, forward_to_server, responder } = self {
3676 Some((value, forward_to_server, responder))
3677 } else {
3678 None
3679 }
3680 }
3681
3682 #[allow(irrefutable_let_patterns)]
3683 pub fn into_echo_xunions_with_error(
3684 self,
3685 ) -> Option<(
3686 Vec<AllTypesXunion>,
3687 DefaultEnum,
3688 String,
3689 RespondWith,
3690 EchoEchoXunionsWithErrorResponder,
3691 )> {
3692 if let EchoRequest::EchoXunionsWithError {
3693 value,
3694 result_err,
3695 forward_to_server,
3696 result_variant,
3697 responder,
3698 } = self
3699 {
3700 Some((value, result_err, forward_to_server, result_variant, responder))
3701 } else {
3702 None
3703 }
3704 }
3705
3706 #[allow(irrefutable_let_patterns)]
3707 pub fn into_echo_named_struct(
3708 self,
3709 ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoEchoNamedStructResponder)> {
3710 if let EchoRequest::EchoNamedStruct { value, forward_to_server, responder } = self {
3711 Some((value, forward_to_server, responder))
3712 } else {
3713 None
3714 }
3715 }
3716
3717 #[allow(irrefutable_let_patterns)]
3718 pub fn into_echo_named_struct_with_error(
3719 self,
3720 ) -> Option<(
3721 fidl_fidl_test_imported::SimpleStruct,
3722 u32,
3723 String,
3724 fidl_fidl_test_imported::WantResponse,
3725 EchoEchoNamedStructWithErrorResponder,
3726 )> {
3727 if let EchoRequest::EchoNamedStructWithError {
3728 value,
3729 result_err,
3730 forward_to_server,
3731 result_variant,
3732 responder,
3733 } = self
3734 {
3735 Some((value, result_err, forward_to_server, result_variant, responder))
3736 } else {
3737 None
3738 }
3739 }
3740
3741 #[allow(irrefutable_let_patterns)]
3742 pub fn into_echo_named_struct_no_ret_val(
3743 self,
3744 ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoControlHandle)> {
3745 if let EchoRequest::EchoNamedStructNoRetVal { value, forward_to_server, control_handle } =
3746 self
3747 {
3748 Some((value, forward_to_server, control_handle))
3749 } else {
3750 None
3751 }
3752 }
3753
3754 #[allow(irrefutable_let_patterns)]
3755 pub fn into_echo_table_payload(self) -> Option<(RequestTable, EchoEchoTablePayloadResponder)> {
3756 if let EchoRequest::EchoTablePayload { payload, responder } = self {
3757 Some((payload, responder))
3758 } else {
3759 None
3760 }
3761 }
3762
3763 #[allow(irrefutable_let_patterns)]
3764 pub fn into_echo_table_payload_with_error(
3765 self,
3766 ) -> Option<(EchoEchoTablePayloadWithErrorRequest, EchoEchoTablePayloadWithErrorResponder)>
3767 {
3768 if let EchoRequest::EchoTablePayloadWithError { payload, responder } = self {
3769 Some((payload, responder))
3770 } else {
3771 None
3772 }
3773 }
3774
3775 #[allow(irrefutable_let_patterns)]
3776 pub fn into_echo_table_payload_no_ret_val(self) -> Option<(RequestTable, EchoControlHandle)> {
3777 if let EchoRequest::EchoTablePayloadNoRetVal { payload, control_handle } = self {
3778 Some((payload, control_handle))
3779 } else {
3780 None
3781 }
3782 }
3783
3784 #[allow(irrefutable_let_patterns)]
3785 pub fn into_echo_union_payload(self) -> Option<(RequestUnion, EchoEchoUnionPayloadResponder)> {
3786 if let EchoRequest::EchoUnionPayload { payload, responder } = self {
3787 Some((payload, responder))
3788 } else {
3789 None
3790 }
3791 }
3792
3793 #[allow(irrefutable_let_patterns)]
3794 pub fn into_echo_union_payload_with_error(
3795 self,
3796 ) -> Option<(EchoEchoUnionPayloadWithErrorRequest, EchoEchoUnionPayloadWithErrorResponder)>
3797 {
3798 if let EchoRequest::EchoUnionPayloadWithError { payload, responder } = self {
3799 Some((payload, responder))
3800 } else {
3801 None
3802 }
3803 }
3804
3805 #[allow(irrefutable_let_patterns)]
3806 pub fn into_echo_union_payload_no_ret_val(self) -> Option<(RequestUnion, EchoControlHandle)> {
3807 if let EchoRequest::EchoUnionPayloadNoRetVal { payload, control_handle } = self {
3808 Some((payload, control_handle))
3809 } else {
3810 None
3811 }
3812 }
3813
3814 pub fn method_name(&self) -> &'static str {
3816 match *self {
3817 EchoRequest::EchoTableRequestComposed { .. } => "echo_table_request_composed",
3818 EchoRequest::EchoUnionResponseWithErrorComposed { .. } => {
3819 "echo_union_response_with_error_composed"
3820 }
3821 EchoRequest::EchoMinimal { .. } => "echo_minimal",
3822 EchoRequest::EchoMinimalWithError { .. } => "echo_minimal_with_error",
3823 EchoRequest::EchoMinimalNoRetVal { .. } => "echo_minimal_no_ret_val",
3824 EchoRequest::EchoStruct { .. } => "echo_struct",
3825 EchoRequest::EchoStructWithError { .. } => "echo_struct_with_error",
3826 EchoRequest::EchoStructNoRetVal { .. } => "echo_struct_no_ret_val",
3827 EchoRequest::EchoArrays { .. } => "echo_arrays",
3828 EchoRequest::EchoArraysWithError { .. } => "echo_arrays_with_error",
3829 EchoRequest::EchoVectors { .. } => "echo_vectors",
3830 EchoRequest::EchoVectorsWithError { .. } => "echo_vectors_with_error",
3831 EchoRequest::EchoTable { .. } => "echo_table",
3832 EchoRequest::EchoTableWithError { .. } => "echo_table_with_error",
3833 EchoRequest::EchoXunions { .. } => "echo_xunions",
3834 EchoRequest::EchoXunionsWithError { .. } => "echo_xunions_with_error",
3835 EchoRequest::EchoNamedStruct { .. } => "echo_named_struct",
3836 EchoRequest::EchoNamedStructWithError { .. } => "echo_named_struct_with_error",
3837 EchoRequest::EchoNamedStructNoRetVal { .. } => "echo_named_struct_no_ret_val",
3838 EchoRequest::EchoTablePayload { .. } => "echo_table_payload",
3839 EchoRequest::EchoTablePayloadWithError { .. } => "echo_table_payload_with_error",
3840 EchoRequest::EchoTablePayloadNoRetVal { .. } => "echo_table_payload_no_ret_val",
3841 EchoRequest::EchoUnionPayload { .. } => "echo_union_payload",
3842 EchoRequest::EchoUnionPayloadWithError { .. } => "echo_union_payload_with_error",
3843 EchoRequest::EchoUnionPayloadNoRetVal { .. } => "echo_union_payload_no_ret_val",
3844 }
3845 }
3846}
3847
3848#[derive(Debug, Clone)]
3849pub struct EchoControlHandle {
3850 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3851}
3852
3853impl fidl::endpoints::ControlHandle for EchoControlHandle {
3854 fn shutdown(&self) {
3855 self.inner.shutdown()
3856 }
3857 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
3858 self.inner.shutdown_with_epitaph(status)
3859 }
3860
3861 fn is_closed(&self) -> bool {
3862 self.inner.channel().is_closed()
3863 }
3864 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3865 self.inner.channel().on_closed()
3866 }
3867
3868 #[cfg(target_os = "fuchsia")]
3869 fn signal_peer(
3870 &self,
3871 clear_mask: zx::Signals,
3872 set_mask: zx::Signals,
3873 ) -> Result<(), zx_status::Status> {
3874 use fidl::Peered;
3875 self.inner.channel().signal_peer(clear_mask, set_mask)
3876 }
3877}
3878
3879impl EchoControlHandle {
3880 pub fn send_echo_minimal_event(&self) -> Result<(), fidl::Error> {
3881 self.inner.send::<fidl::encoding::EmptyPayload>(
3882 (),
3883 0,
3884 0x273b2029f1a0aee2,
3885 fidl::encoding::DynamicFlags::empty(),
3886 )
3887 }
3888
3889 pub fn send_echo_event(&self, mut value: Struct) -> Result<(), fidl::Error> {
3890 self.inner.send::<EchoEchoEventRequest>(
3891 (&mut value,),
3892 0,
3893 0x1219e12e0450024,
3894 fidl::encoding::DynamicFlags::empty(),
3895 )
3896 }
3897
3898 pub fn send_on_echo_named_event(
3899 &self,
3900 mut value: &fidl_fidl_test_imported::SimpleStruct,
3901 ) -> Result<(), fidl::Error> {
3902 self.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3903 (value,),
3904 0,
3905 0x749ebde83348a374,
3906 fidl::encoding::DynamicFlags::empty(),
3907 )
3908 }
3909
3910 pub fn send_on_echo_table_payload_event(
3911 &self,
3912 mut payload: &ResponseTable,
3913 ) -> Result<(), fidl::Error> {
3914 self.inner.send::<ResponseTable>(
3915 payload,
3916 0,
3917 0x708dddea1cb98430,
3918 fidl::encoding::DynamicFlags::empty(),
3919 )
3920 }
3921
3922 pub fn send_on_echo_union_payload_event(
3923 &self,
3924 mut payload: &ResponseUnion,
3925 ) -> Result<(), fidl::Error> {
3926 self.inner.send::<ResponseUnion>(
3927 payload,
3928 0,
3929 0x642f4c265a05f4c0,
3930 fidl::encoding::DynamicFlags::empty(),
3931 )
3932 }
3933}
3934
3935#[must_use = "FIDL methods require a response to be sent"]
3936#[derive(Debug)]
3937pub struct EchoEchoTableRequestComposedResponder {
3938 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
3939 tx_id: u32,
3940}
3941
3942impl std::ops::Drop for EchoEchoTableRequestComposedResponder {
3946 fn drop(&mut self) {
3947 self.control_handle.shutdown();
3948 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3950 }
3951}
3952
3953impl fidl::endpoints::Responder for EchoEchoTableRequestComposedResponder {
3954 type ControlHandle = EchoControlHandle;
3955
3956 fn control_handle(&self) -> &EchoControlHandle {
3957 &self.control_handle
3958 }
3959
3960 fn drop_without_shutdown(mut self) {
3961 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3963 std::mem::forget(self);
3965 }
3966}
3967
3968impl EchoEchoTableRequestComposedResponder {
3969 pub fn send(
3973 self,
3974 mut value: &fidl_fidl_test_imported::SimpleStruct,
3975 ) -> Result<(), fidl::Error> {
3976 let _result = self.send_raw(value);
3977 if _result.is_err() {
3978 self.control_handle.shutdown();
3979 }
3980 self.drop_without_shutdown();
3981 _result
3982 }
3983
3984 pub fn send_no_shutdown_on_err(
3986 self,
3987 mut value: &fidl_fidl_test_imported::SimpleStruct,
3988 ) -> Result<(), fidl::Error> {
3989 let _result = self.send_raw(value);
3990 self.drop_without_shutdown();
3991 _result
3992 }
3993
3994 fn send_raw(
3995 &self,
3996 mut value: &fidl_fidl_test_imported::SimpleStruct,
3997 ) -> Result<(), fidl::Error> {
3998 self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3999 (value,),
4000 self.tx_id,
4001 0x1d545c738c7a8ee,
4002 fidl::encoding::DynamicFlags::empty(),
4003 )
4004 }
4005}
4006
4007#[must_use = "FIDL methods require a response to be sent"]
4008#[derive(Debug)]
4009pub struct EchoEchoUnionResponseWithErrorComposedResponder {
4010 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4011 tx_id: u32,
4012}
4013
4014impl std::ops::Drop for EchoEchoUnionResponseWithErrorComposedResponder {
4018 fn drop(&mut self) {
4019 self.control_handle.shutdown();
4020 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4022 }
4023}
4024
4025impl fidl::endpoints::Responder for EchoEchoUnionResponseWithErrorComposedResponder {
4026 type ControlHandle = EchoControlHandle;
4027
4028 fn control_handle(&self) -> &EchoControlHandle {
4029 &self.control_handle
4030 }
4031
4032 fn drop_without_shutdown(mut self) {
4033 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4035 std::mem::forget(self);
4037 }
4038}
4039
4040impl EchoEchoUnionResponseWithErrorComposedResponder {
4041 pub fn send(
4045 self,
4046 mut result: Result<
4047 &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4048 u32,
4049 >,
4050 ) -> Result<(), fidl::Error> {
4051 let _result = self.send_raw(result);
4052 if _result.is_err() {
4053 self.control_handle.shutdown();
4054 }
4055 self.drop_without_shutdown();
4056 _result
4057 }
4058
4059 pub fn send_no_shutdown_on_err(
4061 self,
4062 mut result: Result<
4063 &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4064 u32,
4065 >,
4066 ) -> Result<(), fidl::Error> {
4067 let _result = self.send_raw(result);
4068 self.drop_without_shutdown();
4069 _result
4070 }
4071
4072 fn send_raw(
4073 &self,
4074 mut result: Result<
4075 &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4076 u32,
4077 >,
4078 ) -> Result<(), fidl::Error> {
4079 self.control_handle.inner.send::<fidl::encoding::ResultType<
4080 fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4081 u32,
4082 >>(
4083 result,
4084 self.tx_id,
4085 0x38a67e88d6106443,
4086 fidl::encoding::DynamicFlags::empty(),
4087 )
4088 }
4089}
4090
4091#[must_use = "FIDL methods require a response to be sent"]
4092#[derive(Debug)]
4093pub struct EchoEchoMinimalResponder {
4094 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4095 tx_id: u32,
4096}
4097
4098impl std::ops::Drop for EchoEchoMinimalResponder {
4102 fn drop(&mut self) {
4103 self.control_handle.shutdown();
4104 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4106 }
4107}
4108
4109impl fidl::endpoints::Responder for EchoEchoMinimalResponder {
4110 type ControlHandle = EchoControlHandle;
4111
4112 fn control_handle(&self) -> &EchoControlHandle {
4113 &self.control_handle
4114 }
4115
4116 fn drop_without_shutdown(mut self) {
4117 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4119 std::mem::forget(self);
4121 }
4122}
4123
4124impl EchoEchoMinimalResponder {
4125 pub fn send(self) -> Result<(), fidl::Error> {
4129 let _result = self.send_raw();
4130 if _result.is_err() {
4131 self.control_handle.shutdown();
4132 }
4133 self.drop_without_shutdown();
4134 _result
4135 }
4136
4137 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4139 let _result = self.send_raw();
4140 self.drop_without_shutdown();
4141 _result
4142 }
4143
4144 fn send_raw(&self) -> Result<(), fidl::Error> {
4145 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4146 (),
4147 self.tx_id,
4148 0x39edd68c837482ec,
4149 fidl::encoding::DynamicFlags::empty(),
4150 )
4151 }
4152}
4153
4154#[must_use = "FIDL methods require a response to be sent"]
4155#[derive(Debug)]
4156pub struct EchoEchoMinimalWithErrorResponder {
4157 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4158 tx_id: u32,
4159}
4160
4161impl std::ops::Drop for EchoEchoMinimalWithErrorResponder {
4165 fn drop(&mut self) {
4166 self.control_handle.shutdown();
4167 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4169 }
4170}
4171
4172impl fidl::endpoints::Responder for EchoEchoMinimalWithErrorResponder {
4173 type ControlHandle = EchoControlHandle;
4174
4175 fn control_handle(&self) -> &EchoControlHandle {
4176 &self.control_handle
4177 }
4178
4179 fn drop_without_shutdown(mut self) {
4180 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4182 std::mem::forget(self);
4184 }
4185}
4186
4187impl EchoEchoMinimalWithErrorResponder {
4188 pub fn send(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4192 let _result = self.send_raw(result);
4193 if _result.is_err() {
4194 self.control_handle.shutdown();
4195 }
4196 self.drop_without_shutdown();
4197 _result
4198 }
4199
4200 pub fn send_no_shutdown_on_err(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4202 let _result = self.send_raw(result);
4203 self.drop_without_shutdown();
4204 _result
4205 }
4206
4207 fn send_raw(&self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4208 self.control_handle
4209 .inner
4210 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>>(
4211 result,
4212 self.tx_id,
4213 0x36f4695996e35acc,
4214 fidl::encoding::DynamicFlags::empty(),
4215 )
4216 }
4217}
4218
4219#[must_use = "FIDL methods require a response to be sent"]
4220#[derive(Debug)]
4221pub struct EchoEchoStructResponder {
4222 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4223 tx_id: u32,
4224}
4225
4226impl std::ops::Drop for EchoEchoStructResponder {
4230 fn drop(&mut self) {
4231 self.control_handle.shutdown();
4232 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4234 }
4235}
4236
4237impl fidl::endpoints::Responder for EchoEchoStructResponder {
4238 type ControlHandle = EchoControlHandle;
4239
4240 fn control_handle(&self) -> &EchoControlHandle {
4241 &self.control_handle
4242 }
4243
4244 fn drop_without_shutdown(mut self) {
4245 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4247 std::mem::forget(self);
4249 }
4250}
4251
4252impl EchoEchoStructResponder {
4253 pub fn send(self, mut value: Struct) -> Result<(), fidl::Error> {
4257 let _result = self.send_raw(value);
4258 if _result.is_err() {
4259 self.control_handle.shutdown();
4260 }
4261 self.drop_without_shutdown();
4262 _result
4263 }
4264
4265 pub fn send_no_shutdown_on_err(self, mut value: Struct) -> Result<(), fidl::Error> {
4267 let _result = self.send_raw(value);
4268 self.drop_without_shutdown();
4269 _result
4270 }
4271
4272 fn send_raw(&self, mut value: Struct) -> Result<(), fidl::Error> {
4273 self.control_handle.inner.send::<EchoEchoStructResponse>(
4274 (&mut value,),
4275 self.tx_id,
4276 0x4c2f85818cc53f37,
4277 fidl::encoding::DynamicFlags::empty(),
4278 )
4279 }
4280}
4281
4282#[must_use = "FIDL methods require a response to be sent"]
4283#[derive(Debug)]
4284pub struct EchoEchoStructWithErrorResponder {
4285 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4286 tx_id: u32,
4287}
4288
4289impl std::ops::Drop for EchoEchoStructWithErrorResponder {
4293 fn drop(&mut self) {
4294 self.control_handle.shutdown();
4295 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4297 }
4298}
4299
4300impl fidl::endpoints::Responder for EchoEchoStructWithErrorResponder {
4301 type ControlHandle = EchoControlHandle;
4302
4303 fn control_handle(&self) -> &EchoControlHandle {
4304 &self.control_handle
4305 }
4306
4307 fn drop_without_shutdown(mut self) {
4308 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4310 std::mem::forget(self);
4312 }
4313}
4314
4315impl EchoEchoStructWithErrorResponder {
4316 pub fn send(self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4320 let _result = self.send_raw(result);
4321 if _result.is_err() {
4322 self.control_handle.shutdown();
4323 }
4324 self.drop_without_shutdown();
4325 _result
4326 }
4327
4328 pub fn send_no_shutdown_on_err(
4330 self,
4331 mut result: Result<Struct, DefaultEnum>,
4332 ) -> Result<(), fidl::Error> {
4333 let _result = self.send_raw(result);
4334 self.drop_without_shutdown();
4335 _result
4336 }
4337
4338 fn send_raw(&self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4339 self.control_handle.inner.send::<fidl::encoding::ResultType<
4340 EchoEchoStructWithErrorResponse,
4341 DefaultEnum,
4342 >>(
4343 result.as_mut().map_err(|e| *e).map(|value| (value,)),
4344 self.tx_id,
4345 0x46cb32652c4c0899,
4346 fidl::encoding::DynamicFlags::empty(),
4347 )
4348 }
4349}
4350
4351#[must_use = "FIDL methods require a response to be sent"]
4352#[derive(Debug)]
4353pub struct EchoEchoArraysResponder {
4354 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4355 tx_id: u32,
4356}
4357
4358impl std::ops::Drop for EchoEchoArraysResponder {
4362 fn drop(&mut self) {
4363 self.control_handle.shutdown();
4364 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4366 }
4367}
4368
4369impl fidl::endpoints::Responder for EchoEchoArraysResponder {
4370 type ControlHandle = EchoControlHandle;
4371
4372 fn control_handle(&self) -> &EchoControlHandle {
4373 &self.control_handle
4374 }
4375
4376 fn drop_without_shutdown(mut self) {
4377 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4379 std::mem::forget(self);
4381 }
4382}
4383
4384impl EchoEchoArraysResponder {
4385 pub fn send(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4389 let _result = self.send_raw(value);
4390 if _result.is_err() {
4391 self.control_handle.shutdown();
4392 }
4393 self.drop_without_shutdown();
4394 _result
4395 }
4396
4397 pub fn send_no_shutdown_on_err(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4399 let _result = self.send_raw(value);
4400 self.drop_without_shutdown();
4401 _result
4402 }
4403
4404 fn send_raw(&self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4405 self.control_handle.inner.send::<EchoEchoArraysResponse>(
4406 (&mut value,),
4407 self.tx_id,
4408 0x1b6019d5611f2470,
4409 fidl::encoding::DynamicFlags::empty(),
4410 )
4411 }
4412}
4413
4414#[must_use = "FIDL methods require a response to be sent"]
4415#[derive(Debug)]
4416pub struct EchoEchoArraysWithErrorResponder {
4417 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4418 tx_id: u32,
4419}
4420
4421impl std::ops::Drop for EchoEchoArraysWithErrorResponder {
4425 fn drop(&mut self) {
4426 self.control_handle.shutdown();
4427 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4429 }
4430}
4431
4432impl fidl::endpoints::Responder for EchoEchoArraysWithErrorResponder {
4433 type ControlHandle = EchoControlHandle;
4434
4435 fn control_handle(&self) -> &EchoControlHandle {
4436 &self.control_handle
4437 }
4438
4439 fn drop_without_shutdown(mut self) {
4440 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4442 std::mem::forget(self);
4444 }
4445}
4446
4447impl EchoEchoArraysWithErrorResponder {
4448 pub fn send(self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4452 let _result = self.send_raw(result);
4453 if _result.is_err() {
4454 self.control_handle.shutdown();
4455 }
4456 self.drop_without_shutdown();
4457 _result
4458 }
4459
4460 pub fn send_no_shutdown_on_err(
4462 self,
4463 mut result: Result<ArraysStruct, DefaultEnum>,
4464 ) -> Result<(), fidl::Error> {
4465 let _result = self.send_raw(result);
4466 self.drop_without_shutdown();
4467 _result
4468 }
4469
4470 fn send_raw(&self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4471 self.control_handle.inner.send::<fidl::encoding::ResultType<
4472 EchoEchoArraysWithErrorResponse,
4473 DefaultEnum,
4474 >>(
4475 result.as_mut().map_err(|e| *e).map(|value| (value,)),
4476 self.tx_id,
4477 0x6dbf26e67e253afa,
4478 fidl::encoding::DynamicFlags::empty(),
4479 )
4480 }
4481}
4482
4483#[must_use = "FIDL methods require a response to be sent"]
4484#[derive(Debug)]
4485pub struct EchoEchoVectorsResponder {
4486 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4487 tx_id: u32,
4488}
4489
4490impl std::ops::Drop for EchoEchoVectorsResponder {
4494 fn drop(&mut self) {
4495 self.control_handle.shutdown();
4496 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4498 }
4499}
4500
4501impl fidl::endpoints::Responder for EchoEchoVectorsResponder {
4502 type ControlHandle = EchoControlHandle;
4503
4504 fn control_handle(&self) -> &EchoControlHandle {
4505 &self.control_handle
4506 }
4507
4508 fn drop_without_shutdown(mut self) {
4509 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4511 std::mem::forget(self);
4513 }
4514}
4515
4516impl EchoEchoVectorsResponder {
4517 pub fn send(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4521 let _result = self.send_raw(value);
4522 if _result.is_err() {
4523 self.control_handle.shutdown();
4524 }
4525 self.drop_without_shutdown();
4526 _result
4527 }
4528
4529 pub fn send_no_shutdown_on_err(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4531 let _result = self.send_raw(value);
4532 self.drop_without_shutdown();
4533 _result
4534 }
4535
4536 fn send_raw(&self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4537 self.control_handle.inner.send::<EchoEchoVectorsResponse>(
4538 (&mut value,),
4539 self.tx_id,
4540 0x1582623f0d9f6e5e,
4541 fidl::encoding::DynamicFlags::empty(),
4542 )
4543 }
4544}
4545
4546#[must_use = "FIDL methods require a response to be sent"]
4547#[derive(Debug)]
4548pub struct EchoEchoVectorsWithErrorResponder {
4549 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4550 tx_id: u32,
4551}
4552
4553impl std::ops::Drop for EchoEchoVectorsWithErrorResponder {
4557 fn drop(&mut self) {
4558 self.control_handle.shutdown();
4559 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4561 }
4562}
4563
4564impl fidl::endpoints::Responder for EchoEchoVectorsWithErrorResponder {
4565 type ControlHandle = EchoControlHandle;
4566
4567 fn control_handle(&self) -> &EchoControlHandle {
4568 &self.control_handle
4569 }
4570
4571 fn drop_without_shutdown(mut self) {
4572 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4574 std::mem::forget(self);
4576 }
4577}
4578
4579impl EchoEchoVectorsWithErrorResponder {
4580 pub fn send(self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4584 let _result = self.send_raw(result);
4585 if _result.is_err() {
4586 self.control_handle.shutdown();
4587 }
4588 self.drop_without_shutdown();
4589 _result
4590 }
4591
4592 pub fn send_no_shutdown_on_err(
4594 self,
4595 mut result: Result<VectorsStruct, DefaultEnum>,
4596 ) -> Result<(), fidl::Error> {
4597 let _result = self.send_raw(result);
4598 self.drop_without_shutdown();
4599 _result
4600 }
4601
4602 fn send_raw(&self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4603 self.control_handle.inner.send::<fidl::encoding::ResultType<
4604 EchoEchoVectorsWithErrorResponse,
4605 DefaultEnum,
4606 >>(
4607 result.as_mut().map_err(|e| *e).map(|value| (value,)),
4608 self.tx_id,
4609 0x730f163401e2b3e5,
4610 fidl::encoding::DynamicFlags::empty(),
4611 )
4612 }
4613}
4614
4615#[must_use = "FIDL methods require a response to be sent"]
4616#[derive(Debug)]
4617pub struct EchoEchoTableResponder {
4618 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4619 tx_id: u32,
4620}
4621
4622impl std::ops::Drop for EchoEchoTableResponder {
4626 fn drop(&mut self) {
4627 self.control_handle.shutdown();
4628 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4630 }
4631}
4632
4633impl fidl::endpoints::Responder for EchoEchoTableResponder {
4634 type ControlHandle = EchoControlHandle;
4635
4636 fn control_handle(&self) -> &EchoControlHandle {
4637 &self.control_handle
4638 }
4639
4640 fn drop_without_shutdown(mut self) {
4641 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4643 std::mem::forget(self);
4645 }
4646}
4647
4648impl EchoEchoTableResponder {
4649 pub fn send(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4653 let _result = self.send_raw(value);
4654 if _result.is_err() {
4655 self.control_handle.shutdown();
4656 }
4657 self.drop_without_shutdown();
4658 _result
4659 }
4660
4661 pub fn send_no_shutdown_on_err(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4663 let _result = self.send_raw(value);
4664 self.drop_without_shutdown();
4665 _result
4666 }
4667
4668 fn send_raw(&self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4669 self.control_handle.inner.send::<EchoEchoTableResponse>(
4670 (&mut value,),
4671 self.tx_id,
4672 0x4f1fb0a512f47c4b,
4673 fidl::encoding::DynamicFlags::empty(),
4674 )
4675 }
4676}
4677
4678#[must_use = "FIDL methods require a response to be sent"]
4679#[derive(Debug)]
4680pub struct EchoEchoTableWithErrorResponder {
4681 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4682 tx_id: u32,
4683}
4684
4685impl std::ops::Drop for EchoEchoTableWithErrorResponder {
4689 fn drop(&mut self) {
4690 self.control_handle.shutdown();
4691 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4693 }
4694}
4695
4696impl fidl::endpoints::Responder for EchoEchoTableWithErrorResponder {
4697 type ControlHandle = EchoControlHandle;
4698
4699 fn control_handle(&self) -> &EchoControlHandle {
4700 &self.control_handle
4701 }
4702
4703 fn drop_without_shutdown(mut self) {
4704 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4706 std::mem::forget(self);
4708 }
4709}
4710
4711impl EchoEchoTableWithErrorResponder {
4712 pub fn send(self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4716 let _result = self.send_raw(result);
4717 if _result.is_err() {
4718 self.control_handle.shutdown();
4719 }
4720 self.drop_without_shutdown();
4721 _result
4722 }
4723
4724 pub fn send_no_shutdown_on_err(
4726 self,
4727 mut result: Result<AllTypesTable, DefaultEnum>,
4728 ) -> Result<(), fidl::Error> {
4729 let _result = self.send_raw(result);
4730 self.drop_without_shutdown();
4731 _result
4732 }
4733
4734 fn send_raw(&self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4735 self.control_handle.inner.send::<fidl::encoding::ResultType<
4736 EchoEchoTableWithErrorResponse,
4737 DefaultEnum,
4738 >>(
4739 result.as_mut().map_err(|e| *e).map(|value| (value,)),
4740 self.tx_id,
4741 0x44e835cb1eb9a931,
4742 fidl::encoding::DynamicFlags::empty(),
4743 )
4744 }
4745}
4746
4747#[must_use = "FIDL methods require a response to be sent"]
4748#[derive(Debug)]
4749pub struct EchoEchoXunionsResponder {
4750 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4751 tx_id: u32,
4752}
4753
4754impl std::ops::Drop for EchoEchoXunionsResponder {
4758 fn drop(&mut self) {
4759 self.control_handle.shutdown();
4760 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4762 }
4763}
4764
4765impl fidl::endpoints::Responder for EchoEchoXunionsResponder {
4766 type ControlHandle = EchoControlHandle;
4767
4768 fn control_handle(&self) -> &EchoControlHandle {
4769 &self.control_handle
4770 }
4771
4772 fn drop_without_shutdown(mut self) {
4773 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4775 std::mem::forget(self);
4777 }
4778}
4779
4780impl EchoEchoXunionsResponder {
4781 pub fn send(self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4785 let _result = self.send_raw(value);
4786 if _result.is_err() {
4787 self.control_handle.shutdown();
4788 }
4789 self.drop_without_shutdown();
4790 _result
4791 }
4792
4793 pub fn send_no_shutdown_on_err(
4795 self,
4796 mut value: Vec<AllTypesXunion>,
4797 ) -> Result<(), fidl::Error> {
4798 let _result = self.send_raw(value);
4799 self.drop_without_shutdown();
4800 _result
4801 }
4802
4803 fn send_raw(&self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4804 self.control_handle.inner.send::<EchoEchoXunionsResponse>(
4805 (value.as_mut(),),
4806 self.tx_id,
4807 0x3dc181909041a583,
4808 fidl::encoding::DynamicFlags::empty(),
4809 )
4810 }
4811}
4812
4813#[must_use = "FIDL methods require a response to be sent"]
4814#[derive(Debug)]
4815pub struct EchoEchoXunionsWithErrorResponder {
4816 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4817 tx_id: u32,
4818}
4819
4820impl std::ops::Drop for EchoEchoXunionsWithErrorResponder {
4824 fn drop(&mut self) {
4825 self.control_handle.shutdown();
4826 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4828 }
4829}
4830
4831impl fidl::endpoints::Responder for EchoEchoXunionsWithErrorResponder {
4832 type ControlHandle = EchoControlHandle;
4833
4834 fn control_handle(&self) -> &EchoControlHandle {
4835 &self.control_handle
4836 }
4837
4838 fn drop_without_shutdown(mut self) {
4839 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4841 std::mem::forget(self);
4843 }
4844}
4845
4846impl EchoEchoXunionsWithErrorResponder {
4847 pub fn send(
4851 self,
4852 mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4853 ) -> Result<(), fidl::Error> {
4854 let _result = self.send_raw(result);
4855 if _result.is_err() {
4856 self.control_handle.shutdown();
4857 }
4858 self.drop_without_shutdown();
4859 _result
4860 }
4861
4862 pub fn send_no_shutdown_on_err(
4864 self,
4865 mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4866 ) -> Result<(), fidl::Error> {
4867 let _result = self.send_raw(result);
4868 self.drop_without_shutdown();
4869 _result
4870 }
4871
4872 fn send_raw(
4873 &self,
4874 mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4875 ) -> Result<(), fidl::Error> {
4876 self.control_handle.inner.send::<fidl::encoding::ResultType<
4877 EchoEchoXunionsWithErrorResponse,
4878 DefaultEnum,
4879 >>(
4880 result.as_mut().map_err(|e| *e).map(|value| (value.as_mut_slice(),)),
4881 self.tx_id,
4882 0x75184102667fa766,
4883 fidl::encoding::DynamicFlags::empty(),
4884 )
4885 }
4886}
4887
4888#[must_use = "FIDL methods require a response to be sent"]
4889#[derive(Debug)]
4890pub struct EchoEchoNamedStructResponder {
4891 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4892 tx_id: u32,
4893}
4894
4895impl std::ops::Drop for EchoEchoNamedStructResponder {
4899 fn drop(&mut self) {
4900 self.control_handle.shutdown();
4901 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4903 }
4904}
4905
4906impl fidl::endpoints::Responder for EchoEchoNamedStructResponder {
4907 type ControlHandle = EchoControlHandle;
4908
4909 fn control_handle(&self) -> &EchoControlHandle {
4910 &self.control_handle
4911 }
4912
4913 fn drop_without_shutdown(mut self) {
4914 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4916 std::mem::forget(self);
4918 }
4919}
4920
4921impl EchoEchoNamedStructResponder {
4922 pub fn send(
4926 self,
4927 mut value: &fidl_fidl_test_imported::SimpleStruct,
4928 ) -> Result<(), fidl::Error> {
4929 let _result = self.send_raw(value);
4930 if _result.is_err() {
4931 self.control_handle.shutdown();
4932 }
4933 self.drop_without_shutdown();
4934 _result
4935 }
4936
4937 pub fn send_no_shutdown_on_err(
4939 self,
4940 mut value: &fidl_fidl_test_imported::SimpleStruct,
4941 ) -> Result<(), fidl::Error> {
4942 let _result = self.send_raw(value);
4943 self.drop_without_shutdown();
4944 _result
4945 }
4946
4947 fn send_raw(
4948 &self,
4949 mut value: &fidl_fidl_test_imported::SimpleStruct,
4950 ) -> Result<(), fidl::Error> {
4951 self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4952 (value,),
4953 self.tx_id,
4954 0xf2d4aa9e65f7111,
4955 fidl::encoding::DynamicFlags::empty(),
4956 )
4957 }
4958}
4959
4960#[must_use = "FIDL methods require a response to be sent"]
4961#[derive(Debug)]
4962pub struct EchoEchoNamedStructWithErrorResponder {
4963 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4964 tx_id: u32,
4965}
4966
4967impl std::ops::Drop for EchoEchoNamedStructWithErrorResponder {
4971 fn drop(&mut self) {
4972 self.control_handle.shutdown();
4973 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4975 }
4976}
4977
4978impl fidl::endpoints::Responder for EchoEchoNamedStructWithErrorResponder {
4979 type ControlHandle = EchoControlHandle;
4980
4981 fn control_handle(&self) -> &EchoControlHandle {
4982 &self.control_handle
4983 }
4984
4985 fn drop_without_shutdown(mut self) {
4986 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4988 std::mem::forget(self);
4990 }
4991}
4992
4993impl EchoEchoNamedStructWithErrorResponder {
4994 pub fn send(
4998 self,
4999 mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5000 ) -> Result<(), fidl::Error> {
5001 let _result = self.send_raw(result);
5002 if _result.is_err() {
5003 self.control_handle.shutdown();
5004 }
5005 self.drop_without_shutdown();
5006 _result
5007 }
5008
5009 pub fn send_no_shutdown_on_err(
5011 self,
5012 mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5013 ) -> Result<(), fidl::Error> {
5014 let _result = self.send_raw(result);
5015 self.drop_without_shutdown();
5016 _result
5017 }
5018
5019 fn send_raw(
5020 &self,
5021 mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5022 ) -> Result<(), fidl::Error> {
5023 self.control_handle.inner.send::<fidl::encoding::ResultType<
5024 fidl_fidl_test_imported::ResponseStruct,
5025 u32,
5026 >>(
5027 result.map(|value| (value,)),
5028 self.tx_id,
5029 0x5766fee9e74442e8,
5030 fidl::encoding::DynamicFlags::empty(),
5031 )
5032 }
5033}
5034
5035#[must_use = "FIDL methods require a response to be sent"]
5036#[derive(Debug)]
5037pub struct EchoEchoTablePayloadResponder {
5038 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5039 tx_id: u32,
5040}
5041
5042impl std::ops::Drop for EchoEchoTablePayloadResponder {
5046 fn drop(&mut self) {
5047 self.control_handle.shutdown();
5048 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5050 }
5051}
5052
5053impl fidl::endpoints::Responder for EchoEchoTablePayloadResponder {
5054 type ControlHandle = EchoControlHandle;
5055
5056 fn control_handle(&self) -> &EchoControlHandle {
5057 &self.control_handle
5058 }
5059
5060 fn drop_without_shutdown(mut self) {
5061 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5063 std::mem::forget(self);
5065 }
5066}
5067
5068impl EchoEchoTablePayloadResponder {
5069 pub fn send(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5073 let _result = self.send_raw(payload);
5074 if _result.is_err() {
5075 self.control_handle.shutdown();
5076 }
5077 self.drop_without_shutdown();
5078 _result
5079 }
5080
5081 pub fn send_no_shutdown_on_err(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5083 let _result = self.send_raw(payload);
5084 self.drop_without_shutdown();
5085 _result
5086 }
5087
5088 fn send_raw(&self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5089 self.control_handle.inner.send::<ResponseTable>(
5090 payload,
5091 self.tx_id,
5092 0x641d98087378c003,
5093 fidl::encoding::DynamicFlags::empty(),
5094 )
5095 }
5096}
5097
5098#[must_use = "FIDL methods require a response to be sent"]
5099#[derive(Debug)]
5100pub struct EchoEchoTablePayloadWithErrorResponder {
5101 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5102 tx_id: u32,
5103}
5104
5105impl std::ops::Drop for EchoEchoTablePayloadWithErrorResponder {
5109 fn drop(&mut self) {
5110 self.control_handle.shutdown();
5111 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5113 }
5114}
5115
5116impl fidl::endpoints::Responder for EchoEchoTablePayloadWithErrorResponder {
5117 type ControlHandle = EchoControlHandle;
5118
5119 fn control_handle(&self) -> &EchoControlHandle {
5120 &self.control_handle
5121 }
5122
5123 fn drop_without_shutdown(mut self) {
5124 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5126 std::mem::forget(self);
5128 }
5129}
5130
5131impl EchoEchoTablePayloadWithErrorResponder {
5132 pub fn send(self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5136 let _result = self.send_raw(result);
5137 if _result.is_err() {
5138 self.control_handle.shutdown();
5139 }
5140 self.drop_without_shutdown();
5141 _result
5142 }
5143
5144 pub fn send_no_shutdown_on_err(
5146 self,
5147 mut result: Result<&ResponseTable, DefaultEnum>,
5148 ) -> Result<(), fidl::Error> {
5149 let _result = self.send_raw(result);
5150 self.drop_without_shutdown();
5151 _result
5152 }
5153
5154 fn send_raw(&self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5155 self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseTable, DefaultEnum>>(
5156 result,
5157 self.tx_id,
5158 0x636ed243761ab66d,
5159 fidl::encoding::DynamicFlags::empty(),
5160 )
5161 }
5162}
5163
5164#[must_use = "FIDL methods require a response to be sent"]
5165#[derive(Debug)]
5166pub struct EchoEchoUnionPayloadResponder {
5167 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5168 tx_id: u32,
5169}
5170
5171impl std::ops::Drop for EchoEchoUnionPayloadResponder {
5175 fn drop(&mut self) {
5176 self.control_handle.shutdown();
5177 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5179 }
5180}
5181
5182impl fidl::endpoints::Responder for EchoEchoUnionPayloadResponder {
5183 type ControlHandle = EchoControlHandle;
5184
5185 fn control_handle(&self) -> &EchoControlHandle {
5186 &self.control_handle
5187 }
5188
5189 fn drop_without_shutdown(mut self) {
5190 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5192 std::mem::forget(self);
5194 }
5195}
5196
5197impl EchoEchoUnionPayloadResponder {
5198 pub fn send(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5202 let _result = self.send_raw(payload);
5203 if _result.is_err() {
5204 self.control_handle.shutdown();
5205 }
5206 self.drop_without_shutdown();
5207 _result
5208 }
5209
5210 pub fn send_no_shutdown_on_err(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5212 let _result = self.send_raw(payload);
5213 self.drop_without_shutdown();
5214 _result
5215 }
5216
5217 fn send_raw(&self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5218 self.control_handle.inner.send::<ResponseUnion>(
5219 payload,
5220 self.tx_id,
5221 0x66def9e793f10c55,
5222 fidl::encoding::DynamicFlags::empty(),
5223 )
5224 }
5225}
5226
5227#[must_use = "FIDL methods require a response to be sent"]
5228#[derive(Debug)]
5229pub struct EchoEchoUnionPayloadWithErrorResponder {
5230 control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5231 tx_id: u32,
5232}
5233
5234impl std::ops::Drop for EchoEchoUnionPayloadWithErrorResponder {
5238 fn drop(&mut self) {
5239 self.control_handle.shutdown();
5240 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5242 }
5243}
5244
5245impl fidl::endpoints::Responder for EchoEchoUnionPayloadWithErrorResponder {
5246 type ControlHandle = EchoControlHandle;
5247
5248 fn control_handle(&self) -> &EchoControlHandle {
5249 &self.control_handle
5250 }
5251
5252 fn drop_without_shutdown(mut self) {
5253 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5255 std::mem::forget(self);
5257 }
5258}
5259
5260impl EchoEchoUnionPayloadWithErrorResponder {
5261 pub fn send(self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5265 let _result = self.send_raw(result);
5266 if _result.is_err() {
5267 self.control_handle.shutdown();
5268 }
5269 self.drop_without_shutdown();
5270 _result
5271 }
5272
5273 pub fn send_no_shutdown_on_err(
5275 self,
5276 mut result: Result<&ResponseUnion, DefaultEnum>,
5277 ) -> Result<(), fidl::Error> {
5278 let _result = self.send_raw(result);
5279 self.drop_without_shutdown();
5280 _result
5281 }
5282
5283 fn send_raw(&self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5284 self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseUnion, DefaultEnum>>(
5285 result,
5286 self.tx_id,
5287 0x1be890d6e68ef063,
5288 fidl::encoding::DynamicFlags::empty(),
5289 )
5290 }
5291}
5292
5293mod internal {
5294 use super::*;
5295
5296 impl fidl::encoding::ResourceTypeMarker for ArraysStruct {
5297 type Borrowed<'a> = &'a mut Self;
5298 fn take_or_borrow<'a>(
5299 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5300 ) -> Self::Borrowed<'a> {
5301 value
5302 }
5303 }
5304
5305 unsafe impl fidl::encoding::TypeMarker for ArraysStruct {
5306 type Owned = Self;
5307
5308 #[inline(always)]
5309 fn inline_align(_context: fidl::encoding::Context) -> usize {
5310 8
5311 }
5312
5313 #[inline(always)]
5314 fn inline_size(_context: fidl::encoding::Context) -> usize {
5315 680
5316 }
5317 }
5318
5319 unsafe impl fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5320 for &mut ArraysStruct
5321 {
5322 #[inline]
5323 unsafe fn encode(
5324 self,
5325 encoder: &mut fidl::encoding::Encoder<
5326 '_,
5327 fidl::encoding::DefaultFuchsiaResourceDialect,
5328 >,
5329 offset: usize,
5330 _depth: fidl::encoding::Depth,
5331 ) -> fidl::Result<()> {
5332 encoder.debug_check_bounds::<ArraysStruct>(offset);
5333 fidl::encoding::Encode::<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
5335 (
5336 <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
5337 <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
5338 <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
5339 <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
5340 <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
5341 <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
5342 <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
5343 <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
5344 <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
5345 <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
5346 <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
5347 <fidl::encoding::Array<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
5348 <fidl::encoding::Array<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
5349 <fidl::encoding::Array<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
5350 <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
5351 <fidl::encoding::Array<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
5352 <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
5353 <fidl::encoding::Array<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
5354 <fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
5355 <fidl::encoding::Array<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
5356 <fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
5357 <fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
5358 <fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
5359 <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
5360 <fidl::encoding::Array<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
5361 <fidl::encoding::Array<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
5362 ),
5363 encoder, offset, _depth
5364 )
5365 }
5366 }
5367 unsafe impl<
5368 T0: fidl::encoding::Encode<
5369 fidl::encoding::Array<bool, 3>,
5370 fidl::encoding::DefaultFuchsiaResourceDialect,
5371 >,
5372 T1: fidl::encoding::Encode<
5373 fidl::encoding::Array<i8, 3>,
5374 fidl::encoding::DefaultFuchsiaResourceDialect,
5375 >,
5376 T2: fidl::encoding::Encode<
5377 fidl::encoding::Array<i16, 3>,
5378 fidl::encoding::DefaultFuchsiaResourceDialect,
5379 >,
5380 T3: fidl::encoding::Encode<
5381 fidl::encoding::Array<i32, 3>,
5382 fidl::encoding::DefaultFuchsiaResourceDialect,
5383 >,
5384 T4: fidl::encoding::Encode<
5385 fidl::encoding::Array<i64, 3>,
5386 fidl::encoding::DefaultFuchsiaResourceDialect,
5387 >,
5388 T5: fidl::encoding::Encode<
5389 fidl::encoding::Array<u8, 3>,
5390 fidl::encoding::DefaultFuchsiaResourceDialect,
5391 >,
5392 T6: fidl::encoding::Encode<
5393 fidl::encoding::Array<u16, 3>,
5394 fidl::encoding::DefaultFuchsiaResourceDialect,
5395 >,
5396 T7: fidl::encoding::Encode<
5397 fidl::encoding::Array<u32, 3>,
5398 fidl::encoding::DefaultFuchsiaResourceDialect,
5399 >,
5400 T8: fidl::encoding::Encode<
5401 fidl::encoding::Array<u64, 3>,
5402 fidl::encoding::DefaultFuchsiaResourceDialect,
5403 >,
5404 T9: fidl::encoding::Encode<
5405 fidl::encoding::Array<f32, 3>,
5406 fidl::encoding::DefaultFuchsiaResourceDialect,
5407 >,
5408 T10: fidl::encoding::Encode<
5409 fidl::encoding::Array<f64, 3>,
5410 fidl::encoding::DefaultFuchsiaResourceDialect,
5411 >,
5412 T11: fidl::encoding::Encode<
5413 fidl::encoding::Array<DefaultEnum, 3>,
5414 fidl::encoding::DefaultFuchsiaResourceDialect,
5415 >,
5416 T12: fidl::encoding::Encode<
5417 fidl::encoding::Array<DefaultBits, 3>,
5418 fidl::encoding::DefaultFuchsiaResourceDialect,
5419 >,
5420 T13: fidl::encoding::Encode<
5421 fidl::encoding::Array<
5422 fidl::encoding::HandleType<
5423 fidl::Handle,
5424 { fidl::ObjectType::NONE.into_raw() },
5425 2147483648,
5426 >,
5427 3,
5428 >,
5429 fidl::encoding::DefaultFuchsiaResourceDialect,
5430 >,
5431 T14: fidl::encoding::Encode<
5432 fidl::encoding::Array<
5433 fidl::encoding::Optional<
5434 fidl::encoding::HandleType<
5435 fidl::Handle,
5436 { fidl::ObjectType::NONE.into_raw() },
5437 2147483648,
5438 >,
5439 >,
5440 3,
5441 >,
5442 fidl::encoding::DefaultFuchsiaResourceDialect,
5443 >,
5444 T15: fidl::encoding::Encode<
5445 fidl::encoding::Array<fidl::encoding::UnboundedString, 3>,
5446 fidl::encoding::DefaultFuchsiaResourceDialect,
5447 >,
5448 T16: fidl::encoding::Encode<
5449 fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5450 fidl::encoding::DefaultFuchsiaResourceDialect,
5451 >,
5452 T17: fidl::encoding::Encode<
5453 fidl::encoding::Array<ThisIsAStruct, 3>,
5454 fidl::encoding::DefaultFuchsiaResourceDialect,
5455 >,
5456 T18: fidl::encoding::Encode<
5457 fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5458 fidl::encoding::DefaultFuchsiaResourceDialect,
5459 >,
5460 T19: fidl::encoding::Encode<
5461 fidl::encoding::Array<ThisIsAUnion, 3>,
5462 fidl::encoding::DefaultFuchsiaResourceDialect,
5463 >,
5464 T20: fidl::encoding::Encode<
5465 fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5466 fidl::encoding::DefaultFuchsiaResourceDialect,
5467 >,
5468 T21: fidl::encoding::Encode<
5469 fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5470 fidl::encoding::DefaultFuchsiaResourceDialect,
5471 >,
5472 T22: fidl::encoding::Encode<
5473 fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5474 fidl::encoding::DefaultFuchsiaResourceDialect,
5475 >,
5476 T23: fidl::encoding::Encode<
5477 fidl::encoding::Array<
5478 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5479 3,
5480 >,
5481 fidl::encoding::DefaultFuchsiaResourceDialect,
5482 >,
5483 T24: fidl::encoding::Encode<
5484 fidl::encoding::Array<ThisIsATable, 3>,
5485 fidl::encoding::DefaultFuchsiaResourceDialect,
5486 >,
5487 T25: fidl::encoding::Encode<
5488 fidl::encoding::Array<ThisIsAXunion, 3>,
5489 fidl::encoding::DefaultFuchsiaResourceDialect,
5490 >,
5491 > fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5492 for (
5493 T0,
5494 T1,
5495 T2,
5496 T3,
5497 T4,
5498 T5,
5499 T6,
5500 T7,
5501 T8,
5502 T9,
5503 T10,
5504 T11,
5505 T12,
5506 T13,
5507 T14,
5508 T15,
5509 T16,
5510 T17,
5511 T18,
5512 T19,
5513 T20,
5514 T21,
5515 T22,
5516 T23,
5517 T24,
5518 T25,
5519 )
5520 {
5521 #[inline]
5522 unsafe fn encode(
5523 self,
5524 encoder: &mut fidl::encoding::Encoder<
5525 '_,
5526 fidl::encoding::DefaultFuchsiaResourceDialect,
5527 >,
5528 offset: usize,
5529 depth: fidl::encoding::Depth,
5530 ) -> fidl::Result<()> {
5531 encoder.debug_check_bounds::<ArraysStruct>(offset);
5532 unsafe {
5535 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
5536 (ptr as *mut u64).write_unaligned(0);
5537 }
5538 unsafe {
5539 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
5540 (ptr as *mut u64).write_unaligned(0);
5541 }
5542 unsafe {
5543 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
5544 (ptr as *mut u64).write_unaligned(0);
5545 }
5546 unsafe {
5547 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(480);
5548 (ptr as *mut u64).write_unaligned(0);
5549 }
5550 self.0.encode(encoder, offset + 0, depth)?;
5552 self.1.encode(encoder, offset + 3, depth)?;
5553 self.2.encode(encoder, offset + 6, depth)?;
5554 self.3.encode(encoder, offset + 12, depth)?;
5555 self.4.encode(encoder, offset + 24, depth)?;
5556 self.5.encode(encoder, offset + 48, depth)?;
5557 self.6.encode(encoder, offset + 52, depth)?;
5558 self.7.encode(encoder, offset + 60, depth)?;
5559 self.8.encode(encoder, offset + 72, depth)?;
5560 self.9.encode(encoder, offset + 96, depth)?;
5561 self.10.encode(encoder, offset + 112, depth)?;
5562 self.11.encode(encoder, offset + 136, depth)?;
5563 self.12.encode(encoder, offset + 148, depth)?;
5564 self.13.encode(encoder, offset + 160, depth)?;
5565 self.14.encode(encoder, offset + 172, depth)?;
5566 self.15.encode(encoder, offset + 184, depth)?;
5567 self.16.encode(encoder, offset + 232, depth)?;
5568 self.17.encode(encoder, offset + 280, depth)?;
5569 self.18.encode(encoder, offset + 328, depth)?;
5570 self.19.encode(encoder, offset + 352, depth)?;
5571 self.20.encode(encoder, offset + 400, depth)?;
5572 self.21.encode(encoder, offset + 448, depth)?;
5573 self.22.encode(encoder, offset + 488, depth)?;
5574 self.23.encode(encoder, offset + 536, depth)?;
5575 self.24.encode(encoder, offset + 584, depth)?;
5576 self.25.encode(encoder, offset + 632, depth)?;
5577 Ok(())
5578 }
5579 }
5580
5581 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {
5582 #[inline(always)]
5583 fn new_empty() -> Self {
5584 Self {
5585 bools: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5586 int8s: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5587 int16s: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5588 int32s: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5589 int64s: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5590 uint8s: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5591 uint16s: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5592 uint32s: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5593 uint64s: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5594 float32s: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5595 float64s: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5596 enums: fidl::new_empty!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5597 bits: fidl::new_empty!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5598 handles: fidl::new_empty!(
5599 fidl::encoding::Array<
5600 fidl::encoding::HandleType<
5601 fidl::Handle,
5602 { fidl::ObjectType::NONE.into_raw() },
5603 2147483648,
5604 >,
5605 3,
5606 >,
5607 fidl::encoding::DefaultFuchsiaResourceDialect
5608 ),
5609 nullable_handles: fidl::new_empty!(
5610 fidl::encoding::Array<
5611 fidl::encoding::Optional<
5612 fidl::encoding::HandleType<
5613 fidl::Handle,
5614 { fidl::ObjectType::NONE.into_raw() },
5615 2147483648,
5616 >,
5617 >,
5618 3,
5619 >,
5620 fidl::encoding::DefaultFuchsiaResourceDialect
5621 ),
5622 strings: fidl::new_empty!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5623 nullable_strings: fidl::new_empty!(
5624 fidl::encoding::Array<
5625 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
5626 3,
5627 >,
5628 fidl::encoding::DefaultFuchsiaResourceDialect
5629 ),
5630 structs: fidl::new_empty!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5631 nullable_structs: fidl::new_empty!(
5632 fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5633 fidl::encoding::DefaultFuchsiaResourceDialect
5634 ),
5635 unions: fidl::new_empty!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5636 nullable_unions: fidl::new_empty!(
5637 fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5638 fidl::encoding::DefaultFuchsiaResourceDialect
5639 ),
5640 arrays: fidl::new_empty!(
5641 fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5642 fidl::encoding::DefaultFuchsiaResourceDialect
5643 ),
5644 vectors: fidl::new_empty!(
5645 fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5646 fidl::encoding::DefaultFuchsiaResourceDialect
5647 ),
5648 nullable_vectors: fidl::new_empty!(
5649 fidl::encoding::Array<
5650 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5651 3,
5652 >,
5653 fidl::encoding::DefaultFuchsiaResourceDialect
5654 ),
5655 tables: fidl::new_empty!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5656 xunions: fidl::new_empty!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5657 }
5658 }
5659
5660 #[inline]
5661 unsafe fn decode(
5662 &mut self,
5663 decoder: &mut fidl::encoding::Decoder<
5664 '_,
5665 fidl::encoding::DefaultFuchsiaResourceDialect,
5666 >,
5667 offset: usize,
5668 _depth: fidl::encoding::Depth,
5669 ) -> fidl::Result<()> {
5670 decoder.debug_check_bounds::<Self>(offset);
5671 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
5673 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5674 let mask = 0xff000000u64;
5675 let maskedval = padval & mask;
5676 if maskedval != 0 {
5677 return Err(fidl::Error::NonZeroPadding {
5678 padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
5679 });
5680 }
5681 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
5682 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5683 let mask = 0xffff0000u64;
5684 let maskedval = padval & mask;
5685 if maskedval != 0 {
5686 return Err(fidl::Error::NonZeroPadding {
5687 padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
5688 });
5689 }
5690 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
5691 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5692 let mask = 0xffffffff00000000u64;
5693 let maskedval = padval & mask;
5694 if maskedval != 0 {
5695 return Err(fidl::Error::NonZeroPadding {
5696 padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
5697 });
5698 }
5699 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(480) };
5700 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5701 let mask = 0xffffffff00000000u64;
5702 let maskedval = padval & mask;
5703 if maskedval != 0 {
5704 return Err(fidl::Error::NonZeroPadding {
5705 padding_start: offset + 480 + ((mask as u64).trailing_zeros() / 8) as usize,
5706 });
5707 }
5708 fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
5709 fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 3, _depth)?;
5710 fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 6, _depth)?;
5711 fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 12, _depth)?;
5712 fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 24, _depth)?;
5713 fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 48, _depth)?;
5714 fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 52, _depth)?;
5715 fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 60, _depth)?;
5716 fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 72, _depth)?;
5717 fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 96, _depth)?;
5718 fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 112, _depth)?;
5719 fidl::decode!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 136, _depth)?;
5720 fidl::decode!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 148, _depth)?;
5721 fidl::decode!(
5722 fidl::encoding::Array<
5723 fidl::encoding::HandleType<
5724 fidl::Handle,
5725 { fidl::ObjectType::NONE.into_raw() },
5726 2147483648,
5727 >,
5728 3,
5729 >,
5730 fidl::encoding::DefaultFuchsiaResourceDialect,
5731 &mut self.handles,
5732 decoder,
5733 offset + 160,
5734 _depth
5735 )?;
5736 fidl::decode!(
5737 fidl::encoding::Array<
5738 fidl::encoding::Optional<
5739 fidl::encoding::HandleType<
5740 fidl::Handle,
5741 { fidl::ObjectType::NONE.into_raw() },
5742 2147483648,
5743 >,
5744 >,
5745 3,
5746 >,
5747 fidl::encoding::DefaultFuchsiaResourceDialect,
5748 &mut self.nullable_handles,
5749 decoder,
5750 offset + 172,
5751 _depth
5752 )?;
5753 fidl::decode!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 184, _depth)?;
5754 fidl::decode!(
5755 fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5756 fidl::encoding::DefaultFuchsiaResourceDialect,
5757 &mut self.nullable_strings,
5758 decoder,
5759 offset + 232,
5760 _depth
5761 )?;
5762 fidl::decode!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 280, _depth)?;
5763 fidl::decode!(
5764 fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5765 fidl::encoding::DefaultFuchsiaResourceDialect,
5766 &mut self.nullable_structs,
5767 decoder,
5768 offset + 328,
5769 _depth
5770 )?;
5771 fidl::decode!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 352, _depth)?;
5772 fidl::decode!(
5773 fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5774 fidl::encoding::DefaultFuchsiaResourceDialect,
5775 &mut self.nullable_unions,
5776 decoder,
5777 offset + 400,
5778 _depth
5779 )?;
5780 fidl::decode!(
5781 fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5782 fidl::encoding::DefaultFuchsiaResourceDialect,
5783 &mut self.arrays,
5784 decoder,
5785 offset + 448,
5786 _depth
5787 )?;
5788 fidl::decode!(
5789 fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5790 fidl::encoding::DefaultFuchsiaResourceDialect,
5791 &mut self.vectors,
5792 decoder,
5793 offset + 488,
5794 _depth
5795 )?;
5796 fidl::decode!(
5797 fidl::encoding::Array<
5798 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5799 3,
5800 >,
5801 fidl::encoding::DefaultFuchsiaResourceDialect,
5802 &mut self.nullable_vectors,
5803 decoder,
5804 offset + 536,
5805 _depth
5806 )?;
5807 fidl::decode!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 584, _depth)?;
5808 fidl::decode!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 632, _depth)?;
5809 Ok(())
5810 }
5811 }
5812
5813 impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysRequest {
5814 type Borrowed<'a> = &'a mut Self;
5815 fn take_or_borrow<'a>(
5816 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5817 ) -> Self::Borrowed<'a> {
5818 value
5819 }
5820 }
5821
5822 unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysRequest {
5823 type Owned = Self;
5824
5825 #[inline(always)]
5826 fn inline_align(_context: fidl::encoding::Context) -> usize {
5827 8
5828 }
5829
5830 #[inline(always)]
5831 fn inline_size(_context: fidl::encoding::Context) -> usize {
5832 696
5833 }
5834 }
5835
5836 unsafe impl
5837 fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5838 for &mut EchoEchoArraysRequest
5839 {
5840 #[inline]
5841 unsafe fn encode(
5842 self,
5843 encoder: &mut fidl::encoding::Encoder<
5844 '_,
5845 fidl::encoding::DefaultFuchsiaResourceDialect,
5846 >,
5847 offset: usize,
5848 _depth: fidl::encoding::Depth,
5849 ) -> fidl::Result<()> {
5850 encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5851 fidl::encoding::Encode::<
5853 EchoEchoArraysRequest,
5854 fidl::encoding::DefaultFuchsiaResourceDialect,
5855 >::encode(
5856 (
5857 <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5858 &mut self.value,
5859 ),
5860 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
5861 &self.forward_to_server,
5862 ),
5863 ),
5864 encoder,
5865 offset,
5866 _depth,
5867 )
5868 }
5869 }
5870 unsafe impl<
5871 T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
5872 T1: fidl::encoding::Encode<
5873 fidl::encoding::UnboundedString,
5874 fidl::encoding::DefaultFuchsiaResourceDialect,
5875 >,
5876 >
5877 fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5878 for (T0, T1)
5879 {
5880 #[inline]
5881 unsafe fn encode(
5882 self,
5883 encoder: &mut fidl::encoding::Encoder<
5884 '_,
5885 fidl::encoding::DefaultFuchsiaResourceDialect,
5886 >,
5887 offset: usize,
5888 depth: fidl::encoding::Depth,
5889 ) -> fidl::Result<()> {
5890 encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5891 self.0.encode(encoder, offset + 0, depth)?;
5895 self.1.encode(encoder, offset + 680, depth)?;
5896 Ok(())
5897 }
5898 }
5899
5900 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
5901 for EchoEchoArraysRequest
5902 {
5903 #[inline(always)]
5904 fn new_empty() -> Self {
5905 Self {
5906 value: fidl::new_empty!(
5907 ArraysStruct,
5908 fidl::encoding::DefaultFuchsiaResourceDialect
5909 ),
5910 forward_to_server: fidl::new_empty!(
5911 fidl::encoding::UnboundedString,
5912 fidl::encoding::DefaultFuchsiaResourceDialect
5913 ),
5914 }
5915 }
5916
5917 #[inline]
5918 unsafe fn decode(
5919 &mut self,
5920 decoder: &mut fidl::encoding::Decoder<
5921 '_,
5922 fidl::encoding::DefaultFuchsiaResourceDialect,
5923 >,
5924 offset: usize,
5925 _depth: fidl::encoding::Depth,
5926 ) -> fidl::Result<()> {
5927 decoder.debug_check_bounds::<Self>(offset);
5928 fidl::decode!(
5930 ArraysStruct,
5931 fidl::encoding::DefaultFuchsiaResourceDialect,
5932 &mut self.value,
5933 decoder,
5934 offset + 0,
5935 _depth
5936 )?;
5937 fidl::decode!(
5938 fidl::encoding::UnboundedString,
5939 fidl::encoding::DefaultFuchsiaResourceDialect,
5940 &mut self.forward_to_server,
5941 decoder,
5942 offset + 680,
5943 _depth
5944 )?;
5945 Ok(())
5946 }
5947 }
5948
5949 impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysResponse {
5950 type Borrowed<'a> = &'a mut Self;
5951 fn take_or_borrow<'a>(
5952 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5953 ) -> Self::Borrowed<'a> {
5954 value
5955 }
5956 }
5957
5958 unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysResponse {
5959 type Owned = Self;
5960
5961 #[inline(always)]
5962 fn inline_align(_context: fidl::encoding::Context) -> usize {
5963 8
5964 }
5965
5966 #[inline(always)]
5967 fn inline_size(_context: fidl::encoding::Context) -> usize {
5968 680
5969 }
5970 }
5971
5972 unsafe impl
5973 fidl::encoding::Encode<
5974 EchoEchoArraysResponse,
5975 fidl::encoding::DefaultFuchsiaResourceDialect,
5976 > for &mut EchoEchoArraysResponse
5977 {
5978 #[inline]
5979 unsafe fn encode(
5980 self,
5981 encoder: &mut fidl::encoding::Encoder<
5982 '_,
5983 fidl::encoding::DefaultFuchsiaResourceDialect,
5984 >,
5985 offset: usize,
5986 _depth: fidl::encoding::Depth,
5987 ) -> fidl::Result<()> {
5988 encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
5989 fidl::encoding::Encode::<
5991 EchoEchoArraysResponse,
5992 fidl::encoding::DefaultFuchsiaResourceDialect,
5993 >::encode(
5994 (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5995 &mut self.value,
5996 ),),
5997 encoder,
5998 offset,
5999 _depth,
6000 )
6001 }
6002 }
6003 unsafe impl<
6004 T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6005 >
6006 fidl::encoding::Encode<
6007 EchoEchoArraysResponse,
6008 fidl::encoding::DefaultFuchsiaResourceDialect,
6009 > for (T0,)
6010 {
6011 #[inline]
6012 unsafe fn encode(
6013 self,
6014 encoder: &mut fidl::encoding::Encoder<
6015 '_,
6016 fidl::encoding::DefaultFuchsiaResourceDialect,
6017 >,
6018 offset: usize,
6019 depth: fidl::encoding::Depth,
6020 ) -> fidl::Result<()> {
6021 encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6022 self.0.encode(encoder, offset + 0, depth)?;
6026 Ok(())
6027 }
6028 }
6029
6030 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6031 for EchoEchoArraysResponse
6032 {
6033 #[inline(always)]
6034 fn new_empty() -> Self {
6035 Self {
6036 value: fidl::new_empty!(
6037 ArraysStruct,
6038 fidl::encoding::DefaultFuchsiaResourceDialect
6039 ),
6040 }
6041 }
6042
6043 #[inline]
6044 unsafe fn decode(
6045 &mut self,
6046 decoder: &mut fidl::encoding::Decoder<
6047 '_,
6048 fidl::encoding::DefaultFuchsiaResourceDialect,
6049 >,
6050 offset: usize,
6051 _depth: fidl::encoding::Depth,
6052 ) -> fidl::Result<()> {
6053 decoder.debug_check_bounds::<Self>(offset);
6054 fidl::decode!(
6056 ArraysStruct,
6057 fidl::encoding::DefaultFuchsiaResourceDialect,
6058 &mut self.value,
6059 decoder,
6060 offset + 0,
6061 _depth
6062 )?;
6063 Ok(())
6064 }
6065 }
6066
6067 impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorRequest {
6068 type Borrowed<'a> = &'a mut Self;
6069 fn take_or_borrow<'a>(
6070 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6071 ) -> Self::Borrowed<'a> {
6072 value
6073 }
6074 }
6075
6076 unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorRequest {
6077 type Owned = Self;
6078
6079 #[inline(always)]
6080 fn inline_align(_context: fidl::encoding::Context) -> usize {
6081 8
6082 }
6083
6084 #[inline(always)]
6085 fn inline_size(_context: fidl::encoding::Context) -> usize {
6086 712
6087 }
6088 }
6089
6090 unsafe impl
6091 fidl::encoding::Encode<
6092 EchoEchoArraysWithErrorRequest,
6093 fidl::encoding::DefaultFuchsiaResourceDialect,
6094 > for &mut EchoEchoArraysWithErrorRequest
6095 {
6096 #[inline]
6097 unsafe fn encode(
6098 self,
6099 encoder: &mut fidl::encoding::Encoder<
6100 '_,
6101 fidl::encoding::DefaultFuchsiaResourceDialect,
6102 >,
6103 offset: usize,
6104 _depth: fidl::encoding::Depth,
6105 ) -> fidl::Result<()> {
6106 encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6107 fidl::encoding::Encode::<
6109 EchoEchoArraysWithErrorRequest,
6110 fidl::encoding::DefaultFuchsiaResourceDialect,
6111 >::encode(
6112 (
6113 <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6114 &mut self.value,
6115 ),
6116 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6117 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6118 &self.forward_to_server,
6119 ),
6120 <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6121 ),
6122 encoder,
6123 offset,
6124 _depth,
6125 )
6126 }
6127 }
6128 unsafe impl<
6129 T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6130 T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6131 T2: fidl::encoding::Encode<
6132 fidl::encoding::UnboundedString,
6133 fidl::encoding::DefaultFuchsiaResourceDialect,
6134 >,
6135 T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6136 >
6137 fidl::encoding::Encode<
6138 EchoEchoArraysWithErrorRequest,
6139 fidl::encoding::DefaultFuchsiaResourceDialect,
6140 > for (T0, T1, T2, T3)
6141 {
6142 #[inline]
6143 unsafe fn encode(
6144 self,
6145 encoder: &mut fidl::encoding::Encoder<
6146 '_,
6147 fidl::encoding::DefaultFuchsiaResourceDialect,
6148 >,
6149 offset: usize,
6150 depth: fidl::encoding::Depth,
6151 ) -> fidl::Result<()> {
6152 encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6153 unsafe {
6156 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(680);
6157 (ptr as *mut u64).write_unaligned(0);
6158 }
6159 unsafe {
6160 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(704);
6161 (ptr as *mut u64).write_unaligned(0);
6162 }
6163 self.0.encode(encoder, offset + 0, depth)?;
6165 self.1.encode(encoder, offset + 680, depth)?;
6166 self.2.encode(encoder, offset + 688, depth)?;
6167 self.3.encode(encoder, offset + 704, depth)?;
6168 Ok(())
6169 }
6170 }
6171
6172 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6173 for EchoEchoArraysWithErrorRequest
6174 {
6175 #[inline(always)]
6176 fn new_empty() -> Self {
6177 Self {
6178 value: fidl::new_empty!(
6179 ArraysStruct,
6180 fidl::encoding::DefaultFuchsiaResourceDialect
6181 ),
6182 result_err: fidl::new_empty!(
6183 DefaultEnum,
6184 fidl::encoding::DefaultFuchsiaResourceDialect
6185 ),
6186 forward_to_server: fidl::new_empty!(
6187 fidl::encoding::UnboundedString,
6188 fidl::encoding::DefaultFuchsiaResourceDialect
6189 ),
6190 result_variant: fidl::new_empty!(
6191 RespondWith,
6192 fidl::encoding::DefaultFuchsiaResourceDialect
6193 ),
6194 }
6195 }
6196
6197 #[inline]
6198 unsafe fn decode(
6199 &mut self,
6200 decoder: &mut fidl::encoding::Decoder<
6201 '_,
6202 fidl::encoding::DefaultFuchsiaResourceDialect,
6203 >,
6204 offset: usize,
6205 _depth: fidl::encoding::Depth,
6206 ) -> fidl::Result<()> {
6207 decoder.debug_check_bounds::<Self>(offset);
6208 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(680) };
6210 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6211 let mask = 0xffffffff00000000u64;
6212 let maskedval = padval & mask;
6213 if maskedval != 0 {
6214 return Err(fidl::Error::NonZeroPadding {
6215 padding_start: offset + 680 + ((mask as u64).trailing_zeros() / 8) as usize,
6216 });
6217 }
6218 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(704) };
6219 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6220 let mask = 0xffffffff00000000u64;
6221 let maskedval = padval & mask;
6222 if maskedval != 0 {
6223 return Err(fidl::Error::NonZeroPadding {
6224 padding_start: offset + 704 + ((mask as u64).trailing_zeros() / 8) as usize,
6225 });
6226 }
6227 fidl::decode!(
6228 ArraysStruct,
6229 fidl::encoding::DefaultFuchsiaResourceDialect,
6230 &mut self.value,
6231 decoder,
6232 offset + 0,
6233 _depth
6234 )?;
6235 fidl::decode!(
6236 DefaultEnum,
6237 fidl::encoding::DefaultFuchsiaResourceDialect,
6238 &mut self.result_err,
6239 decoder,
6240 offset + 680,
6241 _depth
6242 )?;
6243 fidl::decode!(
6244 fidl::encoding::UnboundedString,
6245 fidl::encoding::DefaultFuchsiaResourceDialect,
6246 &mut self.forward_to_server,
6247 decoder,
6248 offset + 688,
6249 _depth
6250 )?;
6251 fidl::decode!(
6252 RespondWith,
6253 fidl::encoding::DefaultFuchsiaResourceDialect,
6254 &mut self.result_variant,
6255 decoder,
6256 offset + 704,
6257 _depth
6258 )?;
6259 Ok(())
6260 }
6261 }
6262
6263 impl fidl::encoding::ResourceTypeMarker for EchoEchoEventRequest {
6264 type Borrowed<'a> = &'a mut Self;
6265 fn take_or_borrow<'a>(
6266 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6267 ) -> Self::Borrowed<'a> {
6268 value
6269 }
6270 }
6271
6272 unsafe impl fidl::encoding::TypeMarker for EchoEchoEventRequest {
6273 type Owned = Self;
6274
6275 #[inline(always)]
6276 fn inline_align(_context: fidl::encoding::Context) -> usize {
6277 8
6278 }
6279
6280 #[inline(always)]
6281 fn inline_size(_context: fidl::encoding::Context) -> usize {
6282 2912
6283 }
6284 }
6285
6286 unsafe impl
6287 fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6288 for &mut EchoEchoEventRequest
6289 {
6290 #[inline]
6291 unsafe fn encode(
6292 self,
6293 encoder: &mut fidl::encoding::Encoder<
6294 '_,
6295 fidl::encoding::DefaultFuchsiaResourceDialect,
6296 >,
6297 offset: usize,
6298 _depth: fidl::encoding::Depth,
6299 ) -> fidl::Result<()> {
6300 encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6301 fidl::encoding::Encode::<
6303 EchoEchoEventRequest,
6304 fidl::encoding::DefaultFuchsiaResourceDialect,
6305 >::encode(
6306 (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6307 encoder,
6308 offset,
6309 _depth,
6310 )
6311 }
6312 }
6313 unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6314 fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6315 for (T0,)
6316 {
6317 #[inline]
6318 unsafe fn encode(
6319 self,
6320 encoder: &mut fidl::encoding::Encoder<
6321 '_,
6322 fidl::encoding::DefaultFuchsiaResourceDialect,
6323 >,
6324 offset: usize,
6325 depth: fidl::encoding::Depth,
6326 ) -> fidl::Result<()> {
6327 encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6328 self.0.encode(encoder, offset + 0, depth)?;
6332 Ok(())
6333 }
6334 }
6335
6336 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6337 for EchoEchoEventRequest
6338 {
6339 #[inline(always)]
6340 fn new_empty() -> Self {
6341 Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6342 }
6343
6344 #[inline]
6345 unsafe fn decode(
6346 &mut self,
6347 decoder: &mut fidl::encoding::Decoder<
6348 '_,
6349 fidl::encoding::DefaultFuchsiaResourceDialect,
6350 >,
6351 offset: usize,
6352 _depth: fidl::encoding::Depth,
6353 ) -> fidl::Result<()> {
6354 decoder.debug_check_bounds::<Self>(offset);
6355 fidl::decode!(
6357 Struct,
6358 fidl::encoding::DefaultFuchsiaResourceDialect,
6359 &mut self.value,
6360 decoder,
6361 offset + 0,
6362 _depth
6363 )?;
6364 Ok(())
6365 }
6366 }
6367
6368 impl fidl::encoding::ResourceTypeMarker for EchoEchoStructNoRetValRequest {
6369 type Borrowed<'a> = &'a mut Self;
6370 fn take_or_borrow<'a>(
6371 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6372 ) -> Self::Borrowed<'a> {
6373 value
6374 }
6375 }
6376
6377 unsafe impl fidl::encoding::TypeMarker for EchoEchoStructNoRetValRequest {
6378 type Owned = Self;
6379
6380 #[inline(always)]
6381 fn inline_align(_context: fidl::encoding::Context) -> usize {
6382 8
6383 }
6384
6385 #[inline(always)]
6386 fn inline_size(_context: fidl::encoding::Context) -> usize {
6387 2928
6388 }
6389 }
6390
6391 unsafe impl
6392 fidl::encoding::Encode<
6393 EchoEchoStructNoRetValRequest,
6394 fidl::encoding::DefaultFuchsiaResourceDialect,
6395 > for &mut EchoEchoStructNoRetValRequest
6396 {
6397 #[inline]
6398 unsafe fn encode(
6399 self,
6400 encoder: &mut fidl::encoding::Encoder<
6401 '_,
6402 fidl::encoding::DefaultFuchsiaResourceDialect,
6403 >,
6404 offset: usize,
6405 _depth: fidl::encoding::Depth,
6406 ) -> fidl::Result<()> {
6407 encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6408 fidl::encoding::Encode::<
6410 EchoEchoStructNoRetValRequest,
6411 fidl::encoding::DefaultFuchsiaResourceDialect,
6412 >::encode(
6413 (
6414 <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6415 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6416 &self.forward_to_server,
6417 ),
6418 ),
6419 encoder,
6420 offset,
6421 _depth,
6422 )
6423 }
6424 }
6425 unsafe impl<
6426 T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6427 T1: fidl::encoding::Encode<
6428 fidl::encoding::UnboundedString,
6429 fidl::encoding::DefaultFuchsiaResourceDialect,
6430 >,
6431 >
6432 fidl::encoding::Encode<
6433 EchoEchoStructNoRetValRequest,
6434 fidl::encoding::DefaultFuchsiaResourceDialect,
6435 > for (T0, T1)
6436 {
6437 #[inline]
6438 unsafe fn encode(
6439 self,
6440 encoder: &mut fidl::encoding::Encoder<
6441 '_,
6442 fidl::encoding::DefaultFuchsiaResourceDialect,
6443 >,
6444 offset: usize,
6445 depth: fidl::encoding::Depth,
6446 ) -> fidl::Result<()> {
6447 encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6448 self.0.encode(encoder, offset + 0, depth)?;
6452 self.1.encode(encoder, offset + 2912, depth)?;
6453 Ok(())
6454 }
6455 }
6456
6457 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6458 for EchoEchoStructNoRetValRequest
6459 {
6460 #[inline(always)]
6461 fn new_empty() -> Self {
6462 Self {
6463 value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6464 forward_to_server: fidl::new_empty!(
6465 fidl::encoding::UnboundedString,
6466 fidl::encoding::DefaultFuchsiaResourceDialect
6467 ),
6468 }
6469 }
6470
6471 #[inline]
6472 unsafe fn decode(
6473 &mut self,
6474 decoder: &mut fidl::encoding::Decoder<
6475 '_,
6476 fidl::encoding::DefaultFuchsiaResourceDialect,
6477 >,
6478 offset: usize,
6479 _depth: fidl::encoding::Depth,
6480 ) -> fidl::Result<()> {
6481 decoder.debug_check_bounds::<Self>(offset);
6482 fidl::decode!(
6484 Struct,
6485 fidl::encoding::DefaultFuchsiaResourceDialect,
6486 &mut self.value,
6487 decoder,
6488 offset + 0,
6489 _depth
6490 )?;
6491 fidl::decode!(
6492 fidl::encoding::UnboundedString,
6493 fidl::encoding::DefaultFuchsiaResourceDialect,
6494 &mut self.forward_to_server,
6495 decoder,
6496 offset + 2912,
6497 _depth
6498 )?;
6499 Ok(())
6500 }
6501 }
6502
6503 impl fidl::encoding::ResourceTypeMarker for EchoEchoStructRequest {
6504 type Borrowed<'a> = &'a mut Self;
6505 fn take_or_borrow<'a>(
6506 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6507 ) -> Self::Borrowed<'a> {
6508 value
6509 }
6510 }
6511
6512 unsafe impl fidl::encoding::TypeMarker for EchoEchoStructRequest {
6513 type Owned = Self;
6514
6515 #[inline(always)]
6516 fn inline_align(_context: fidl::encoding::Context) -> usize {
6517 8
6518 }
6519
6520 #[inline(always)]
6521 fn inline_size(_context: fidl::encoding::Context) -> usize {
6522 2928
6523 }
6524 }
6525
6526 unsafe impl
6527 fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6528 for &mut EchoEchoStructRequest
6529 {
6530 #[inline]
6531 unsafe fn encode(
6532 self,
6533 encoder: &mut fidl::encoding::Encoder<
6534 '_,
6535 fidl::encoding::DefaultFuchsiaResourceDialect,
6536 >,
6537 offset: usize,
6538 _depth: fidl::encoding::Depth,
6539 ) -> fidl::Result<()> {
6540 encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6541 fidl::encoding::Encode::<
6543 EchoEchoStructRequest,
6544 fidl::encoding::DefaultFuchsiaResourceDialect,
6545 >::encode(
6546 (
6547 <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6548 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6549 &self.forward_to_server,
6550 ),
6551 ),
6552 encoder,
6553 offset,
6554 _depth,
6555 )
6556 }
6557 }
6558 unsafe impl<
6559 T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6560 T1: fidl::encoding::Encode<
6561 fidl::encoding::UnboundedString,
6562 fidl::encoding::DefaultFuchsiaResourceDialect,
6563 >,
6564 >
6565 fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6566 for (T0, T1)
6567 {
6568 #[inline]
6569 unsafe fn encode(
6570 self,
6571 encoder: &mut fidl::encoding::Encoder<
6572 '_,
6573 fidl::encoding::DefaultFuchsiaResourceDialect,
6574 >,
6575 offset: usize,
6576 depth: fidl::encoding::Depth,
6577 ) -> fidl::Result<()> {
6578 encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6579 self.0.encode(encoder, offset + 0, depth)?;
6583 self.1.encode(encoder, offset + 2912, depth)?;
6584 Ok(())
6585 }
6586 }
6587
6588 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6589 for EchoEchoStructRequest
6590 {
6591 #[inline(always)]
6592 fn new_empty() -> Self {
6593 Self {
6594 value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6595 forward_to_server: fidl::new_empty!(
6596 fidl::encoding::UnboundedString,
6597 fidl::encoding::DefaultFuchsiaResourceDialect
6598 ),
6599 }
6600 }
6601
6602 #[inline]
6603 unsafe fn decode(
6604 &mut self,
6605 decoder: &mut fidl::encoding::Decoder<
6606 '_,
6607 fidl::encoding::DefaultFuchsiaResourceDialect,
6608 >,
6609 offset: usize,
6610 _depth: fidl::encoding::Depth,
6611 ) -> fidl::Result<()> {
6612 decoder.debug_check_bounds::<Self>(offset);
6613 fidl::decode!(
6615 Struct,
6616 fidl::encoding::DefaultFuchsiaResourceDialect,
6617 &mut self.value,
6618 decoder,
6619 offset + 0,
6620 _depth
6621 )?;
6622 fidl::decode!(
6623 fidl::encoding::UnboundedString,
6624 fidl::encoding::DefaultFuchsiaResourceDialect,
6625 &mut self.forward_to_server,
6626 decoder,
6627 offset + 2912,
6628 _depth
6629 )?;
6630 Ok(())
6631 }
6632 }
6633
6634 impl fidl::encoding::ResourceTypeMarker for EchoEchoStructResponse {
6635 type Borrowed<'a> = &'a mut Self;
6636 fn take_or_borrow<'a>(
6637 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6638 ) -> Self::Borrowed<'a> {
6639 value
6640 }
6641 }
6642
6643 unsafe impl fidl::encoding::TypeMarker for EchoEchoStructResponse {
6644 type Owned = Self;
6645
6646 #[inline(always)]
6647 fn inline_align(_context: fidl::encoding::Context) -> usize {
6648 8
6649 }
6650
6651 #[inline(always)]
6652 fn inline_size(_context: fidl::encoding::Context) -> usize {
6653 2912
6654 }
6655 }
6656
6657 unsafe impl
6658 fidl::encoding::Encode<
6659 EchoEchoStructResponse,
6660 fidl::encoding::DefaultFuchsiaResourceDialect,
6661 > for &mut EchoEchoStructResponse
6662 {
6663 #[inline]
6664 unsafe fn encode(
6665 self,
6666 encoder: &mut fidl::encoding::Encoder<
6667 '_,
6668 fidl::encoding::DefaultFuchsiaResourceDialect,
6669 >,
6670 offset: usize,
6671 _depth: fidl::encoding::Depth,
6672 ) -> fidl::Result<()> {
6673 encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6674 fidl::encoding::Encode::<
6676 EchoEchoStructResponse,
6677 fidl::encoding::DefaultFuchsiaResourceDialect,
6678 >::encode(
6679 (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6680 encoder,
6681 offset,
6682 _depth,
6683 )
6684 }
6685 }
6686 unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6687 fidl::encoding::Encode<
6688 EchoEchoStructResponse,
6689 fidl::encoding::DefaultFuchsiaResourceDialect,
6690 > for (T0,)
6691 {
6692 #[inline]
6693 unsafe fn encode(
6694 self,
6695 encoder: &mut fidl::encoding::Encoder<
6696 '_,
6697 fidl::encoding::DefaultFuchsiaResourceDialect,
6698 >,
6699 offset: usize,
6700 depth: fidl::encoding::Depth,
6701 ) -> fidl::Result<()> {
6702 encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6703 self.0.encode(encoder, offset + 0, depth)?;
6707 Ok(())
6708 }
6709 }
6710
6711 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6712 for EchoEchoStructResponse
6713 {
6714 #[inline(always)]
6715 fn new_empty() -> Self {
6716 Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6717 }
6718
6719 #[inline]
6720 unsafe fn decode(
6721 &mut self,
6722 decoder: &mut fidl::encoding::Decoder<
6723 '_,
6724 fidl::encoding::DefaultFuchsiaResourceDialect,
6725 >,
6726 offset: usize,
6727 _depth: fidl::encoding::Depth,
6728 ) -> fidl::Result<()> {
6729 decoder.debug_check_bounds::<Self>(offset);
6730 fidl::decode!(
6732 Struct,
6733 fidl::encoding::DefaultFuchsiaResourceDialect,
6734 &mut self.value,
6735 decoder,
6736 offset + 0,
6737 _depth
6738 )?;
6739 Ok(())
6740 }
6741 }
6742
6743 impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorRequest {
6744 type Borrowed<'a> = &'a mut Self;
6745 fn take_or_borrow<'a>(
6746 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6747 ) -> Self::Borrowed<'a> {
6748 value
6749 }
6750 }
6751
6752 unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorRequest {
6753 type Owned = Self;
6754
6755 #[inline(always)]
6756 fn inline_align(_context: fidl::encoding::Context) -> usize {
6757 8
6758 }
6759
6760 #[inline(always)]
6761 fn inline_size(_context: fidl::encoding::Context) -> usize {
6762 2944
6763 }
6764 }
6765
6766 unsafe impl
6767 fidl::encoding::Encode<
6768 EchoEchoStructWithErrorRequest,
6769 fidl::encoding::DefaultFuchsiaResourceDialect,
6770 > for &mut EchoEchoStructWithErrorRequest
6771 {
6772 #[inline]
6773 unsafe fn encode(
6774 self,
6775 encoder: &mut fidl::encoding::Encoder<
6776 '_,
6777 fidl::encoding::DefaultFuchsiaResourceDialect,
6778 >,
6779 offset: usize,
6780 _depth: fidl::encoding::Depth,
6781 ) -> fidl::Result<()> {
6782 encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6783 fidl::encoding::Encode::<
6785 EchoEchoStructWithErrorRequest,
6786 fidl::encoding::DefaultFuchsiaResourceDialect,
6787 >::encode(
6788 (
6789 <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6790 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6791 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6792 &self.forward_to_server,
6793 ),
6794 <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6795 ),
6796 encoder,
6797 offset,
6798 _depth,
6799 )
6800 }
6801 }
6802 unsafe impl<
6803 T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6804 T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6805 T2: fidl::encoding::Encode<
6806 fidl::encoding::UnboundedString,
6807 fidl::encoding::DefaultFuchsiaResourceDialect,
6808 >,
6809 T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6810 >
6811 fidl::encoding::Encode<
6812 EchoEchoStructWithErrorRequest,
6813 fidl::encoding::DefaultFuchsiaResourceDialect,
6814 > for (T0, T1, T2, T3)
6815 {
6816 #[inline]
6817 unsafe fn encode(
6818 self,
6819 encoder: &mut fidl::encoding::Encoder<
6820 '_,
6821 fidl::encoding::DefaultFuchsiaResourceDialect,
6822 >,
6823 offset: usize,
6824 depth: fidl::encoding::Depth,
6825 ) -> fidl::Result<()> {
6826 encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6827 unsafe {
6830 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2912);
6831 (ptr as *mut u64).write_unaligned(0);
6832 }
6833 unsafe {
6834 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2936);
6835 (ptr as *mut u64).write_unaligned(0);
6836 }
6837 self.0.encode(encoder, offset + 0, depth)?;
6839 self.1.encode(encoder, offset + 2912, depth)?;
6840 self.2.encode(encoder, offset + 2920, depth)?;
6841 self.3.encode(encoder, offset + 2936, depth)?;
6842 Ok(())
6843 }
6844 }
6845
6846 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6847 for EchoEchoStructWithErrorRequest
6848 {
6849 #[inline(always)]
6850 fn new_empty() -> Self {
6851 Self {
6852 value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6853 result_err: fidl::new_empty!(
6854 DefaultEnum,
6855 fidl::encoding::DefaultFuchsiaResourceDialect
6856 ),
6857 forward_to_server: fidl::new_empty!(
6858 fidl::encoding::UnboundedString,
6859 fidl::encoding::DefaultFuchsiaResourceDialect
6860 ),
6861 result_variant: fidl::new_empty!(
6862 RespondWith,
6863 fidl::encoding::DefaultFuchsiaResourceDialect
6864 ),
6865 }
6866 }
6867
6868 #[inline]
6869 unsafe fn decode(
6870 &mut self,
6871 decoder: &mut fidl::encoding::Decoder<
6872 '_,
6873 fidl::encoding::DefaultFuchsiaResourceDialect,
6874 >,
6875 offset: usize,
6876 _depth: fidl::encoding::Depth,
6877 ) -> fidl::Result<()> {
6878 decoder.debug_check_bounds::<Self>(offset);
6879 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2912) };
6881 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6882 let mask = 0xffffffff00000000u64;
6883 let maskedval = padval & mask;
6884 if maskedval != 0 {
6885 return Err(fidl::Error::NonZeroPadding {
6886 padding_start: offset + 2912 + ((mask as u64).trailing_zeros() / 8) as usize,
6887 });
6888 }
6889 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2936) };
6890 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6891 let mask = 0xffffffff00000000u64;
6892 let maskedval = padval & mask;
6893 if maskedval != 0 {
6894 return Err(fidl::Error::NonZeroPadding {
6895 padding_start: offset + 2936 + ((mask as u64).trailing_zeros() / 8) as usize,
6896 });
6897 }
6898 fidl::decode!(
6899 Struct,
6900 fidl::encoding::DefaultFuchsiaResourceDialect,
6901 &mut self.value,
6902 decoder,
6903 offset + 0,
6904 _depth
6905 )?;
6906 fidl::decode!(
6907 DefaultEnum,
6908 fidl::encoding::DefaultFuchsiaResourceDialect,
6909 &mut self.result_err,
6910 decoder,
6911 offset + 2912,
6912 _depth
6913 )?;
6914 fidl::decode!(
6915 fidl::encoding::UnboundedString,
6916 fidl::encoding::DefaultFuchsiaResourceDialect,
6917 &mut self.forward_to_server,
6918 decoder,
6919 offset + 2920,
6920 _depth
6921 )?;
6922 fidl::decode!(
6923 RespondWith,
6924 fidl::encoding::DefaultFuchsiaResourceDialect,
6925 &mut self.result_variant,
6926 decoder,
6927 offset + 2936,
6928 _depth
6929 )?;
6930 Ok(())
6931 }
6932 }
6933
6934 impl fidl::encoding::ResourceTypeMarker for EchoEchoTableRequest {
6935 type Borrowed<'a> = &'a mut Self;
6936 fn take_or_borrow<'a>(
6937 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6938 ) -> Self::Borrowed<'a> {
6939 value
6940 }
6941 }
6942
6943 unsafe impl fidl::encoding::TypeMarker for EchoEchoTableRequest {
6944 type Owned = Self;
6945
6946 #[inline(always)]
6947 fn inline_align(_context: fidl::encoding::Context) -> usize {
6948 8
6949 }
6950
6951 #[inline(always)]
6952 fn inline_size(_context: fidl::encoding::Context) -> usize {
6953 32
6954 }
6955 }
6956
6957 unsafe impl
6958 fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6959 for &mut EchoEchoTableRequest
6960 {
6961 #[inline]
6962 unsafe fn encode(
6963 self,
6964 encoder: &mut fidl::encoding::Encoder<
6965 '_,
6966 fidl::encoding::DefaultFuchsiaResourceDialect,
6967 >,
6968 offset: usize,
6969 _depth: fidl::encoding::Depth,
6970 ) -> fidl::Result<()> {
6971 encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
6972 fidl::encoding::Encode::<
6974 EchoEchoTableRequest,
6975 fidl::encoding::DefaultFuchsiaResourceDialect,
6976 >::encode(
6977 (
6978 <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6979 &mut self.value,
6980 ),
6981 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6982 &self.forward_to_server,
6983 ),
6984 ),
6985 encoder,
6986 offset,
6987 _depth,
6988 )
6989 }
6990 }
6991 unsafe impl<
6992 T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
6993 T1: fidl::encoding::Encode<
6994 fidl::encoding::UnboundedString,
6995 fidl::encoding::DefaultFuchsiaResourceDialect,
6996 >,
6997 >
6998 fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6999 for (T0, T1)
7000 {
7001 #[inline]
7002 unsafe fn encode(
7003 self,
7004 encoder: &mut fidl::encoding::Encoder<
7005 '_,
7006 fidl::encoding::DefaultFuchsiaResourceDialect,
7007 >,
7008 offset: usize,
7009 depth: fidl::encoding::Depth,
7010 ) -> fidl::Result<()> {
7011 encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7012 self.0.encode(encoder, offset + 0, depth)?;
7016 self.1.encode(encoder, offset + 16, depth)?;
7017 Ok(())
7018 }
7019 }
7020
7021 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7022 for EchoEchoTableRequest
7023 {
7024 #[inline(always)]
7025 fn new_empty() -> Self {
7026 Self {
7027 value: fidl::new_empty!(
7028 AllTypesTable,
7029 fidl::encoding::DefaultFuchsiaResourceDialect
7030 ),
7031 forward_to_server: fidl::new_empty!(
7032 fidl::encoding::UnboundedString,
7033 fidl::encoding::DefaultFuchsiaResourceDialect
7034 ),
7035 }
7036 }
7037
7038 #[inline]
7039 unsafe fn decode(
7040 &mut self,
7041 decoder: &mut fidl::encoding::Decoder<
7042 '_,
7043 fidl::encoding::DefaultFuchsiaResourceDialect,
7044 >,
7045 offset: usize,
7046 _depth: fidl::encoding::Depth,
7047 ) -> fidl::Result<()> {
7048 decoder.debug_check_bounds::<Self>(offset);
7049 fidl::decode!(
7051 AllTypesTable,
7052 fidl::encoding::DefaultFuchsiaResourceDialect,
7053 &mut self.value,
7054 decoder,
7055 offset + 0,
7056 _depth
7057 )?;
7058 fidl::decode!(
7059 fidl::encoding::UnboundedString,
7060 fidl::encoding::DefaultFuchsiaResourceDialect,
7061 &mut self.forward_to_server,
7062 decoder,
7063 offset + 16,
7064 _depth
7065 )?;
7066 Ok(())
7067 }
7068 }
7069
7070 impl fidl::encoding::ResourceTypeMarker for EchoEchoTableResponse {
7071 type Borrowed<'a> = &'a mut Self;
7072 fn take_or_borrow<'a>(
7073 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7074 ) -> Self::Borrowed<'a> {
7075 value
7076 }
7077 }
7078
7079 unsafe impl fidl::encoding::TypeMarker for EchoEchoTableResponse {
7080 type Owned = Self;
7081
7082 #[inline(always)]
7083 fn inline_align(_context: fidl::encoding::Context) -> usize {
7084 8
7085 }
7086
7087 #[inline(always)]
7088 fn inline_size(_context: fidl::encoding::Context) -> usize {
7089 16
7090 }
7091 }
7092
7093 unsafe impl
7094 fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7095 for &mut EchoEchoTableResponse
7096 {
7097 #[inline]
7098 unsafe fn encode(
7099 self,
7100 encoder: &mut fidl::encoding::Encoder<
7101 '_,
7102 fidl::encoding::DefaultFuchsiaResourceDialect,
7103 >,
7104 offset: usize,
7105 _depth: fidl::encoding::Depth,
7106 ) -> fidl::Result<()> {
7107 encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7108 fidl::encoding::Encode::<
7110 EchoEchoTableResponse,
7111 fidl::encoding::DefaultFuchsiaResourceDialect,
7112 >::encode(
7113 (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7114 &mut self.value,
7115 ),),
7116 encoder,
7117 offset,
7118 _depth,
7119 )
7120 }
7121 }
7122 unsafe impl<
7123 T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7124 >
7125 fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7126 for (T0,)
7127 {
7128 #[inline]
7129 unsafe fn encode(
7130 self,
7131 encoder: &mut fidl::encoding::Encoder<
7132 '_,
7133 fidl::encoding::DefaultFuchsiaResourceDialect,
7134 >,
7135 offset: usize,
7136 depth: fidl::encoding::Depth,
7137 ) -> fidl::Result<()> {
7138 encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7139 self.0.encode(encoder, offset + 0, depth)?;
7143 Ok(())
7144 }
7145 }
7146
7147 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7148 for EchoEchoTableResponse
7149 {
7150 #[inline(always)]
7151 fn new_empty() -> Self {
7152 Self {
7153 value: fidl::new_empty!(
7154 AllTypesTable,
7155 fidl::encoding::DefaultFuchsiaResourceDialect
7156 ),
7157 }
7158 }
7159
7160 #[inline]
7161 unsafe fn decode(
7162 &mut self,
7163 decoder: &mut fidl::encoding::Decoder<
7164 '_,
7165 fidl::encoding::DefaultFuchsiaResourceDialect,
7166 >,
7167 offset: usize,
7168 _depth: fidl::encoding::Depth,
7169 ) -> fidl::Result<()> {
7170 decoder.debug_check_bounds::<Self>(offset);
7171 fidl::decode!(
7173 AllTypesTable,
7174 fidl::encoding::DefaultFuchsiaResourceDialect,
7175 &mut self.value,
7176 decoder,
7177 offset + 0,
7178 _depth
7179 )?;
7180 Ok(())
7181 }
7182 }
7183
7184 impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorRequest {
7185 type Borrowed<'a> = &'a mut Self;
7186 fn take_or_borrow<'a>(
7187 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7188 ) -> Self::Borrowed<'a> {
7189 value
7190 }
7191 }
7192
7193 unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorRequest {
7194 type Owned = Self;
7195
7196 #[inline(always)]
7197 fn inline_align(_context: fidl::encoding::Context) -> usize {
7198 8
7199 }
7200
7201 #[inline(always)]
7202 fn inline_size(_context: fidl::encoding::Context) -> usize {
7203 48
7204 }
7205 }
7206
7207 unsafe impl
7208 fidl::encoding::Encode<
7209 EchoEchoTableWithErrorRequest,
7210 fidl::encoding::DefaultFuchsiaResourceDialect,
7211 > for &mut EchoEchoTableWithErrorRequest
7212 {
7213 #[inline]
7214 unsafe fn encode(
7215 self,
7216 encoder: &mut fidl::encoding::Encoder<
7217 '_,
7218 fidl::encoding::DefaultFuchsiaResourceDialect,
7219 >,
7220 offset: usize,
7221 _depth: fidl::encoding::Depth,
7222 ) -> fidl::Result<()> {
7223 encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7224 fidl::encoding::Encode::<
7226 EchoEchoTableWithErrorRequest,
7227 fidl::encoding::DefaultFuchsiaResourceDialect,
7228 >::encode(
7229 (
7230 <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7231 &mut self.value,
7232 ),
7233 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7234 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7235 &self.forward_to_server,
7236 ),
7237 <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7238 ),
7239 encoder,
7240 offset,
7241 _depth,
7242 )
7243 }
7244 }
7245 unsafe impl<
7246 T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7247 T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7248 T2: fidl::encoding::Encode<
7249 fidl::encoding::UnboundedString,
7250 fidl::encoding::DefaultFuchsiaResourceDialect,
7251 >,
7252 T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7253 >
7254 fidl::encoding::Encode<
7255 EchoEchoTableWithErrorRequest,
7256 fidl::encoding::DefaultFuchsiaResourceDialect,
7257 > for (T0, T1, T2, T3)
7258 {
7259 #[inline]
7260 unsafe fn encode(
7261 self,
7262 encoder: &mut fidl::encoding::Encoder<
7263 '_,
7264 fidl::encoding::DefaultFuchsiaResourceDialect,
7265 >,
7266 offset: usize,
7267 depth: fidl::encoding::Depth,
7268 ) -> fidl::Result<()> {
7269 encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7270 unsafe {
7273 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7274 (ptr as *mut u64).write_unaligned(0);
7275 }
7276 unsafe {
7277 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
7278 (ptr as *mut u64).write_unaligned(0);
7279 }
7280 self.0.encode(encoder, offset + 0, depth)?;
7282 self.1.encode(encoder, offset + 16, depth)?;
7283 self.2.encode(encoder, offset + 24, depth)?;
7284 self.3.encode(encoder, offset + 40, depth)?;
7285 Ok(())
7286 }
7287 }
7288
7289 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7290 for EchoEchoTableWithErrorRequest
7291 {
7292 #[inline(always)]
7293 fn new_empty() -> Self {
7294 Self {
7295 value: fidl::new_empty!(
7296 AllTypesTable,
7297 fidl::encoding::DefaultFuchsiaResourceDialect
7298 ),
7299 result_err: fidl::new_empty!(
7300 DefaultEnum,
7301 fidl::encoding::DefaultFuchsiaResourceDialect
7302 ),
7303 forward_to_server: fidl::new_empty!(
7304 fidl::encoding::UnboundedString,
7305 fidl::encoding::DefaultFuchsiaResourceDialect
7306 ),
7307 result_variant: fidl::new_empty!(
7308 RespondWith,
7309 fidl::encoding::DefaultFuchsiaResourceDialect
7310 ),
7311 }
7312 }
7313
7314 #[inline]
7315 unsafe fn decode(
7316 &mut self,
7317 decoder: &mut fidl::encoding::Decoder<
7318 '_,
7319 fidl::encoding::DefaultFuchsiaResourceDialect,
7320 >,
7321 offset: usize,
7322 _depth: fidl::encoding::Depth,
7323 ) -> fidl::Result<()> {
7324 decoder.debug_check_bounds::<Self>(offset);
7325 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7327 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7328 let mask = 0xffffffff00000000u64;
7329 let maskedval = padval & mask;
7330 if maskedval != 0 {
7331 return Err(fidl::Error::NonZeroPadding {
7332 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7333 });
7334 }
7335 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
7336 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7337 let mask = 0xffffffff00000000u64;
7338 let maskedval = padval & mask;
7339 if maskedval != 0 {
7340 return Err(fidl::Error::NonZeroPadding {
7341 padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
7342 });
7343 }
7344 fidl::decode!(
7345 AllTypesTable,
7346 fidl::encoding::DefaultFuchsiaResourceDialect,
7347 &mut self.value,
7348 decoder,
7349 offset + 0,
7350 _depth
7351 )?;
7352 fidl::decode!(
7353 DefaultEnum,
7354 fidl::encoding::DefaultFuchsiaResourceDialect,
7355 &mut self.result_err,
7356 decoder,
7357 offset + 16,
7358 _depth
7359 )?;
7360 fidl::decode!(
7361 fidl::encoding::UnboundedString,
7362 fidl::encoding::DefaultFuchsiaResourceDialect,
7363 &mut self.forward_to_server,
7364 decoder,
7365 offset + 24,
7366 _depth
7367 )?;
7368 fidl::decode!(
7369 RespondWith,
7370 fidl::encoding::DefaultFuchsiaResourceDialect,
7371 &mut self.result_variant,
7372 decoder,
7373 offset + 40,
7374 _depth
7375 )?;
7376 Ok(())
7377 }
7378 }
7379
7380 impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsRequest {
7381 type Borrowed<'a> = &'a mut Self;
7382 fn take_or_borrow<'a>(
7383 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7384 ) -> Self::Borrowed<'a> {
7385 value
7386 }
7387 }
7388
7389 unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsRequest {
7390 type Owned = Self;
7391
7392 #[inline(always)]
7393 fn inline_align(_context: fidl::encoding::Context) -> usize {
7394 8
7395 }
7396
7397 #[inline(always)]
7398 fn inline_size(_context: fidl::encoding::Context) -> usize {
7399 432
7400 }
7401 }
7402
7403 unsafe impl
7404 fidl::encoding::Encode<
7405 EchoEchoVectorsRequest,
7406 fidl::encoding::DefaultFuchsiaResourceDialect,
7407 > for &mut EchoEchoVectorsRequest
7408 {
7409 #[inline]
7410 unsafe fn encode(
7411 self,
7412 encoder: &mut fidl::encoding::Encoder<
7413 '_,
7414 fidl::encoding::DefaultFuchsiaResourceDialect,
7415 >,
7416 offset: usize,
7417 _depth: fidl::encoding::Depth,
7418 ) -> fidl::Result<()> {
7419 encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7420 fidl::encoding::Encode::<
7422 EchoEchoVectorsRequest,
7423 fidl::encoding::DefaultFuchsiaResourceDialect,
7424 >::encode(
7425 (
7426 <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7427 &mut self.value,
7428 ),
7429 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7430 &self.forward_to_server,
7431 ),
7432 ),
7433 encoder,
7434 offset,
7435 _depth,
7436 )
7437 }
7438 }
7439 unsafe impl<
7440 T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7441 T1: fidl::encoding::Encode<
7442 fidl::encoding::UnboundedString,
7443 fidl::encoding::DefaultFuchsiaResourceDialect,
7444 >,
7445 >
7446 fidl::encoding::Encode<
7447 EchoEchoVectorsRequest,
7448 fidl::encoding::DefaultFuchsiaResourceDialect,
7449 > for (T0, T1)
7450 {
7451 #[inline]
7452 unsafe fn encode(
7453 self,
7454 encoder: &mut fidl::encoding::Encoder<
7455 '_,
7456 fidl::encoding::DefaultFuchsiaResourceDialect,
7457 >,
7458 offset: usize,
7459 depth: fidl::encoding::Depth,
7460 ) -> fidl::Result<()> {
7461 encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7462 self.0.encode(encoder, offset + 0, depth)?;
7466 self.1.encode(encoder, offset + 416, depth)?;
7467 Ok(())
7468 }
7469 }
7470
7471 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7472 for EchoEchoVectorsRequest
7473 {
7474 #[inline(always)]
7475 fn new_empty() -> Self {
7476 Self {
7477 value: fidl::new_empty!(
7478 VectorsStruct,
7479 fidl::encoding::DefaultFuchsiaResourceDialect
7480 ),
7481 forward_to_server: fidl::new_empty!(
7482 fidl::encoding::UnboundedString,
7483 fidl::encoding::DefaultFuchsiaResourceDialect
7484 ),
7485 }
7486 }
7487
7488 #[inline]
7489 unsafe fn decode(
7490 &mut self,
7491 decoder: &mut fidl::encoding::Decoder<
7492 '_,
7493 fidl::encoding::DefaultFuchsiaResourceDialect,
7494 >,
7495 offset: usize,
7496 _depth: fidl::encoding::Depth,
7497 ) -> fidl::Result<()> {
7498 decoder.debug_check_bounds::<Self>(offset);
7499 fidl::decode!(
7501 VectorsStruct,
7502 fidl::encoding::DefaultFuchsiaResourceDialect,
7503 &mut self.value,
7504 decoder,
7505 offset + 0,
7506 _depth
7507 )?;
7508 fidl::decode!(
7509 fidl::encoding::UnboundedString,
7510 fidl::encoding::DefaultFuchsiaResourceDialect,
7511 &mut self.forward_to_server,
7512 decoder,
7513 offset + 416,
7514 _depth
7515 )?;
7516 Ok(())
7517 }
7518 }
7519
7520 impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsResponse {
7521 type Borrowed<'a> = &'a mut Self;
7522 fn take_or_borrow<'a>(
7523 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7524 ) -> Self::Borrowed<'a> {
7525 value
7526 }
7527 }
7528
7529 unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsResponse {
7530 type Owned = Self;
7531
7532 #[inline(always)]
7533 fn inline_align(_context: fidl::encoding::Context) -> usize {
7534 8
7535 }
7536
7537 #[inline(always)]
7538 fn inline_size(_context: fidl::encoding::Context) -> usize {
7539 416
7540 }
7541 }
7542
7543 unsafe impl
7544 fidl::encoding::Encode<
7545 EchoEchoVectorsResponse,
7546 fidl::encoding::DefaultFuchsiaResourceDialect,
7547 > for &mut EchoEchoVectorsResponse
7548 {
7549 #[inline]
7550 unsafe fn encode(
7551 self,
7552 encoder: &mut fidl::encoding::Encoder<
7553 '_,
7554 fidl::encoding::DefaultFuchsiaResourceDialect,
7555 >,
7556 offset: usize,
7557 _depth: fidl::encoding::Depth,
7558 ) -> fidl::Result<()> {
7559 encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7560 fidl::encoding::Encode::<
7562 EchoEchoVectorsResponse,
7563 fidl::encoding::DefaultFuchsiaResourceDialect,
7564 >::encode(
7565 (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7566 &mut self.value,
7567 ),),
7568 encoder,
7569 offset,
7570 _depth,
7571 )
7572 }
7573 }
7574 unsafe impl<
7575 T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7576 >
7577 fidl::encoding::Encode<
7578 EchoEchoVectorsResponse,
7579 fidl::encoding::DefaultFuchsiaResourceDialect,
7580 > for (T0,)
7581 {
7582 #[inline]
7583 unsafe fn encode(
7584 self,
7585 encoder: &mut fidl::encoding::Encoder<
7586 '_,
7587 fidl::encoding::DefaultFuchsiaResourceDialect,
7588 >,
7589 offset: usize,
7590 depth: fidl::encoding::Depth,
7591 ) -> fidl::Result<()> {
7592 encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7593 self.0.encode(encoder, offset + 0, depth)?;
7597 Ok(())
7598 }
7599 }
7600
7601 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7602 for EchoEchoVectorsResponse
7603 {
7604 #[inline(always)]
7605 fn new_empty() -> Self {
7606 Self {
7607 value: fidl::new_empty!(
7608 VectorsStruct,
7609 fidl::encoding::DefaultFuchsiaResourceDialect
7610 ),
7611 }
7612 }
7613
7614 #[inline]
7615 unsafe fn decode(
7616 &mut self,
7617 decoder: &mut fidl::encoding::Decoder<
7618 '_,
7619 fidl::encoding::DefaultFuchsiaResourceDialect,
7620 >,
7621 offset: usize,
7622 _depth: fidl::encoding::Depth,
7623 ) -> fidl::Result<()> {
7624 decoder.debug_check_bounds::<Self>(offset);
7625 fidl::decode!(
7627 VectorsStruct,
7628 fidl::encoding::DefaultFuchsiaResourceDialect,
7629 &mut self.value,
7630 decoder,
7631 offset + 0,
7632 _depth
7633 )?;
7634 Ok(())
7635 }
7636 }
7637
7638 impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorRequest {
7639 type Borrowed<'a> = &'a mut Self;
7640 fn take_or_borrow<'a>(
7641 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7642 ) -> Self::Borrowed<'a> {
7643 value
7644 }
7645 }
7646
7647 unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorRequest {
7648 type Owned = Self;
7649
7650 #[inline(always)]
7651 fn inline_align(_context: fidl::encoding::Context) -> usize {
7652 8
7653 }
7654
7655 #[inline(always)]
7656 fn inline_size(_context: fidl::encoding::Context) -> usize {
7657 448
7658 }
7659 }
7660
7661 unsafe impl
7662 fidl::encoding::Encode<
7663 EchoEchoVectorsWithErrorRequest,
7664 fidl::encoding::DefaultFuchsiaResourceDialect,
7665 > for &mut EchoEchoVectorsWithErrorRequest
7666 {
7667 #[inline]
7668 unsafe fn encode(
7669 self,
7670 encoder: &mut fidl::encoding::Encoder<
7671 '_,
7672 fidl::encoding::DefaultFuchsiaResourceDialect,
7673 >,
7674 offset: usize,
7675 _depth: fidl::encoding::Depth,
7676 ) -> fidl::Result<()> {
7677 encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7678 fidl::encoding::Encode::<
7680 EchoEchoVectorsWithErrorRequest,
7681 fidl::encoding::DefaultFuchsiaResourceDialect,
7682 >::encode(
7683 (
7684 <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7685 &mut self.value,
7686 ),
7687 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7688 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7689 &self.forward_to_server,
7690 ),
7691 <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7692 ),
7693 encoder,
7694 offset,
7695 _depth,
7696 )
7697 }
7698 }
7699 unsafe impl<
7700 T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7701 T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7702 T2: fidl::encoding::Encode<
7703 fidl::encoding::UnboundedString,
7704 fidl::encoding::DefaultFuchsiaResourceDialect,
7705 >,
7706 T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7707 >
7708 fidl::encoding::Encode<
7709 EchoEchoVectorsWithErrorRequest,
7710 fidl::encoding::DefaultFuchsiaResourceDialect,
7711 > for (T0, T1, T2, T3)
7712 {
7713 #[inline]
7714 unsafe fn encode(
7715 self,
7716 encoder: &mut fidl::encoding::Encoder<
7717 '_,
7718 fidl::encoding::DefaultFuchsiaResourceDialect,
7719 >,
7720 offset: usize,
7721 depth: fidl::encoding::Depth,
7722 ) -> fidl::Result<()> {
7723 encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7724 unsafe {
7727 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(416);
7728 (ptr as *mut u64).write_unaligned(0);
7729 }
7730 unsafe {
7731 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(440);
7732 (ptr as *mut u64).write_unaligned(0);
7733 }
7734 self.0.encode(encoder, offset + 0, depth)?;
7736 self.1.encode(encoder, offset + 416, depth)?;
7737 self.2.encode(encoder, offset + 424, depth)?;
7738 self.3.encode(encoder, offset + 440, depth)?;
7739 Ok(())
7740 }
7741 }
7742
7743 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7744 for EchoEchoVectorsWithErrorRequest
7745 {
7746 #[inline(always)]
7747 fn new_empty() -> Self {
7748 Self {
7749 value: fidl::new_empty!(
7750 VectorsStruct,
7751 fidl::encoding::DefaultFuchsiaResourceDialect
7752 ),
7753 result_err: fidl::new_empty!(
7754 DefaultEnum,
7755 fidl::encoding::DefaultFuchsiaResourceDialect
7756 ),
7757 forward_to_server: fidl::new_empty!(
7758 fidl::encoding::UnboundedString,
7759 fidl::encoding::DefaultFuchsiaResourceDialect
7760 ),
7761 result_variant: fidl::new_empty!(
7762 RespondWith,
7763 fidl::encoding::DefaultFuchsiaResourceDialect
7764 ),
7765 }
7766 }
7767
7768 #[inline]
7769 unsafe fn decode(
7770 &mut self,
7771 decoder: &mut fidl::encoding::Decoder<
7772 '_,
7773 fidl::encoding::DefaultFuchsiaResourceDialect,
7774 >,
7775 offset: usize,
7776 _depth: fidl::encoding::Depth,
7777 ) -> fidl::Result<()> {
7778 decoder.debug_check_bounds::<Self>(offset);
7779 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(416) };
7781 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7782 let mask = 0xffffffff00000000u64;
7783 let maskedval = padval & mask;
7784 if maskedval != 0 {
7785 return Err(fidl::Error::NonZeroPadding {
7786 padding_start: offset + 416 + ((mask as u64).trailing_zeros() / 8) as usize,
7787 });
7788 }
7789 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(440) };
7790 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7791 let mask = 0xffffffff00000000u64;
7792 let maskedval = padval & mask;
7793 if maskedval != 0 {
7794 return Err(fidl::Error::NonZeroPadding {
7795 padding_start: offset + 440 + ((mask as u64).trailing_zeros() / 8) as usize,
7796 });
7797 }
7798 fidl::decode!(
7799 VectorsStruct,
7800 fidl::encoding::DefaultFuchsiaResourceDialect,
7801 &mut self.value,
7802 decoder,
7803 offset + 0,
7804 _depth
7805 )?;
7806 fidl::decode!(
7807 DefaultEnum,
7808 fidl::encoding::DefaultFuchsiaResourceDialect,
7809 &mut self.result_err,
7810 decoder,
7811 offset + 416,
7812 _depth
7813 )?;
7814 fidl::decode!(
7815 fidl::encoding::UnboundedString,
7816 fidl::encoding::DefaultFuchsiaResourceDialect,
7817 &mut self.forward_to_server,
7818 decoder,
7819 offset + 424,
7820 _depth
7821 )?;
7822 fidl::decode!(
7823 RespondWith,
7824 fidl::encoding::DefaultFuchsiaResourceDialect,
7825 &mut self.result_variant,
7826 decoder,
7827 offset + 440,
7828 _depth
7829 )?;
7830 Ok(())
7831 }
7832 }
7833
7834 impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsRequest {
7835 type Borrowed<'a> = &'a mut Self;
7836 fn take_or_borrow<'a>(
7837 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7838 ) -> Self::Borrowed<'a> {
7839 value
7840 }
7841 }
7842
7843 unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsRequest {
7844 type Owned = Self;
7845
7846 #[inline(always)]
7847 fn inline_align(_context: fidl::encoding::Context) -> usize {
7848 8
7849 }
7850
7851 #[inline(always)]
7852 fn inline_size(_context: fidl::encoding::Context) -> usize {
7853 32
7854 }
7855 }
7856
7857 unsafe impl
7858 fidl::encoding::Encode<
7859 EchoEchoXunionsRequest,
7860 fidl::encoding::DefaultFuchsiaResourceDialect,
7861 > for &mut EchoEchoXunionsRequest
7862 {
7863 #[inline]
7864 unsafe fn encode(
7865 self,
7866 encoder: &mut fidl::encoding::Encoder<
7867 '_,
7868 fidl::encoding::DefaultFuchsiaResourceDialect,
7869 >,
7870 offset: usize,
7871 _depth: fidl::encoding::Depth,
7872 ) -> fidl::Result<()> {
7873 encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7874 fidl::encoding::Encode::<EchoEchoXunionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7876 (
7877 <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
7878 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
7879 ),
7880 encoder, offset, _depth
7881 )
7882 }
7883 }
7884 unsafe impl<
7885 T0: fidl::encoding::Encode<
7886 fidl::encoding::UnboundedVector<AllTypesXunion>,
7887 fidl::encoding::DefaultFuchsiaResourceDialect,
7888 >,
7889 T1: fidl::encoding::Encode<
7890 fidl::encoding::UnboundedString,
7891 fidl::encoding::DefaultFuchsiaResourceDialect,
7892 >,
7893 >
7894 fidl::encoding::Encode<
7895 EchoEchoXunionsRequest,
7896 fidl::encoding::DefaultFuchsiaResourceDialect,
7897 > for (T0, T1)
7898 {
7899 #[inline]
7900 unsafe fn encode(
7901 self,
7902 encoder: &mut fidl::encoding::Encoder<
7903 '_,
7904 fidl::encoding::DefaultFuchsiaResourceDialect,
7905 >,
7906 offset: usize,
7907 depth: fidl::encoding::Depth,
7908 ) -> fidl::Result<()> {
7909 encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7910 self.0.encode(encoder, offset + 0, depth)?;
7914 self.1.encode(encoder, offset + 16, depth)?;
7915 Ok(())
7916 }
7917 }
7918
7919 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7920 for EchoEchoXunionsRequest
7921 {
7922 #[inline(always)]
7923 fn new_empty() -> Self {
7924 Self {
7925 value: fidl::new_empty!(
7926 fidl::encoding::UnboundedVector<AllTypesXunion>,
7927 fidl::encoding::DefaultFuchsiaResourceDialect
7928 ),
7929 forward_to_server: fidl::new_empty!(
7930 fidl::encoding::UnboundedString,
7931 fidl::encoding::DefaultFuchsiaResourceDialect
7932 ),
7933 }
7934 }
7935
7936 #[inline]
7937 unsafe fn decode(
7938 &mut self,
7939 decoder: &mut fidl::encoding::Decoder<
7940 '_,
7941 fidl::encoding::DefaultFuchsiaResourceDialect,
7942 >,
7943 offset: usize,
7944 _depth: fidl::encoding::Depth,
7945 ) -> fidl::Result<()> {
7946 decoder.debug_check_bounds::<Self>(offset);
7947 fidl::decode!(
7949 fidl::encoding::UnboundedVector<AllTypesXunion>,
7950 fidl::encoding::DefaultFuchsiaResourceDialect,
7951 &mut self.value,
7952 decoder,
7953 offset + 0,
7954 _depth
7955 )?;
7956 fidl::decode!(
7957 fidl::encoding::UnboundedString,
7958 fidl::encoding::DefaultFuchsiaResourceDialect,
7959 &mut self.forward_to_server,
7960 decoder,
7961 offset + 16,
7962 _depth
7963 )?;
7964 Ok(())
7965 }
7966 }
7967
7968 impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsResponse {
7969 type Borrowed<'a> = &'a mut Self;
7970 fn take_or_borrow<'a>(
7971 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7972 ) -> Self::Borrowed<'a> {
7973 value
7974 }
7975 }
7976
7977 unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsResponse {
7978 type Owned = Self;
7979
7980 #[inline(always)]
7981 fn inline_align(_context: fidl::encoding::Context) -> usize {
7982 8
7983 }
7984
7985 #[inline(always)]
7986 fn inline_size(_context: fidl::encoding::Context) -> usize {
7987 16
7988 }
7989 }
7990
7991 unsafe impl
7992 fidl::encoding::Encode<
7993 EchoEchoXunionsResponse,
7994 fidl::encoding::DefaultFuchsiaResourceDialect,
7995 > for &mut EchoEchoXunionsResponse
7996 {
7997 #[inline]
7998 unsafe fn encode(
7999 self,
8000 encoder: &mut fidl::encoding::Encoder<
8001 '_,
8002 fidl::encoding::DefaultFuchsiaResourceDialect,
8003 >,
8004 offset: usize,
8005 _depth: fidl::encoding::Depth,
8006 ) -> fidl::Result<()> {
8007 encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8008 fidl::encoding::Encode::<EchoEchoXunionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8010 (
8011 <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8012 ),
8013 encoder, offset, _depth
8014 )
8015 }
8016 }
8017 unsafe impl<
8018 T0: fidl::encoding::Encode<
8019 fidl::encoding::UnboundedVector<AllTypesXunion>,
8020 fidl::encoding::DefaultFuchsiaResourceDialect,
8021 >,
8022 >
8023 fidl::encoding::Encode<
8024 EchoEchoXunionsResponse,
8025 fidl::encoding::DefaultFuchsiaResourceDialect,
8026 > for (T0,)
8027 {
8028 #[inline]
8029 unsafe fn encode(
8030 self,
8031 encoder: &mut fidl::encoding::Encoder<
8032 '_,
8033 fidl::encoding::DefaultFuchsiaResourceDialect,
8034 >,
8035 offset: usize,
8036 depth: fidl::encoding::Depth,
8037 ) -> fidl::Result<()> {
8038 encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8039 self.0.encode(encoder, offset + 0, depth)?;
8043 Ok(())
8044 }
8045 }
8046
8047 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8048 for EchoEchoXunionsResponse
8049 {
8050 #[inline(always)]
8051 fn new_empty() -> Self {
8052 Self {
8053 value: fidl::new_empty!(
8054 fidl::encoding::UnboundedVector<AllTypesXunion>,
8055 fidl::encoding::DefaultFuchsiaResourceDialect
8056 ),
8057 }
8058 }
8059
8060 #[inline]
8061 unsafe fn decode(
8062 &mut self,
8063 decoder: &mut fidl::encoding::Decoder<
8064 '_,
8065 fidl::encoding::DefaultFuchsiaResourceDialect,
8066 >,
8067 offset: usize,
8068 _depth: fidl::encoding::Depth,
8069 ) -> fidl::Result<()> {
8070 decoder.debug_check_bounds::<Self>(offset);
8071 fidl::decode!(
8073 fidl::encoding::UnboundedVector<AllTypesXunion>,
8074 fidl::encoding::DefaultFuchsiaResourceDialect,
8075 &mut self.value,
8076 decoder,
8077 offset + 0,
8078 _depth
8079 )?;
8080 Ok(())
8081 }
8082 }
8083
8084 impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorRequest {
8085 type Borrowed<'a> = &'a mut Self;
8086 fn take_or_borrow<'a>(
8087 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8088 ) -> Self::Borrowed<'a> {
8089 value
8090 }
8091 }
8092
8093 unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorRequest {
8094 type Owned = Self;
8095
8096 #[inline(always)]
8097 fn inline_align(_context: fidl::encoding::Context) -> usize {
8098 8
8099 }
8100
8101 #[inline(always)]
8102 fn inline_size(_context: fidl::encoding::Context) -> usize {
8103 48
8104 }
8105 }
8106
8107 unsafe impl
8108 fidl::encoding::Encode<
8109 EchoEchoXunionsWithErrorRequest,
8110 fidl::encoding::DefaultFuchsiaResourceDialect,
8111 > for &mut EchoEchoXunionsWithErrorRequest
8112 {
8113 #[inline]
8114 unsafe fn encode(
8115 self,
8116 encoder: &mut fidl::encoding::Encoder<
8117 '_,
8118 fidl::encoding::DefaultFuchsiaResourceDialect,
8119 >,
8120 offset: usize,
8121 _depth: fidl::encoding::Depth,
8122 ) -> fidl::Result<()> {
8123 encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8124 fidl::encoding::Encode::<EchoEchoXunionsWithErrorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8126 (
8127 <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8128 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
8129 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
8130 <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
8131 ),
8132 encoder, offset, _depth
8133 )
8134 }
8135 }
8136 unsafe impl<
8137 T0: fidl::encoding::Encode<
8138 fidl::encoding::UnboundedVector<AllTypesXunion>,
8139 fidl::encoding::DefaultFuchsiaResourceDialect,
8140 >,
8141 T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8142 T2: fidl::encoding::Encode<
8143 fidl::encoding::UnboundedString,
8144 fidl::encoding::DefaultFuchsiaResourceDialect,
8145 >,
8146 T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
8147 >
8148 fidl::encoding::Encode<
8149 EchoEchoXunionsWithErrorRequest,
8150 fidl::encoding::DefaultFuchsiaResourceDialect,
8151 > for (T0, T1, T2, T3)
8152 {
8153 #[inline]
8154 unsafe fn encode(
8155 self,
8156 encoder: &mut fidl::encoding::Encoder<
8157 '_,
8158 fidl::encoding::DefaultFuchsiaResourceDialect,
8159 >,
8160 offset: usize,
8161 depth: fidl::encoding::Depth,
8162 ) -> fidl::Result<()> {
8163 encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8164 unsafe {
8167 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
8168 (ptr as *mut u64).write_unaligned(0);
8169 }
8170 unsafe {
8171 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
8172 (ptr as *mut u64).write_unaligned(0);
8173 }
8174 self.0.encode(encoder, offset + 0, depth)?;
8176 self.1.encode(encoder, offset + 16, depth)?;
8177 self.2.encode(encoder, offset + 24, depth)?;
8178 self.3.encode(encoder, offset + 40, depth)?;
8179 Ok(())
8180 }
8181 }
8182
8183 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8184 for EchoEchoXunionsWithErrorRequest
8185 {
8186 #[inline(always)]
8187 fn new_empty() -> Self {
8188 Self {
8189 value: fidl::new_empty!(
8190 fidl::encoding::UnboundedVector<AllTypesXunion>,
8191 fidl::encoding::DefaultFuchsiaResourceDialect
8192 ),
8193 result_err: fidl::new_empty!(
8194 DefaultEnum,
8195 fidl::encoding::DefaultFuchsiaResourceDialect
8196 ),
8197 forward_to_server: fidl::new_empty!(
8198 fidl::encoding::UnboundedString,
8199 fidl::encoding::DefaultFuchsiaResourceDialect
8200 ),
8201 result_variant: fidl::new_empty!(
8202 RespondWith,
8203 fidl::encoding::DefaultFuchsiaResourceDialect
8204 ),
8205 }
8206 }
8207
8208 #[inline]
8209 unsafe fn decode(
8210 &mut self,
8211 decoder: &mut fidl::encoding::Decoder<
8212 '_,
8213 fidl::encoding::DefaultFuchsiaResourceDialect,
8214 >,
8215 offset: usize,
8216 _depth: fidl::encoding::Depth,
8217 ) -> fidl::Result<()> {
8218 decoder.debug_check_bounds::<Self>(offset);
8219 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
8221 let padval = unsafe { (ptr as *const u64).read_unaligned() };
8222 let mask = 0xffffffff00000000u64;
8223 let maskedval = padval & mask;
8224 if maskedval != 0 {
8225 return Err(fidl::Error::NonZeroPadding {
8226 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
8227 });
8228 }
8229 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
8230 let padval = unsafe { (ptr as *const u64).read_unaligned() };
8231 let mask = 0xffffffff00000000u64;
8232 let maskedval = padval & mask;
8233 if maskedval != 0 {
8234 return Err(fidl::Error::NonZeroPadding {
8235 padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
8236 });
8237 }
8238 fidl::decode!(
8239 fidl::encoding::UnboundedVector<AllTypesXunion>,
8240 fidl::encoding::DefaultFuchsiaResourceDialect,
8241 &mut self.value,
8242 decoder,
8243 offset + 0,
8244 _depth
8245 )?;
8246 fidl::decode!(
8247 DefaultEnum,
8248 fidl::encoding::DefaultFuchsiaResourceDialect,
8249 &mut self.result_err,
8250 decoder,
8251 offset + 16,
8252 _depth
8253 )?;
8254 fidl::decode!(
8255 fidl::encoding::UnboundedString,
8256 fidl::encoding::DefaultFuchsiaResourceDialect,
8257 &mut self.forward_to_server,
8258 decoder,
8259 offset + 24,
8260 _depth
8261 )?;
8262 fidl::decode!(
8263 RespondWith,
8264 fidl::encoding::DefaultFuchsiaResourceDialect,
8265 &mut self.result_variant,
8266 decoder,
8267 offset + 40,
8268 _depth
8269 )?;
8270 Ok(())
8271 }
8272 }
8273
8274 impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorResponse {
8275 type Borrowed<'a> = &'a mut Self;
8276 fn take_or_borrow<'a>(
8277 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8278 ) -> Self::Borrowed<'a> {
8279 value
8280 }
8281 }
8282
8283 unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorResponse {
8284 type Owned = Self;
8285
8286 #[inline(always)]
8287 fn inline_align(_context: fidl::encoding::Context) -> usize {
8288 8
8289 }
8290
8291 #[inline(always)]
8292 fn inline_size(_context: fidl::encoding::Context) -> usize {
8293 680
8294 }
8295 }
8296
8297 unsafe impl
8298 fidl::encoding::Encode<
8299 EchoEchoArraysWithErrorResponse,
8300 fidl::encoding::DefaultFuchsiaResourceDialect,
8301 > for &mut EchoEchoArraysWithErrorResponse
8302 {
8303 #[inline]
8304 unsafe fn encode(
8305 self,
8306 encoder: &mut fidl::encoding::Encoder<
8307 '_,
8308 fidl::encoding::DefaultFuchsiaResourceDialect,
8309 >,
8310 offset: usize,
8311 _depth: fidl::encoding::Depth,
8312 ) -> fidl::Result<()> {
8313 encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8314 fidl::encoding::Encode::<
8316 EchoEchoArraysWithErrorResponse,
8317 fidl::encoding::DefaultFuchsiaResourceDialect,
8318 >::encode(
8319 (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8320 &mut self.value,
8321 ),),
8322 encoder,
8323 offset,
8324 _depth,
8325 )
8326 }
8327 }
8328 unsafe impl<
8329 T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8330 >
8331 fidl::encoding::Encode<
8332 EchoEchoArraysWithErrorResponse,
8333 fidl::encoding::DefaultFuchsiaResourceDialect,
8334 > for (T0,)
8335 {
8336 #[inline]
8337 unsafe fn encode(
8338 self,
8339 encoder: &mut fidl::encoding::Encoder<
8340 '_,
8341 fidl::encoding::DefaultFuchsiaResourceDialect,
8342 >,
8343 offset: usize,
8344 depth: fidl::encoding::Depth,
8345 ) -> fidl::Result<()> {
8346 encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8347 self.0.encode(encoder, offset + 0, depth)?;
8351 Ok(())
8352 }
8353 }
8354
8355 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8356 for EchoEchoArraysWithErrorResponse
8357 {
8358 #[inline(always)]
8359 fn new_empty() -> Self {
8360 Self {
8361 value: fidl::new_empty!(
8362 ArraysStruct,
8363 fidl::encoding::DefaultFuchsiaResourceDialect
8364 ),
8365 }
8366 }
8367
8368 #[inline]
8369 unsafe fn decode(
8370 &mut self,
8371 decoder: &mut fidl::encoding::Decoder<
8372 '_,
8373 fidl::encoding::DefaultFuchsiaResourceDialect,
8374 >,
8375 offset: usize,
8376 _depth: fidl::encoding::Depth,
8377 ) -> fidl::Result<()> {
8378 decoder.debug_check_bounds::<Self>(offset);
8379 fidl::decode!(
8381 ArraysStruct,
8382 fidl::encoding::DefaultFuchsiaResourceDialect,
8383 &mut self.value,
8384 decoder,
8385 offset + 0,
8386 _depth
8387 )?;
8388 Ok(())
8389 }
8390 }
8391
8392 impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorResponse {
8393 type Borrowed<'a> = &'a mut Self;
8394 fn take_or_borrow<'a>(
8395 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8396 ) -> Self::Borrowed<'a> {
8397 value
8398 }
8399 }
8400
8401 unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorResponse {
8402 type Owned = Self;
8403
8404 #[inline(always)]
8405 fn inline_align(_context: fidl::encoding::Context) -> usize {
8406 8
8407 }
8408
8409 #[inline(always)]
8410 fn inline_size(_context: fidl::encoding::Context) -> usize {
8411 2912
8412 }
8413 }
8414
8415 unsafe impl
8416 fidl::encoding::Encode<
8417 EchoEchoStructWithErrorResponse,
8418 fidl::encoding::DefaultFuchsiaResourceDialect,
8419 > for &mut EchoEchoStructWithErrorResponse
8420 {
8421 #[inline]
8422 unsafe fn encode(
8423 self,
8424 encoder: &mut fidl::encoding::Encoder<
8425 '_,
8426 fidl::encoding::DefaultFuchsiaResourceDialect,
8427 >,
8428 offset: usize,
8429 _depth: fidl::encoding::Depth,
8430 ) -> fidl::Result<()> {
8431 encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8432 fidl::encoding::Encode::<
8434 EchoEchoStructWithErrorResponse,
8435 fidl::encoding::DefaultFuchsiaResourceDialect,
8436 >::encode(
8437 (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
8438 encoder,
8439 offset,
8440 _depth,
8441 )
8442 }
8443 }
8444 unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
8445 fidl::encoding::Encode<
8446 EchoEchoStructWithErrorResponse,
8447 fidl::encoding::DefaultFuchsiaResourceDialect,
8448 > for (T0,)
8449 {
8450 #[inline]
8451 unsafe fn encode(
8452 self,
8453 encoder: &mut fidl::encoding::Encoder<
8454 '_,
8455 fidl::encoding::DefaultFuchsiaResourceDialect,
8456 >,
8457 offset: usize,
8458 depth: fidl::encoding::Depth,
8459 ) -> fidl::Result<()> {
8460 encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8461 self.0.encode(encoder, offset + 0, depth)?;
8465 Ok(())
8466 }
8467 }
8468
8469 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8470 for EchoEchoStructWithErrorResponse
8471 {
8472 #[inline(always)]
8473 fn new_empty() -> Self {
8474 Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
8475 }
8476
8477 #[inline]
8478 unsafe fn decode(
8479 &mut self,
8480 decoder: &mut fidl::encoding::Decoder<
8481 '_,
8482 fidl::encoding::DefaultFuchsiaResourceDialect,
8483 >,
8484 offset: usize,
8485 _depth: fidl::encoding::Depth,
8486 ) -> fidl::Result<()> {
8487 decoder.debug_check_bounds::<Self>(offset);
8488 fidl::decode!(
8490 Struct,
8491 fidl::encoding::DefaultFuchsiaResourceDialect,
8492 &mut self.value,
8493 decoder,
8494 offset + 0,
8495 _depth
8496 )?;
8497 Ok(())
8498 }
8499 }
8500
8501 impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorResponse {
8502 type Borrowed<'a> = &'a mut Self;
8503 fn take_or_borrow<'a>(
8504 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8505 ) -> Self::Borrowed<'a> {
8506 value
8507 }
8508 }
8509
8510 unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorResponse {
8511 type Owned = Self;
8512
8513 #[inline(always)]
8514 fn inline_align(_context: fidl::encoding::Context) -> usize {
8515 8
8516 }
8517
8518 #[inline(always)]
8519 fn inline_size(_context: fidl::encoding::Context) -> usize {
8520 16
8521 }
8522 }
8523
8524 unsafe impl
8525 fidl::encoding::Encode<
8526 EchoEchoTableWithErrorResponse,
8527 fidl::encoding::DefaultFuchsiaResourceDialect,
8528 > for &mut EchoEchoTableWithErrorResponse
8529 {
8530 #[inline]
8531 unsafe fn encode(
8532 self,
8533 encoder: &mut fidl::encoding::Encoder<
8534 '_,
8535 fidl::encoding::DefaultFuchsiaResourceDialect,
8536 >,
8537 offset: usize,
8538 _depth: fidl::encoding::Depth,
8539 ) -> fidl::Result<()> {
8540 encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8541 fidl::encoding::Encode::<
8543 EchoEchoTableWithErrorResponse,
8544 fidl::encoding::DefaultFuchsiaResourceDialect,
8545 >::encode(
8546 (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8547 &mut self.value,
8548 ),),
8549 encoder,
8550 offset,
8551 _depth,
8552 )
8553 }
8554 }
8555 unsafe impl<
8556 T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8557 >
8558 fidl::encoding::Encode<
8559 EchoEchoTableWithErrorResponse,
8560 fidl::encoding::DefaultFuchsiaResourceDialect,
8561 > for (T0,)
8562 {
8563 #[inline]
8564 unsafe fn encode(
8565 self,
8566 encoder: &mut fidl::encoding::Encoder<
8567 '_,
8568 fidl::encoding::DefaultFuchsiaResourceDialect,
8569 >,
8570 offset: usize,
8571 depth: fidl::encoding::Depth,
8572 ) -> fidl::Result<()> {
8573 encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8574 self.0.encode(encoder, offset + 0, depth)?;
8578 Ok(())
8579 }
8580 }
8581
8582 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8583 for EchoEchoTableWithErrorResponse
8584 {
8585 #[inline(always)]
8586 fn new_empty() -> Self {
8587 Self {
8588 value: fidl::new_empty!(
8589 AllTypesTable,
8590 fidl::encoding::DefaultFuchsiaResourceDialect
8591 ),
8592 }
8593 }
8594
8595 #[inline]
8596 unsafe fn decode(
8597 &mut self,
8598 decoder: &mut fidl::encoding::Decoder<
8599 '_,
8600 fidl::encoding::DefaultFuchsiaResourceDialect,
8601 >,
8602 offset: usize,
8603 _depth: fidl::encoding::Depth,
8604 ) -> fidl::Result<()> {
8605 decoder.debug_check_bounds::<Self>(offset);
8606 fidl::decode!(
8608 AllTypesTable,
8609 fidl::encoding::DefaultFuchsiaResourceDialect,
8610 &mut self.value,
8611 decoder,
8612 offset + 0,
8613 _depth
8614 )?;
8615 Ok(())
8616 }
8617 }
8618
8619 impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorResponse {
8620 type Borrowed<'a> = &'a mut Self;
8621 fn take_or_borrow<'a>(
8622 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8623 ) -> Self::Borrowed<'a> {
8624 value
8625 }
8626 }
8627
8628 unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorResponse {
8629 type Owned = Self;
8630
8631 #[inline(always)]
8632 fn inline_align(_context: fidl::encoding::Context) -> usize {
8633 8
8634 }
8635
8636 #[inline(always)]
8637 fn inline_size(_context: fidl::encoding::Context) -> usize {
8638 416
8639 }
8640 }
8641
8642 unsafe impl
8643 fidl::encoding::Encode<
8644 EchoEchoVectorsWithErrorResponse,
8645 fidl::encoding::DefaultFuchsiaResourceDialect,
8646 > for &mut EchoEchoVectorsWithErrorResponse
8647 {
8648 #[inline]
8649 unsafe fn encode(
8650 self,
8651 encoder: &mut fidl::encoding::Encoder<
8652 '_,
8653 fidl::encoding::DefaultFuchsiaResourceDialect,
8654 >,
8655 offset: usize,
8656 _depth: fidl::encoding::Depth,
8657 ) -> fidl::Result<()> {
8658 encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8659 fidl::encoding::Encode::<
8661 EchoEchoVectorsWithErrorResponse,
8662 fidl::encoding::DefaultFuchsiaResourceDialect,
8663 >::encode(
8664 (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8665 &mut self.value,
8666 ),),
8667 encoder,
8668 offset,
8669 _depth,
8670 )
8671 }
8672 }
8673 unsafe impl<
8674 T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8675 >
8676 fidl::encoding::Encode<
8677 EchoEchoVectorsWithErrorResponse,
8678 fidl::encoding::DefaultFuchsiaResourceDialect,
8679 > for (T0,)
8680 {
8681 #[inline]
8682 unsafe fn encode(
8683 self,
8684 encoder: &mut fidl::encoding::Encoder<
8685 '_,
8686 fidl::encoding::DefaultFuchsiaResourceDialect,
8687 >,
8688 offset: usize,
8689 depth: fidl::encoding::Depth,
8690 ) -> fidl::Result<()> {
8691 encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8692 self.0.encode(encoder, offset + 0, depth)?;
8696 Ok(())
8697 }
8698 }
8699
8700 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8701 for EchoEchoVectorsWithErrorResponse
8702 {
8703 #[inline(always)]
8704 fn new_empty() -> Self {
8705 Self {
8706 value: fidl::new_empty!(
8707 VectorsStruct,
8708 fidl::encoding::DefaultFuchsiaResourceDialect
8709 ),
8710 }
8711 }
8712
8713 #[inline]
8714 unsafe fn decode(
8715 &mut self,
8716 decoder: &mut fidl::encoding::Decoder<
8717 '_,
8718 fidl::encoding::DefaultFuchsiaResourceDialect,
8719 >,
8720 offset: usize,
8721 _depth: fidl::encoding::Depth,
8722 ) -> fidl::Result<()> {
8723 decoder.debug_check_bounds::<Self>(offset);
8724 fidl::decode!(
8726 VectorsStruct,
8727 fidl::encoding::DefaultFuchsiaResourceDialect,
8728 &mut self.value,
8729 decoder,
8730 offset + 0,
8731 _depth
8732 )?;
8733 Ok(())
8734 }
8735 }
8736
8737 impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorResponse {
8738 type Borrowed<'a> = &'a mut Self;
8739 fn take_or_borrow<'a>(
8740 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8741 ) -> Self::Borrowed<'a> {
8742 value
8743 }
8744 }
8745
8746 unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorResponse {
8747 type Owned = Self;
8748
8749 #[inline(always)]
8750 fn inline_align(_context: fidl::encoding::Context) -> usize {
8751 8
8752 }
8753
8754 #[inline(always)]
8755 fn inline_size(_context: fidl::encoding::Context) -> usize {
8756 16
8757 }
8758 }
8759
8760 unsafe impl
8761 fidl::encoding::Encode<
8762 EchoEchoXunionsWithErrorResponse,
8763 fidl::encoding::DefaultFuchsiaResourceDialect,
8764 > for &mut EchoEchoXunionsWithErrorResponse
8765 {
8766 #[inline]
8767 unsafe fn encode(
8768 self,
8769 encoder: &mut fidl::encoding::Encoder<
8770 '_,
8771 fidl::encoding::DefaultFuchsiaResourceDialect,
8772 >,
8773 offset: usize,
8774 _depth: fidl::encoding::Depth,
8775 ) -> fidl::Result<()> {
8776 encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8777 fidl::encoding::Encode::<EchoEchoXunionsWithErrorResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8779 (
8780 <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8781 ),
8782 encoder, offset, _depth
8783 )
8784 }
8785 }
8786 unsafe impl<
8787 T0: fidl::encoding::Encode<
8788 fidl::encoding::UnboundedVector<AllTypesXunion>,
8789 fidl::encoding::DefaultFuchsiaResourceDialect,
8790 >,
8791 >
8792 fidl::encoding::Encode<
8793 EchoEchoXunionsWithErrorResponse,
8794 fidl::encoding::DefaultFuchsiaResourceDialect,
8795 > for (T0,)
8796 {
8797 #[inline]
8798 unsafe fn encode(
8799 self,
8800 encoder: &mut fidl::encoding::Encoder<
8801 '_,
8802 fidl::encoding::DefaultFuchsiaResourceDialect,
8803 >,
8804 offset: usize,
8805 depth: fidl::encoding::Depth,
8806 ) -> fidl::Result<()> {
8807 encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8808 self.0.encode(encoder, offset + 0, depth)?;
8812 Ok(())
8813 }
8814 }
8815
8816 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8817 for EchoEchoXunionsWithErrorResponse
8818 {
8819 #[inline(always)]
8820 fn new_empty() -> Self {
8821 Self {
8822 value: fidl::new_empty!(
8823 fidl::encoding::UnboundedVector<AllTypesXunion>,
8824 fidl::encoding::DefaultFuchsiaResourceDialect
8825 ),
8826 }
8827 }
8828
8829 #[inline]
8830 unsafe fn decode(
8831 &mut self,
8832 decoder: &mut fidl::encoding::Decoder<
8833 '_,
8834 fidl::encoding::DefaultFuchsiaResourceDialect,
8835 >,
8836 offset: usize,
8837 _depth: fidl::encoding::Depth,
8838 ) -> fidl::Result<()> {
8839 decoder.debug_check_bounds::<Self>(offset);
8840 fidl::decode!(
8842 fidl::encoding::UnboundedVector<AllTypesXunion>,
8843 fidl::encoding::DefaultFuchsiaResourceDialect,
8844 &mut self.value,
8845 decoder,
8846 offset + 0,
8847 _depth
8848 )?;
8849 Ok(())
8850 }
8851 }
8852
8853 impl fidl::encoding::ResourceTypeMarker for Struct {
8854 type Borrowed<'a> = &'a mut Self;
8855 fn take_or_borrow<'a>(
8856 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8857 ) -> Self::Borrowed<'a> {
8858 value
8859 }
8860 }
8861
8862 unsafe impl fidl::encoding::TypeMarker for Struct {
8863 type Owned = Self;
8864
8865 #[inline(always)]
8866 fn inline_align(_context: fidl::encoding::Context) -> usize {
8867 8
8868 }
8869
8870 #[inline(always)]
8871 fn inline_size(_context: fidl::encoding::Context) -> usize {
8872 2912
8873 }
8874 }
8875
8876 unsafe impl fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8877 for &mut Struct
8878 {
8879 #[inline]
8880 unsafe fn encode(
8881 self,
8882 encoder: &mut fidl::encoding::Encoder<
8883 '_,
8884 fidl::encoding::DefaultFuchsiaResourceDialect,
8885 >,
8886 offset: usize,
8887 _depth: fidl::encoding::Depth,
8888 ) -> fidl::Result<()> {
8889 encoder.debug_check_bounds::<Struct>(offset);
8890 fidl::encoding::Encode::<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8892 (
8893 <PrimitiveTypes as fidl::encoding::ValueTypeMarker>::borrow(
8894 &self.primitive_types,
8895 ),
8896 <DefaultValues as fidl::encoding::ValueTypeMarker>::borrow(
8897 &self.default_values,
8898 ),
8899 <Arrays as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8900 &mut self.arrays,
8901 ),
8902 <Arrays2d as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8903 &mut self.arrays_2d,
8904 ),
8905 <Vectors as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8906 &mut self.vectors,
8907 ),
8908 <Handles as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8909 &mut self.handles,
8910 ),
8911 <Strings as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
8912 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.default_enum),
8913 <I8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_enum),
8914 <I16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_enum),
8915 <I32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_enum),
8916 <I64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_enum),
8917 <U8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_enum),
8918 <U16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_enum),
8919 <U32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_enum),
8920 <U64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_enum),
8921 <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(&self.default_bits),
8922 <U8Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_bits),
8923 <U16Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_bits),
8924 <U32Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_bits),
8925 <U64Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_bits),
8926 <Structs as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
8927 <Unions as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
8928 <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
8929 <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(&self.xunion),
8930 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
8931 ),
8932 encoder,
8933 offset,
8934 _depth,
8935 )
8936 }
8937 }
8938 unsafe impl<
8939 T0: fidl::encoding::Encode<PrimitiveTypes, fidl::encoding::DefaultFuchsiaResourceDialect>,
8940 T1: fidl::encoding::Encode<DefaultValues, fidl::encoding::DefaultFuchsiaResourceDialect>,
8941 T2: fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>,
8942 T3: fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>,
8943 T4: fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>,
8944 T5: fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>,
8945 T6: fidl::encoding::Encode<Strings, fidl::encoding::DefaultFuchsiaResourceDialect>,
8946 T7: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8947 T8: fidl::encoding::Encode<I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8948 T9: fidl::encoding::Encode<I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8949 T10: fidl::encoding::Encode<I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8950 T11: fidl::encoding::Encode<I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8951 T12: fidl::encoding::Encode<U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8952 T13: fidl::encoding::Encode<U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8953 T14: fidl::encoding::Encode<U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8954 T15: fidl::encoding::Encode<U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8955 T16: fidl::encoding::Encode<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8956 T17: fidl::encoding::Encode<U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8957 T18: fidl::encoding::Encode<U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8958 T19: fidl::encoding::Encode<U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8959 T20: fidl::encoding::Encode<U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8960 T21: fidl::encoding::Encode<Structs, fidl::encoding::DefaultFuchsiaResourceDialect>,
8961 T22: fidl::encoding::Encode<Unions, fidl::encoding::DefaultFuchsiaResourceDialect>,
8962 T23: fidl::encoding::Encode<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8963 T24: fidl::encoding::Encode<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>,
8964 T25: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
8965 > fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8966 for (
8967 T0,
8968 T1,
8969 T2,
8970 T3,
8971 T4,
8972 T5,
8973 T6,
8974 T7,
8975 T8,
8976 T9,
8977 T10,
8978 T11,
8979 T12,
8980 T13,
8981 T14,
8982 T15,
8983 T16,
8984 T17,
8985 T18,
8986 T19,
8987 T20,
8988 T21,
8989 T22,
8990 T23,
8991 T24,
8992 T25,
8993 )
8994 {
8995 #[inline]
8996 unsafe fn encode(
8997 self,
8998 encoder: &mut fidl::encoding::Encoder<
8999 '_,
9000 fidl::encoding::DefaultFuchsiaResourceDialect,
9001 >,
9002 offset: usize,
9003 depth: fidl::encoding::Depth,
9004 ) -> fidl::Result<()> {
9005 encoder.debug_check_bounds::<Struct>(offset);
9006 unsafe {
9009 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2640);
9010 (ptr as *mut u64).write_unaligned(0);
9011 }
9012 unsafe {
9013 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2744);
9014 (ptr as *mut u64).write_unaligned(0);
9015 }
9016 unsafe {
9017 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2752);
9018 (ptr as *mut u64).write_unaligned(0);
9019 }
9020 unsafe {
9021 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2768);
9022 (ptr as *mut u64).write_unaligned(0);
9023 }
9024 unsafe {
9025 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2784);
9026 (ptr as *mut u64).write_unaligned(0);
9027 }
9028 unsafe {
9029 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2792);
9030 (ptr as *mut u64).write_unaligned(0);
9031 }
9032 unsafe {
9033 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2904);
9034 (ptr as *mut u64).write_unaligned(0);
9035 }
9036 self.0.encode(encoder, offset + 0, depth)?;
9038 self.1.encode(encoder, offset + 48, depth)?;
9039 self.2.encode(encoder, offset + 120, depth)?;
9040 self.3.encode(encoder, offset + 328, depth)?;
9041 self.4.encode(encoder, offset + 616, depth)?;
9042 self.5.encode(encoder, offset + 2536, depth)?;
9043 self.6.encode(encoder, offset + 2648, depth)?;
9044 self.7.encode(encoder, offset + 2744, depth)?;
9045 self.8.encode(encoder, offset + 2748, depth)?;
9046 self.9.encode(encoder, offset + 2750, depth)?;
9047 self.10.encode(encoder, offset + 2752, depth)?;
9048 self.11.encode(encoder, offset + 2760, depth)?;
9049 self.12.encode(encoder, offset + 2768, depth)?;
9050 self.13.encode(encoder, offset + 2770, depth)?;
9051 self.14.encode(encoder, offset + 2772, depth)?;
9052 self.15.encode(encoder, offset + 2776, depth)?;
9053 self.16.encode(encoder, offset + 2784, depth)?;
9054 self.17.encode(encoder, offset + 2788, depth)?;
9055 self.18.encode(encoder, offset + 2790, depth)?;
9056 self.19.encode(encoder, offset + 2792, depth)?;
9057 self.20.encode(encoder, offset + 2800, depth)?;
9058 self.21.encode(encoder, offset + 2808, depth)?;
9059 self.22.encode(encoder, offset + 2840, depth)?;
9060 self.23.encode(encoder, offset + 2872, depth)?;
9061 self.24.encode(encoder, offset + 2888, depth)?;
9062 self.25.encode(encoder, offset + 2904, depth)?;
9063 Ok(())
9064 }
9065 }
9066
9067 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {
9068 #[inline(always)]
9069 fn new_empty() -> Self {
9070 Self {
9071 primitive_types: fidl::new_empty!(
9072 PrimitiveTypes,
9073 fidl::encoding::DefaultFuchsiaResourceDialect
9074 ),
9075 default_values: fidl::new_empty!(
9076 DefaultValues,
9077 fidl::encoding::DefaultFuchsiaResourceDialect
9078 ),
9079 arrays: fidl::new_empty!(Arrays, fidl::encoding::DefaultFuchsiaResourceDialect),
9080 arrays_2d: fidl::new_empty!(
9081 Arrays2d,
9082 fidl::encoding::DefaultFuchsiaResourceDialect
9083 ),
9084 vectors: fidl::new_empty!(Vectors, fidl::encoding::DefaultFuchsiaResourceDialect),
9085 handles: fidl::new_empty!(Handles, fidl::encoding::DefaultFuchsiaResourceDialect),
9086 strings: fidl::new_empty!(Strings, fidl::encoding::DefaultFuchsiaResourceDialect),
9087 default_enum: fidl::new_empty!(
9088 DefaultEnum,
9089 fidl::encoding::DefaultFuchsiaResourceDialect
9090 ),
9091 i8_enum: fidl::new_empty!(I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9092 i16_enum: fidl::new_empty!(I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9093 i32_enum: fidl::new_empty!(I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9094 i64_enum: fidl::new_empty!(I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9095 u8_enum: fidl::new_empty!(U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9096 u16_enum: fidl::new_empty!(U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9097 u32_enum: fidl::new_empty!(U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9098 u64_enum: fidl::new_empty!(U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9099 default_bits: fidl::new_empty!(
9100 DefaultBits,
9101 fidl::encoding::DefaultFuchsiaResourceDialect
9102 ),
9103 u8_bits: fidl::new_empty!(U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9104 u16_bits: fidl::new_empty!(U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9105 u32_bits: fidl::new_empty!(U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9106 u64_bits: fidl::new_empty!(U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9107 structs: fidl::new_empty!(Structs, fidl::encoding::DefaultFuchsiaResourceDialect),
9108 unions: fidl::new_empty!(Unions, fidl::encoding::DefaultFuchsiaResourceDialect),
9109 table: fidl::new_empty!(
9110 ThisIsATable,
9111 fidl::encoding::DefaultFuchsiaResourceDialect
9112 ),
9113 xunion: fidl::new_empty!(
9114 ThisIsAXunion,
9115 fidl::encoding::DefaultFuchsiaResourceDialect
9116 ),
9117 b: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
9118 }
9119 }
9120
9121 #[inline]
9122 unsafe fn decode(
9123 &mut self,
9124 decoder: &mut fidl::encoding::Decoder<
9125 '_,
9126 fidl::encoding::DefaultFuchsiaResourceDialect,
9127 >,
9128 offset: usize,
9129 _depth: fidl::encoding::Depth,
9130 ) -> fidl::Result<()> {
9131 decoder.debug_check_bounds::<Self>(offset);
9132 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2640) };
9134 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9135 let mask = 0xffffffff00000000u64;
9136 let maskedval = padval & mask;
9137 if maskedval != 0 {
9138 return Err(fidl::Error::NonZeroPadding {
9139 padding_start: offset + 2640 + ((mask as u64).trailing_zeros() / 8) as usize,
9140 });
9141 }
9142 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2744) };
9143 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9144 let mask = 0xff0000000000u64;
9145 let maskedval = padval & mask;
9146 if maskedval != 0 {
9147 return Err(fidl::Error::NonZeroPadding {
9148 padding_start: offset + 2744 + ((mask as u64).trailing_zeros() / 8) as usize,
9149 });
9150 }
9151 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2752) };
9152 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9153 let mask = 0xffffffff00000000u64;
9154 let maskedval = padval & mask;
9155 if maskedval != 0 {
9156 return Err(fidl::Error::NonZeroPadding {
9157 padding_start: offset + 2752 + ((mask as u64).trailing_zeros() / 8) as usize,
9158 });
9159 }
9160 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2768) };
9161 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9162 let mask = 0xff00u64;
9163 let maskedval = padval & mask;
9164 if maskedval != 0 {
9165 return Err(fidl::Error::NonZeroPadding {
9166 padding_start: offset + 2768 + ((mask as u64).trailing_zeros() / 8) as usize,
9167 });
9168 }
9169 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2784) };
9170 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9171 let mask = 0xff0000000000u64;
9172 let maskedval = padval & mask;
9173 if maskedval != 0 {
9174 return Err(fidl::Error::NonZeroPadding {
9175 padding_start: offset + 2784 + ((mask as u64).trailing_zeros() / 8) as usize,
9176 });
9177 }
9178 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2792) };
9179 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9180 let mask = 0xffffffff00000000u64;
9181 let maskedval = padval & mask;
9182 if maskedval != 0 {
9183 return Err(fidl::Error::NonZeroPadding {
9184 padding_start: offset + 2792 + ((mask as u64).trailing_zeros() / 8) as usize,
9185 });
9186 }
9187 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2904) };
9188 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9189 let mask = 0xffffffffffffff00u64;
9190 let maskedval = padval & mask;
9191 if maskedval != 0 {
9192 return Err(fidl::Error::NonZeroPadding {
9193 padding_start: offset + 2904 + ((mask as u64).trailing_zeros() / 8) as usize,
9194 });
9195 }
9196 fidl::decode!(
9197 PrimitiveTypes,
9198 fidl::encoding::DefaultFuchsiaResourceDialect,
9199 &mut self.primitive_types,
9200 decoder,
9201 offset + 0,
9202 _depth
9203 )?;
9204 fidl::decode!(
9205 DefaultValues,
9206 fidl::encoding::DefaultFuchsiaResourceDialect,
9207 &mut self.default_values,
9208 decoder,
9209 offset + 48,
9210 _depth
9211 )?;
9212 fidl::decode!(
9213 Arrays,
9214 fidl::encoding::DefaultFuchsiaResourceDialect,
9215 &mut self.arrays,
9216 decoder,
9217 offset + 120,
9218 _depth
9219 )?;
9220 fidl::decode!(
9221 Arrays2d,
9222 fidl::encoding::DefaultFuchsiaResourceDialect,
9223 &mut self.arrays_2d,
9224 decoder,
9225 offset + 328,
9226 _depth
9227 )?;
9228 fidl::decode!(
9229 Vectors,
9230 fidl::encoding::DefaultFuchsiaResourceDialect,
9231 &mut self.vectors,
9232 decoder,
9233 offset + 616,
9234 _depth
9235 )?;
9236 fidl::decode!(
9237 Handles,
9238 fidl::encoding::DefaultFuchsiaResourceDialect,
9239 &mut self.handles,
9240 decoder,
9241 offset + 2536,
9242 _depth
9243 )?;
9244 fidl::decode!(
9245 Strings,
9246 fidl::encoding::DefaultFuchsiaResourceDialect,
9247 &mut self.strings,
9248 decoder,
9249 offset + 2648,
9250 _depth
9251 )?;
9252 fidl::decode!(
9253 DefaultEnum,
9254 fidl::encoding::DefaultFuchsiaResourceDialect,
9255 &mut self.default_enum,
9256 decoder,
9257 offset + 2744,
9258 _depth
9259 )?;
9260 fidl::decode!(
9261 I8Enum,
9262 fidl::encoding::DefaultFuchsiaResourceDialect,
9263 &mut self.i8_enum,
9264 decoder,
9265 offset + 2748,
9266 _depth
9267 )?;
9268 fidl::decode!(
9269 I16Enum,
9270 fidl::encoding::DefaultFuchsiaResourceDialect,
9271 &mut self.i16_enum,
9272 decoder,
9273 offset + 2750,
9274 _depth
9275 )?;
9276 fidl::decode!(
9277 I32Enum,
9278 fidl::encoding::DefaultFuchsiaResourceDialect,
9279 &mut self.i32_enum,
9280 decoder,
9281 offset + 2752,
9282 _depth
9283 )?;
9284 fidl::decode!(
9285 I64Enum,
9286 fidl::encoding::DefaultFuchsiaResourceDialect,
9287 &mut self.i64_enum,
9288 decoder,
9289 offset + 2760,
9290 _depth
9291 )?;
9292 fidl::decode!(
9293 U8Enum,
9294 fidl::encoding::DefaultFuchsiaResourceDialect,
9295 &mut self.u8_enum,
9296 decoder,
9297 offset + 2768,
9298 _depth
9299 )?;
9300 fidl::decode!(
9301 U16Enum,
9302 fidl::encoding::DefaultFuchsiaResourceDialect,
9303 &mut self.u16_enum,
9304 decoder,
9305 offset + 2770,
9306 _depth
9307 )?;
9308 fidl::decode!(
9309 U32Enum,
9310 fidl::encoding::DefaultFuchsiaResourceDialect,
9311 &mut self.u32_enum,
9312 decoder,
9313 offset + 2772,
9314 _depth
9315 )?;
9316 fidl::decode!(
9317 U64Enum,
9318 fidl::encoding::DefaultFuchsiaResourceDialect,
9319 &mut self.u64_enum,
9320 decoder,
9321 offset + 2776,
9322 _depth
9323 )?;
9324 fidl::decode!(
9325 DefaultBits,
9326 fidl::encoding::DefaultFuchsiaResourceDialect,
9327 &mut self.default_bits,
9328 decoder,
9329 offset + 2784,
9330 _depth
9331 )?;
9332 fidl::decode!(
9333 U8Bits,
9334 fidl::encoding::DefaultFuchsiaResourceDialect,
9335 &mut self.u8_bits,
9336 decoder,
9337 offset + 2788,
9338 _depth
9339 )?;
9340 fidl::decode!(
9341 U16Bits,
9342 fidl::encoding::DefaultFuchsiaResourceDialect,
9343 &mut self.u16_bits,
9344 decoder,
9345 offset + 2790,
9346 _depth
9347 )?;
9348 fidl::decode!(
9349 U32Bits,
9350 fidl::encoding::DefaultFuchsiaResourceDialect,
9351 &mut self.u32_bits,
9352 decoder,
9353 offset + 2792,
9354 _depth
9355 )?;
9356 fidl::decode!(
9357 U64Bits,
9358 fidl::encoding::DefaultFuchsiaResourceDialect,
9359 &mut self.u64_bits,
9360 decoder,
9361 offset + 2800,
9362 _depth
9363 )?;
9364 fidl::decode!(
9365 Structs,
9366 fidl::encoding::DefaultFuchsiaResourceDialect,
9367 &mut self.structs,
9368 decoder,
9369 offset + 2808,
9370 _depth
9371 )?;
9372 fidl::decode!(
9373 Unions,
9374 fidl::encoding::DefaultFuchsiaResourceDialect,
9375 &mut self.unions,
9376 decoder,
9377 offset + 2840,
9378 _depth
9379 )?;
9380 fidl::decode!(
9381 ThisIsATable,
9382 fidl::encoding::DefaultFuchsiaResourceDialect,
9383 &mut self.table,
9384 decoder,
9385 offset + 2872,
9386 _depth
9387 )?;
9388 fidl::decode!(
9389 ThisIsAXunion,
9390 fidl::encoding::DefaultFuchsiaResourceDialect,
9391 &mut self.xunion,
9392 decoder,
9393 offset + 2888,
9394 _depth
9395 )?;
9396 fidl::decode!(
9397 bool,
9398 fidl::encoding::DefaultFuchsiaResourceDialect,
9399 &mut self.b,
9400 decoder,
9401 offset + 2904,
9402 _depth
9403 )?;
9404 Ok(())
9405 }
9406 }
9407
9408 impl fidl::encoding::ResourceTypeMarker for VectorsStruct {
9409 type Borrowed<'a> = &'a mut Self;
9410 fn take_or_borrow<'a>(
9411 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9412 ) -> Self::Borrowed<'a> {
9413 value
9414 }
9415 }
9416
9417 unsafe impl fidl::encoding::TypeMarker for VectorsStruct {
9418 type Owned = Self;
9419
9420 #[inline(always)]
9421 fn inline_align(_context: fidl::encoding::Context) -> usize {
9422 8
9423 }
9424
9425 #[inline(always)]
9426 fn inline_size(_context: fidl::encoding::Context) -> usize {
9427 416
9428 }
9429 }
9430
9431 unsafe impl fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9432 for &mut VectorsStruct
9433 {
9434 #[inline]
9435 unsafe fn encode(
9436 self,
9437 encoder: &mut fidl::encoding::Encoder<
9438 '_,
9439 fidl::encoding::DefaultFuchsiaResourceDialect,
9440 >,
9441 offset: usize,
9442 _depth: fidl::encoding::Depth,
9443 ) -> fidl::Result<()> {
9444 encoder.debug_check_bounds::<VectorsStruct>(offset);
9445 fidl::encoding::Encode::<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9447 (
9448 <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
9449 <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
9450 <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
9451 <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
9452 <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
9453 <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
9454 <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
9455 <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
9456 <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
9457 <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
9458 <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
9459 <fidl::encoding::Vector<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
9460 <fidl::encoding::Vector<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
9461 <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
9462 <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
9463 <fidl::encoding::Vector<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
9464 <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
9465 <fidl::encoding::Vector<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
9466 <fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
9467 <fidl::encoding::Vector<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
9468 <fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
9469 <fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
9470 <fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
9471 <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
9472 <fidl::encoding::Vector<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
9473 <fidl::encoding::Vector<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
9474 ),
9475 encoder, offset, _depth
9476 )
9477 }
9478 }
9479 unsafe impl<
9480 T0: fidl::encoding::Encode<
9481 fidl::encoding::Vector<bool, 3>,
9482 fidl::encoding::DefaultFuchsiaResourceDialect,
9483 >,
9484 T1: fidl::encoding::Encode<
9485 fidl::encoding::Vector<i8, 3>,
9486 fidl::encoding::DefaultFuchsiaResourceDialect,
9487 >,
9488 T2: fidl::encoding::Encode<
9489 fidl::encoding::Vector<i16, 3>,
9490 fidl::encoding::DefaultFuchsiaResourceDialect,
9491 >,
9492 T3: fidl::encoding::Encode<
9493 fidl::encoding::Vector<i32, 3>,
9494 fidl::encoding::DefaultFuchsiaResourceDialect,
9495 >,
9496 T4: fidl::encoding::Encode<
9497 fidl::encoding::Vector<i64, 3>,
9498 fidl::encoding::DefaultFuchsiaResourceDialect,
9499 >,
9500 T5: fidl::encoding::Encode<
9501 fidl::encoding::Vector<u8, 3>,
9502 fidl::encoding::DefaultFuchsiaResourceDialect,
9503 >,
9504 T6: fidl::encoding::Encode<
9505 fidl::encoding::Vector<u16, 3>,
9506 fidl::encoding::DefaultFuchsiaResourceDialect,
9507 >,
9508 T7: fidl::encoding::Encode<
9509 fidl::encoding::Vector<u32, 3>,
9510 fidl::encoding::DefaultFuchsiaResourceDialect,
9511 >,
9512 T8: fidl::encoding::Encode<
9513 fidl::encoding::Vector<u64, 3>,
9514 fidl::encoding::DefaultFuchsiaResourceDialect,
9515 >,
9516 T9: fidl::encoding::Encode<
9517 fidl::encoding::Vector<f32, 3>,
9518 fidl::encoding::DefaultFuchsiaResourceDialect,
9519 >,
9520 T10: fidl::encoding::Encode<
9521 fidl::encoding::Vector<f64, 3>,
9522 fidl::encoding::DefaultFuchsiaResourceDialect,
9523 >,
9524 T11: fidl::encoding::Encode<
9525 fidl::encoding::Vector<DefaultEnum, 3>,
9526 fidl::encoding::DefaultFuchsiaResourceDialect,
9527 >,
9528 T12: fidl::encoding::Encode<
9529 fidl::encoding::Vector<DefaultBits, 3>,
9530 fidl::encoding::DefaultFuchsiaResourceDialect,
9531 >,
9532 T13: fidl::encoding::Encode<
9533 fidl::encoding::Vector<
9534 fidl::encoding::HandleType<
9535 fidl::Handle,
9536 { fidl::ObjectType::NONE.into_raw() },
9537 2147483648,
9538 >,
9539 3,
9540 >,
9541 fidl::encoding::DefaultFuchsiaResourceDialect,
9542 >,
9543 T14: fidl::encoding::Encode<
9544 fidl::encoding::Vector<
9545 fidl::encoding::Optional<
9546 fidl::encoding::HandleType<
9547 fidl::Handle,
9548 { fidl::ObjectType::NONE.into_raw() },
9549 2147483648,
9550 >,
9551 >,
9552 3,
9553 >,
9554 fidl::encoding::DefaultFuchsiaResourceDialect,
9555 >,
9556 T15: fidl::encoding::Encode<
9557 fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>,
9558 fidl::encoding::DefaultFuchsiaResourceDialect,
9559 >,
9560 T16: fidl::encoding::Encode<
9561 fidl::encoding::Vector<
9562 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9563 3,
9564 >,
9565 fidl::encoding::DefaultFuchsiaResourceDialect,
9566 >,
9567 T17: fidl::encoding::Encode<
9568 fidl::encoding::Vector<ThisIsAStruct, 3>,
9569 fidl::encoding::DefaultFuchsiaResourceDialect,
9570 >,
9571 T18: fidl::encoding::Encode<
9572 fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9573 fidl::encoding::DefaultFuchsiaResourceDialect,
9574 >,
9575 T19: fidl::encoding::Encode<
9576 fidl::encoding::Vector<ThisIsAUnion, 3>,
9577 fidl::encoding::DefaultFuchsiaResourceDialect,
9578 >,
9579 T20: fidl::encoding::Encode<
9580 fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9581 fidl::encoding::DefaultFuchsiaResourceDialect,
9582 >,
9583 T21: fidl::encoding::Encode<
9584 fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9585 fidl::encoding::DefaultFuchsiaResourceDialect,
9586 >,
9587 T22: fidl::encoding::Encode<
9588 fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9589 fidl::encoding::DefaultFuchsiaResourceDialect,
9590 >,
9591 T23: fidl::encoding::Encode<
9592 fidl::encoding::Vector<
9593 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9594 3,
9595 >,
9596 fidl::encoding::DefaultFuchsiaResourceDialect,
9597 >,
9598 T24: fidl::encoding::Encode<
9599 fidl::encoding::Vector<ThisIsATable, 3>,
9600 fidl::encoding::DefaultFuchsiaResourceDialect,
9601 >,
9602 T25: fidl::encoding::Encode<
9603 fidl::encoding::Vector<ThisIsAXunion, 3>,
9604 fidl::encoding::DefaultFuchsiaResourceDialect,
9605 >,
9606 > fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9607 for (
9608 T0,
9609 T1,
9610 T2,
9611 T3,
9612 T4,
9613 T5,
9614 T6,
9615 T7,
9616 T8,
9617 T9,
9618 T10,
9619 T11,
9620 T12,
9621 T13,
9622 T14,
9623 T15,
9624 T16,
9625 T17,
9626 T18,
9627 T19,
9628 T20,
9629 T21,
9630 T22,
9631 T23,
9632 T24,
9633 T25,
9634 )
9635 {
9636 #[inline]
9637 unsafe fn encode(
9638 self,
9639 encoder: &mut fidl::encoding::Encoder<
9640 '_,
9641 fidl::encoding::DefaultFuchsiaResourceDialect,
9642 >,
9643 offset: usize,
9644 depth: fidl::encoding::Depth,
9645 ) -> fidl::Result<()> {
9646 encoder.debug_check_bounds::<VectorsStruct>(offset);
9647 self.0.encode(encoder, offset + 0, depth)?;
9651 self.1.encode(encoder, offset + 16, depth)?;
9652 self.2.encode(encoder, offset + 32, depth)?;
9653 self.3.encode(encoder, offset + 48, depth)?;
9654 self.4.encode(encoder, offset + 64, depth)?;
9655 self.5.encode(encoder, offset + 80, depth)?;
9656 self.6.encode(encoder, offset + 96, depth)?;
9657 self.7.encode(encoder, offset + 112, depth)?;
9658 self.8.encode(encoder, offset + 128, depth)?;
9659 self.9.encode(encoder, offset + 144, depth)?;
9660 self.10.encode(encoder, offset + 160, depth)?;
9661 self.11.encode(encoder, offset + 176, depth)?;
9662 self.12.encode(encoder, offset + 192, depth)?;
9663 self.13.encode(encoder, offset + 208, depth)?;
9664 self.14.encode(encoder, offset + 224, depth)?;
9665 self.15.encode(encoder, offset + 240, depth)?;
9666 self.16.encode(encoder, offset + 256, depth)?;
9667 self.17.encode(encoder, offset + 272, depth)?;
9668 self.18.encode(encoder, offset + 288, depth)?;
9669 self.19.encode(encoder, offset + 304, depth)?;
9670 self.20.encode(encoder, offset + 320, depth)?;
9671 self.21.encode(encoder, offset + 336, depth)?;
9672 self.22.encode(encoder, offset + 352, depth)?;
9673 self.23.encode(encoder, offset + 368, depth)?;
9674 self.24.encode(encoder, offset + 384, depth)?;
9675 self.25.encode(encoder, offset + 400, depth)?;
9676 Ok(())
9677 }
9678 }
9679
9680 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {
9681 #[inline(always)]
9682 fn new_empty() -> Self {
9683 Self {
9684 bools: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9685 int8s: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9686 int16s: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9687 int32s: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9688 int64s: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9689 uint8s: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9690 uint16s: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9691 uint32s: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9692 uint64s: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9693 float32s: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9694 float64s: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9695 enums: fidl::new_empty!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9696 bits: fidl::new_empty!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9697 handles: fidl::new_empty!(
9698 fidl::encoding::Vector<
9699 fidl::encoding::HandleType<
9700 fidl::Handle,
9701 { fidl::ObjectType::NONE.into_raw() },
9702 2147483648,
9703 >,
9704 3,
9705 >,
9706 fidl::encoding::DefaultFuchsiaResourceDialect
9707 ),
9708 nullable_handles: fidl::new_empty!(
9709 fidl::encoding::Vector<
9710 fidl::encoding::Optional<
9711 fidl::encoding::HandleType<
9712 fidl::Handle,
9713 { fidl::ObjectType::NONE.into_raw() },
9714 2147483648,
9715 >,
9716 >,
9717 3,
9718 >,
9719 fidl::encoding::DefaultFuchsiaResourceDialect
9720 ),
9721 strings: fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9722 nullable_strings: fidl::new_empty!(
9723 fidl::encoding::Vector<
9724 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9725 3,
9726 >,
9727 fidl::encoding::DefaultFuchsiaResourceDialect
9728 ),
9729 structs: fidl::new_empty!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9730 nullable_structs: fidl::new_empty!(
9731 fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9732 fidl::encoding::DefaultFuchsiaResourceDialect
9733 ),
9734 unions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9735 nullable_unions: fidl::new_empty!(
9736 fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9737 fidl::encoding::DefaultFuchsiaResourceDialect
9738 ),
9739 arrays: fidl::new_empty!(
9740 fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9741 fidl::encoding::DefaultFuchsiaResourceDialect
9742 ),
9743 vectors: fidl::new_empty!(
9744 fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9745 fidl::encoding::DefaultFuchsiaResourceDialect
9746 ),
9747 nullable_vectors: fidl::new_empty!(
9748 fidl::encoding::Vector<
9749 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9750 3,
9751 >,
9752 fidl::encoding::DefaultFuchsiaResourceDialect
9753 ),
9754 tables: fidl::new_empty!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9755 xunions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9756 }
9757 }
9758
9759 #[inline]
9760 unsafe fn decode(
9761 &mut self,
9762 decoder: &mut fidl::encoding::Decoder<
9763 '_,
9764 fidl::encoding::DefaultFuchsiaResourceDialect,
9765 >,
9766 offset: usize,
9767 _depth: fidl::encoding::Depth,
9768 ) -> fidl::Result<()> {
9769 decoder.debug_check_bounds::<Self>(offset);
9770 fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
9772 fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 16, _depth)?;
9773 fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 32, _depth)?;
9774 fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 48, _depth)?;
9775 fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 64, _depth)?;
9776 fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 80, _depth)?;
9777 fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 96, _depth)?;
9778 fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 112, _depth)?;
9779 fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 128, _depth)?;
9780 fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 144, _depth)?;
9781 fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 160, _depth)?;
9782 fidl::decode!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 176, _depth)?;
9783 fidl::decode!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 192, _depth)?;
9784 fidl::decode!(
9785 fidl::encoding::Vector<
9786 fidl::encoding::HandleType<
9787 fidl::Handle,
9788 { fidl::ObjectType::NONE.into_raw() },
9789 2147483648,
9790 >,
9791 3,
9792 >,
9793 fidl::encoding::DefaultFuchsiaResourceDialect,
9794 &mut self.handles,
9795 decoder,
9796 offset + 208,
9797 _depth
9798 )?;
9799 fidl::decode!(
9800 fidl::encoding::Vector<
9801 fidl::encoding::Optional<
9802 fidl::encoding::HandleType<
9803 fidl::Handle,
9804 { fidl::ObjectType::NONE.into_raw() },
9805 2147483648,
9806 >,
9807 >,
9808 3,
9809 >,
9810 fidl::encoding::DefaultFuchsiaResourceDialect,
9811 &mut self.nullable_handles,
9812 decoder,
9813 offset + 224,
9814 _depth
9815 )?;
9816 fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 240, _depth)?;
9817 fidl::decode!(
9818 fidl::encoding::Vector<
9819 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9820 3,
9821 >,
9822 fidl::encoding::DefaultFuchsiaResourceDialect,
9823 &mut self.nullable_strings,
9824 decoder,
9825 offset + 256,
9826 _depth
9827 )?;
9828 fidl::decode!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 272, _depth)?;
9829 fidl::decode!(
9830 fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9831 fidl::encoding::DefaultFuchsiaResourceDialect,
9832 &mut self.nullable_structs,
9833 decoder,
9834 offset + 288,
9835 _depth
9836 )?;
9837 fidl::decode!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 304, _depth)?;
9838 fidl::decode!(
9839 fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9840 fidl::encoding::DefaultFuchsiaResourceDialect,
9841 &mut self.nullable_unions,
9842 decoder,
9843 offset + 320,
9844 _depth
9845 )?;
9846 fidl::decode!(
9847 fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9848 fidl::encoding::DefaultFuchsiaResourceDialect,
9849 &mut self.arrays,
9850 decoder,
9851 offset + 336,
9852 _depth
9853 )?;
9854 fidl::decode!(
9855 fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9856 fidl::encoding::DefaultFuchsiaResourceDialect,
9857 &mut self.vectors,
9858 decoder,
9859 offset + 352,
9860 _depth
9861 )?;
9862 fidl::decode!(
9863 fidl::encoding::Vector<
9864 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9865 3,
9866 >,
9867 fidl::encoding::DefaultFuchsiaResourceDialect,
9868 &mut self.nullable_vectors,
9869 decoder,
9870 offset + 368,
9871 _depth
9872 )?;
9873 fidl::decode!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 384, _depth)?;
9874 fidl::decode!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 400, _depth)?;
9875 Ok(())
9876 }
9877 }
9878
9879 impl fidl::encoding::ResourceTypeMarker for Arrays {
9880 type Borrowed<'a> = &'a mut Self;
9881 fn take_or_borrow<'a>(
9882 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9883 ) -> Self::Borrowed<'a> {
9884 value
9885 }
9886 }
9887
9888 unsafe impl fidl::encoding::TypeMarker for Arrays {
9889 type Owned = Self;
9890
9891 #[inline(always)]
9892 fn inline_align(_context: fidl::encoding::Context) -> usize {
9893 8
9894 }
9895
9896 #[inline(always)]
9897 fn inline_size(_context: fidl::encoding::Context) -> usize {
9898 208
9899 }
9900 }
9901
9902 unsafe impl fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
9903 for &mut Arrays
9904 {
9905 #[inline]
9906 unsafe fn encode(
9907 self,
9908 encoder: &mut fidl::encoding::Encoder<
9909 '_,
9910 fidl::encoding::DefaultFuchsiaResourceDialect,
9911 >,
9912 offset: usize,
9913 _depth: fidl::encoding::Depth,
9914 ) -> fidl::Result<()> {
9915 encoder.debug_check_bounds::<Arrays>(offset);
9916 fidl::encoding::Encode::<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9918 (
9919 <fidl::encoding::Array<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9920 &self.b_0,
9921 ),
9922 <fidl::encoding::Array<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9923 &self.i8_0,
9924 ),
9925 <fidl::encoding::Array<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9926 &self.i16_0,
9927 ),
9928 <fidl::encoding::Array<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9929 &self.i32_0,
9930 ),
9931 <fidl::encoding::Array<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9932 &self.i64_0,
9933 ),
9934 <fidl::encoding::Array<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9935 &self.u8_0,
9936 ),
9937 <fidl::encoding::Array<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9938 &self.u16_0,
9939 ),
9940 <fidl::encoding::Array<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9941 &self.u32_0,
9942 ),
9943 <fidl::encoding::Array<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9944 &self.u64_0,
9945 ),
9946 <fidl::encoding::Array<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9947 &self.f32_0,
9948 ),
9949 <fidl::encoding::Array<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9950 &self.f64_0,
9951 ),
9952 <fidl::encoding::Array<
9953 fidl::encoding::HandleType<
9954 fidl::Handle,
9955 { fidl::ObjectType::NONE.into_raw() },
9956 2147483648,
9957 >,
9958 1,
9959 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
9960 &mut self.handle_0
9961 ),
9962 <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9963 &self.b_1,
9964 ),
9965 <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9966 &self.i8_1,
9967 ),
9968 <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9969 &self.i16_1,
9970 ),
9971 <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9972 &self.i32_1,
9973 ),
9974 <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9975 &self.i64_1,
9976 ),
9977 <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9978 &self.u8_1,
9979 ),
9980 <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9981 &self.u16_1,
9982 ),
9983 <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9984 &self.u32_1,
9985 ),
9986 <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9987 &self.u64_1,
9988 ),
9989 <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9990 &self.f32_1,
9991 ),
9992 <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9993 &self.f64_1,
9994 ),
9995 <fidl::encoding::Array<
9996 fidl::encoding::HandleType<
9997 fidl::Handle,
9998 { fidl::ObjectType::NONE.into_raw() },
9999 2147483648,
10000 >,
10001 3,
10002 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10003 &mut self.handle_1
10004 ),
10005 ),
10006 encoder,
10007 offset,
10008 _depth,
10009 )
10010 }
10011 }
10012 unsafe impl<
10013 T0: fidl::encoding::Encode<
10014 fidl::encoding::Array<bool, 1>,
10015 fidl::encoding::DefaultFuchsiaResourceDialect,
10016 >,
10017 T1: fidl::encoding::Encode<
10018 fidl::encoding::Array<i8, 1>,
10019 fidl::encoding::DefaultFuchsiaResourceDialect,
10020 >,
10021 T2: fidl::encoding::Encode<
10022 fidl::encoding::Array<i16, 1>,
10023 fidl::encoding::DefaultFuchsiaResourceDialect,
10024 >,
10025 T3: fidl::encoding::Encode<
10026 fidl::encoding::Array<i32, 1>,
10027 fidl::encoding::DefaultFuchsiaResourceDialect,
10028 >,
10029 T4: fidl::encoding::Encode<
10030 fidl::encoding::Array<i64, 1>,
10031 fidl::encoding::DefaultFuchsiaResourceDialect,
10032 >,
10033 T5: fidl::encoding::Encode<
10034 fidl::encoding::Array<u8, 1>,
10035 fidl::encoding::DefaultFuchsiaResourceDialect,
10036 >,
10037 T6: fidl::encoding::Encode<
10038 fidl::encoding::Array<u16, 1>,
10039 fidl::encoding::DefaultFuchsiaResourceDialect,
10040 >,
10041 T7: fidl::encoding::Encode<
10042 fidl::encoding::Array<u32, 1>,
10043 fidl::encoding::DefaultFuchsiaResourceDialect,
10044 >,
10045 T8: fidl::encoding::Encode<
10046 fidl::encoding::Array<u64, 1>,
10047 fidl::encoding::DefaultFuchsiaResourceDialect,
10048 >,
10049 T9: fidl::encoding::Encode<
10050 fidl::encoding::Array<f32, 1>,
10051 fidl::encoding::DefaultFuchsiaResourceDialect,
10052 >,
10053 T10: fidl::encoding::Encode<
10054 fidl::encoding::Array<f64, 1>,
10055 fidl::encoding::DefaultFuchsiaResourceDialect,
10056 >,
10057 T11: fidl::encoding::Encode<
10058 fidl::encoding::Array<
10059 fidl::encoding::HandleType<
10060 fidl::Handle,
10061 { fidl::ObjectType::NONE.into_raw() },
10062 2147483648,
10063 >,
10064 1,
10065 >,
10066 fidl::encoding::DefaultFuchsiaResourceDialect,
10067 >,
10068 T12: fidl::encoding::Encode<
10069 fidl::encoding::Array<bool, 3>,
10070 fidl::encoding::DefaultFuchsiaResourceDialect,
10071 >,
10072 T13: fidl::encoding::Encode<
10073 fidl::encoding::Array<i8, 3>,
10074 fidl::encoding::DefaultFuchsiaResourceDialect,
10075 >,
10076 T14: fidl::encoding::Encode<
10077 fidl::encoding::Array<i16, 3>,
10078 fidl::encoding::DefaultFuchsiaResourceDialect,
10079 >,
10080 T15: fidl::encoding::Encode<
10081 fidl::encoding::Array<i32, 3>,
10082 fidl::encoding::DefaultFuchsiaResourceDialect,
10083 >,
10084 T16: fidl::encoding::Encode<
10085 fidl::encoding::Array<i64, 3>,
10086 fidl::encoding::DefaultFuchsiaResourceDialect,
10087 >,
10088 T17: fidl::encoding::Encode<
10089 fidl::encoding::Array<u8, 3>,
10090 fidl::encoding::DefaultFuchsiaResourceDialect,
10091 >,
10092 T18: fidl::encoding::Encode<
10093 fidl::encoding::Array<u16, 3>,
10094 fidl::encoding::DefaultFuchsiaResourceDialect,
10095 >,
10096 T19: fidl::encoding::Encode<
10097 fidl::encoding::Array<u32, 3>,
10098 fidl::encoding::DefaultFuchsiaResourceDialect,
10099 >,
10100 T20: fidl::encoding::Encode<
10101 fidl::encoding::Array<u64, 3>,
10102 fidl::encoding::DefaultFuchsiaResourceDialect,
10103 >,
10104 T21: fidl::encoding::Encode<
10105 fidl::encoding::Array<f32, 3>,
10106 fidl::encoding::DefaultFuchsiaResourceDialect,
10107 >,
10108 T22: fidl::encoding::Encode<
10109 fidl::encoding::Array<f64, 3>,
10110 fidl::encoding::DefaultFuchsiaResourceDialect,
10111 >,
10112 T23: fidl::encoding::Encode<
10113 fidl::encoding::Array<
10114 fidl::encoding::HandleType<
10115 fidl::Handle,
10116 { fidl::ObjectType::NONE.into_raw() },
10117 2147483648,
10118 >,
10119 3,
10120 >,
10121 fidl::encoding::DefaultFuchsiaResourceDialect,
10122 >,
10123 > fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
10124 for (
10125 T0,
10126 T1,
10127 T2,
10128 T3,
10129 T4,
10130 T5,
10131 T6,
10132 T7,
10133 T8,
10134 T9,
10135 T10,
10136 T11,
10137 T12,
10138 T13,
10139 T14,
10140 T15,
10141 T16,
10142 T17,
10143 T18,
10144 T19,
10145 T20,
10146 T21,
10147 T22,
10148 T23,
10149 )
10150 {
10151 #[inline]
10152 unsafe fn encode(
10153 self,
10154 encoder: &mut fidl::encoding::Encoder<
10155 '_,
10156 fidl::encoding::DefaultFuchsiaResourceDialect,
10157 >,
10158 offset: usize,
10159 depth: fidl::encoding::Depth,
10160 ) -> fidl::Result<()> {
10161 encoder.debug_check_bounds::<Arrays>(offset);
10162 unsafe {
10165 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
10166 (ptr as *mut u64).write_unaligned(0);
10167 }
10168 unsafe {
10169 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
10170 (ptr as *mut u64).write_unaligned(0);
10171 }
10172 unsafe {
10173 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
10174 (ptr as *mut u64).write_unaligned(0);
10175 }
10176 unsafe {
10177 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
10178 (ptr as *mut u64).write_unaligned(0);
10179 }
10180 unsafe {
10181 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10182 (ptr as *mut u64).write_unaligned(0);
10183 }
10184 unsafe {
10185 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(160);
10186 (ptr as *mut u64).write_unaligned(0);
10187 }
10188 unsafe {
10189 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(200);
10190 (ptr as *mut u64).write_unaligned(0);
10191 }
10192 self.0.encode(encoder, offset + 0, depth)?;
10194 self.1.encode(encoder, offset + 1, depth)?;
10195 self.2.encode(encoder, offset + 2, depth)?;
10196 self.3.encode(encoder, offset + 4, depth)?;
10197 self.4.encode(encoder, offset + 8, depth)?;
10198 self.5.encode(encoder, offset + 16, depth)?;
10199 self.6.encode(encoder, offset + 18, depth)?;
10200 self.7.encode(encoder, offset + 20, depth)?;
10201 self.8.encode(encoder, offset + 24, depth)?;
10202 self.9.encode(encoder, offset + 32, depth)?;
10203 self.10.encode(encoder, offset + 40, depth)?;
10204 self.11.encode(encoder, offset + 48, depth)?;
10205 self.12.encode(encoder, offset + 52, depth)?;
10206 self.13.encode(encoder, offset + 55, depth)?;
10207 self.14.encode(encoder, offset + 58, depth)?;
10208 self.15.encode(encoder, offset + 64, depth)?;
10209 self.16.encode(encoder, offset + 80, depth)?;
10210 self.17.encode(encoder, offset + 104, depth)?;
10211 self.18.encode(encoder, offset + 108, depth)?;
10212 self.19.encode(encoder, offset + 116, depth)?;
10213 self.20.encode(encoder, offset + 128, depth)?;
10214 self.21.encode(encoder, offset + 152, depth)?;
10215 self.22.encode(encoder, offset + 168, depth)?;
10216 self.23.encode(encoder, offset + 192, depth)?;
10217 Ok(())
10218 }
10219 }
10220
10221 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {
10222 #[inline(always)]
10223 fn new_empty() -> Self {
10224 Self {
10225 b_0: fidl::new_empty!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10226 i8_0: fidl::new_empty!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10227 i16_0: fidl::new_empty!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10228 i32_0: fidl::new_empty!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10229 i64_0: fidl::new_empty!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10230 u8_0: fidl::new_empty!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10231 u16_0: fidl::new_empty!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10232 u32_0: fidl::new_empty!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10233 u64_0: fidl::new_empty!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10234 f32_0: fidl::new_empty!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10235 f64_0: fidl::new_empty!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10236 handle_0: fidl::new_empty!(
10237 fidl::encoding::Array<
10238 fidl::encoding::HandleType<
10239 fidl::Handle,
10240 { fidl::ObjectType::NONE.into_raw() },
10241 2147483648,
10242 >,
10243 1,
10244 >,
10245 fidl::encoding::DefaultFuchsiaResourceDialect
10246 ),
10247 b_1: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10248 i8_1: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10249 i16_1: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10250 i32_1: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10251 i64_1: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10252 u8_1: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10253 u16_1: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10254 u32_1: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10255 u64_1: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10256 f32_1: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10257 f64_1: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10258 handle_1: fidl::new_empty!(
10259 fidl::encoding::Array<
10260 fidl::encoding::HandleType<
10261 fidl::Handle,
10262 { fidl::ObjectType::NONE.into_raw() },
10263 2147483648,
10264 >,
10265 3,
10266 >,
10267 fidl::encoding::DefaultFuchsiaResourceDialect
10268 ),
10269 }
10270 }
10271
10272 #[inline]
10273 unsafe fn decode(
10274 &mut self,
10275 decoder: &mut fidl::encoding::Decoder<
10276 '_,
10277 fidl::encoding::DefaultFuchsiaResourceDialect,
10278 >,
10279 offset: usize,
10280 _depth: fidl::encoding::Depth,
10281 ) -> fidl::Result<()> {
10282 decoder.debug_check_bounds::<Self>(offset);
10283 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
10285 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10286 let mask = 0xff00u64;
10287 let maskedval = padval & mask;
10288 if maskedval != 0 {
10289 return Err(fidl::Error::NonZeroPadding {
10290 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
10291 });
10292 }
10293 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
10294 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10295 let mask = 0xffffffff00000000u64;
10296 let maskedval = padval & mask;
10297 if maskedval != 0 {
10298 return Err(fidl::Error::NonZeroPadding {
10299 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
10300 });
10301 }
10302 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
10303 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10304 let mask = 0xffffffff00000000u64;
10305 let maskedval = padval & mask;
10306 if maskedval != 0 {
10307 return Err(fidl::Error::NonZeroPadding {
10308 padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
10309 });
10310 }
10311 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
10312 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10313 let mask = 0xff000000u64;
10314 let maskedval = padval & mask;
10315 if maskedval != 0 {
10316 return Err(fidl::Error::NonZeroPadding {
10317 padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
10318 });
10319 }
10320 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10321 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10322 let mask = 0xffff0000u64;
10323 let maskedval = padval & mask;
10324 if maskedval != 0 {
10325 return Err(fidl::Error::NonZeroPadding {
10326 padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10327 });
10328 }
10329 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(160) };
10330 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10331 let mask = 0xffffffff00000000u64;
10332 let maskedval = padval & mask;
10333 if maskedval != 0 {
10334 return Err(fidl::Error::NonZeroPadding {
10335 padding_start: offset + 160 + ((mask as u64).trailing_zeros() / 8) as usize,
10336 });
10337 }
10338 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(200) };
10339 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10340 let mask = 0xffffffff00000000u64;
10341 let maskedval = padval & mask;
10342 if maskedval != 0 {
10343 return Err(fidl::Error::NonZeroPadding {
10344 padding_start: offset + 200 + ((mask as u64).trailing_zeros() / 8) as usize,
10345 });
10346 }
10347 fidl::decode!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_0, decoder, offset + 0, _depth)?;
10348 fidl::decode!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_0, decoder, offset + 1, _depth)?;
10349 fidl::decode!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_0, decoder, offset + 2, _depth)?;
10350 fidl::decode!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_0, decoder, offset + 4, _depth)?;
10351 fidl::decode!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_0, decoder, offset + 8, _depth)?;
10352 fidl::decode!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_0, decoder, offset + 16, _depth)?;
10353 fidl::decode!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_0, decoder, offset + 18, _depth)?;
10354 fidl::decode!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_0, decoder, offset + 20, _depth)?;
10355 fidl::decode!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_0, decoder, offset + 24, _depth)?;
10356 fidl::decode!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_0, decoder, offset + 32, _depth)?;
10357 fidl::decode!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_0, decoder, offset + 40, _depth)?;
10358 fidl::decode!(
10359 fidl::encoding::Array<
10360 fidl::encoding::HandleType<
10361 fidl::Handle,
10362 { fidl::ObjectType::NONE.into_raw() },
10363 2147483648,
10364 >,
10365 1,
10366 >,
10367 fidl::encoding::DefaultFuchsiaResourceDialect,
10368 &mut self.handle_0,
10369 decoder,
10370 offset + 48,
10371 _depth
10372 )?;
10373 fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_1, decoder, offset + 52, _depth)?;
10374 fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_1, decoder, offset + 55, _depth)?;
10375 fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_1, decoder, offset + 58, _depth)?;
10376 fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_1, decoder, offset + 64, _depth)?;
10377 fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_1, decoder, offset + 80, _depth)?;
10378 fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_1, decoder, offset + 104, _depth)?;
10379 fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_1, decoder, offset + 108, _depth)?;
10380 fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_1, decoder, offset + 116, _depth)?;
10381 fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_1, decoder, offset + 128, _depth)?;
10382 fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_1, decoder, offset + 152, _depth)?;
10383 fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_1, decoder, offset + 168, _depth)?;
10384 fidl::decode!(
10385 fidl::encoding::Array<
10386 fidl::encoding::HandleType<
10387 fidl::Handle,
10388 { fidl::ObjectType::NONE.into_raw() },
10389 2147483648,
10390 >,
10391 3,
10392 >,
10393 fidl::encoding::DefaultFuchsiaResourceDialect,
10394 &mut self.handle_1,
10395 decoder,
10396 offset + 192,
10397 _depth
10398 )?;
10399 Ok(())
10400 }
10401 }
10402
10403 impl fidl::encoding::ResourceTypeMarker for Arrays2d {
10404 type Borrowed<'a> = &'a mut Self;
10405 fn take_or_borrow<'a>(
10406 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10407 ) -> Self::Borrowed<'a> {
10408 value
10409 }
10410 }
10411
10412 unsafe impl fidl::encoding::TypeMarker for Arrays2d {
10413 type Owned = Self;
10414
10415 #[inline(always)]
10416 fn inline_align(_context: fidl::encoding::Context) -> usize {
10417 8
10418 }
10419
10420 #[inline(always)]
10421 fn inline_size(_context: fidl::encoding::Context) -> usize {
10422 288
10423 }
10424 }
10425
10426 unsafe impl fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10427 for &mut Arrays2d
10428 {
10429 #[inline]
10430 unsafe fn encode(
10431 self,
10432 encoder: &mut fidl::encoding::Encoder<
10433 '_,
10434 fidl::encoding::DefaultFuchsiaResourceDialect,
10435 >,
10436 offset: usize,
10437 _depth: fidl::encoding::Depth,
10438 ) -> fidl::Result<()> {
10439 encoder.debug_check_bounds::<Arrays2d>(offset);
10440 fidl::encoding::Encode::<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10442 (
10443 <fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
10444 <fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8),
10445 <fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16),
10446 <fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32),
10447 <fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64),
10448 <fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8),
10449 <fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16),
10450 <fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32),
10451 <fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64),
10452 <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32),
10453 <fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64),
10454 <fidl::encoding::Array<fidl::encoding::Array<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_handle),
10455 ),
10456 encoder, offset, _depth
10457 )
10458 }
10459 }
10460 unsafe impl<
10461 T0: fidl::encoding::Encode<
10462 fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10463 fidl::encoding::DefaultFuchsiaResourceDialect,
10464 >,
10465 T1: fidl::encoding::Encode<
10466 fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10467 fidl::encoding::DefaultFuchsiaResourceDialect,
10468 >,
10469 T2: fidl::encoding::Encode<
10470 fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10471 fidl::encoding::DefaultFuchsiaResourceDialect,
10472 >,
10473 T3: fidl::encoding::Encode<
10474 fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10475 fidl::encoding::DefaultFuchsiaResourceDialect,
10476 >,
10477 T4: fidl::encoding::Encode<
10478 fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10479 fidl::encoding::DefaultFuchsiaResourceDialect,
10480 >,
10481 T5: fidl::encoding::Encode<
10482 fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10483 fidl::encoding::DefaultFuchsiaResourceDialect,
10484 >,
10485 T6: fidl::encoding::Encode<
10486 fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10487 fidl::encoding::DefaultFuchsiaResourceDialect,
10488 >,
10489 T7: fidl::encoding::Encode<
10490 fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10491 fidl::encoding::DefaultFuchsiaResourceDialect,
10492 >,
10493 T8: fidl::encoding::Encode<
10494 fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10495 fidl::encoding::DefaultFuchsiaResourceDialect,
10496 >,
10497 T9: fidl::encoding::Encode<
10498 fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10499 fidl::encoding::DefaultFuchsiaResourceDialect,
10500 >,
10501 T10: fidl::encoding::Encode<
10502 fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10503 fidl::encoding::DefaultFuchsiaResourceDialect,
10504 >,
10505 T11: fidl::encoding::Encode<
10506 fidl::encoding::Array<
10507 fidl::encoding::Array<
10508 fidl::encoding::HandleType<
10509 fidl::Handle,
10510 { fidl::ObjectType::NONE.into_raw() },
10511 2147483648,
10512 >,
10513 2,
10514 >,
10515 3,
10516 >,
10517 fidl::encoding::DefaultFuchsiaResourceDialect,
10518 >,
10519 > fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10520 for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
10521 {
10522 #[inline]
10523 unsafe fn encode(
10524 self,
10525 encoder: &mut fidl::encoding::Encoder<
10526 '_,
10527 fidl::encoding::DefaultFuchsiaResourceDialect,
10528 >,
10529 offset: usize,
10530 depth: fidl::encoding::Depth,
10531 ) -> fidl::Result<()> {
10532 encoder.debug_check_bounds::<Arrays2d>(offset);
10533 unsafe {
10536 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10537 (ptr as *mut u64).write_unaligned(0);
10538 }
10539 unsafe {
10540 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(136);
10541 (ptr as *mut u64).write_unaligned(0);
10542 }
10543 self.0.encode(encoder, offset + 0, depth)?;
10545 self.1.encode(encoder, offset + 6, depth)?;
10546 self.2.encode(encoder, offset + 12, depth)?;
10547 self.3.encode(encoder, offset + 24, depth)?;
10548 self.4.encode(encoder, offset + 48, depth)?;
10549 self.5.encode(encoder, offset + 96, depth)?;
10550 self.6.encode(encoder, offset + 102, depth)?;
10551 self.7.encode(encoder, offset + 116, depth)?;
10552 self.8.encode(encoder, offset + 144, depth)?;
10553 self.9.encode(encoder, offset + 192, depth)?;
10554 self.10.encode(encoder, offset + 216, depth)?;
10555 self.11.encode(encoder, offset + 264, depth)?;
10556 Ok(())
10557 }
10558 }
10559
10560 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {
10561 #[inline(always)]
10562 fn new_empty() -> Self {
10563 Self {
10564 b: fidl::new_empty!(
10565 fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10566 fidl::encoding::DefaultFuchsiaResourceDialect
10567 ),
10568 i8: fidl::new_empty!(
10569 fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10570 fidl::encoding::DefaultFuchsiaResourceDialect
10571 ),
10572 i16: fidl::new_empty!(
10573 fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10574 fidl::encoding::DefaultFuchsiaResourceDialect
10575 ),
10576 i32: fidl::new_empty!(
10577 fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10578 fidl::encoding::DefaultFuchsiaResourceDialect
10579 ),
10580 i64: fidl::new_empty!(
10581 fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10582 fidl::encoding::DefaultFuchsiaResourceDialect
10583 ),
10584 u8: fidl::new_empty!(
10585 fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10586 fidl::encoding::DefaultFuchsiaResourceDialect
10587 ),
10588 u16: fidl::new_empty!(
10589 fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10590 fidl::encoding::DefaultFuchsiaResourceDialect
10591 ),
10592 u32: fidl::new_empty!(
10593 fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10594 fidl::encoding::DefaultFuchsiaResourceDialect
10595 ),
10596 u64: fidl::new_empty!(
10597 fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10598 fidl::encoding::DefaultFuchsiaResourceDialect
10599 ),
10600 f32: fidl::new_empty!(
10601 fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10602 fidl::encoding::DefaultFuchsiaResourceDialect
10603 ),
10604 f64: fidl::new_empty!(
10605 fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10606 fidl::encoding::DefaultFuchsiaResourceDialect
10607 ),
10608 handle_handle: fidl::new_empty!(
10609 fidl::encoding::Array<
10610 fidl::encoding::Array<
10611 fidl::encoding::HandleType<
10612 fidl::Handle,
10613 { fidl::ObjectType::NONE.into_raw() },
10614 2147483648,
10615 >,
10616 2,
10617 >,
10618 3,
10619 >,
10620 fidl::encoding::DefaultFuchsiaResourceDialect
10621 ),
10622 }
10623 }
10624
10625 #[inline]
10626 unsafe fn decode(
10627 &mut self,
10628 decoder: &mut fidl::encoding::Decoder<
10629 '_,
10630 fidl::encoding::DefaultFuchsiaResourceDialect,
10631 >,
10632 offset: usize,
10633 _depth: fidl::encoding::Depth,
10634 ) -> fidl::Result<()> {
10635 decoder.debug_check_bounds::<Self>(offset);
10636 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10638 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10639 let mask = 0xffff0000u64;
10640 let maskedval = padval & mask;
10641 if maskedval != 0 {
10642 return Err(fidl::Error::NonZeroPadding {
10643 padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10644 });
10645 }
10646 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(136) };
10647 let padval = unsafe { (ptr as *const u64).read_unaligned() };
10648 let mask = 0xffffffff00000000u64;
10649 let maskedval = padval & mask;
10650 if maskedval != 0 {
10651 return Err(fidl::Error::NonZeroPadding {
10652 padding_start: offset + 136 + ((mask as u64).trailing_zeros() / 8) as usize,
10653 });
10654 }
10655 fidl::decode!(
10656 fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10657 fidl::encoding::DefaultFuchsiaResourceDialect,
10658 &mut self.b,
10659 decoder,
10660 offset + 0,
10661 _depth
10662 )?;
10663 fidl::decode!(
10664 fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10665 fidl::encoding::DefaultFuchsiaResourceDialect,
10666 &mut self.i8,
10667 decoder,
10668 offset + 6,
10669 _depth
10670 )?;
10671 fidl::decode!(
10672 fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10673 fidl::encoding::DefaultFuchsiaResourceDialect,
10674 &mut self.i16,
10675 decoder,
10676 offset + 12,
10677 _depth
10678 )?;
10679 fidl::decode!(
10680 fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10681 fidl::encoding::DefaultFuchsiaResourceDialect,
10682 &mut self.i32,
10683 decoder,
10684 offset + 24,
10685 _depth
10686 )?;
10687 fidl::decode!(
10688 fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10689 fidl::encoding::DefaultFuchsiaResourceDialect,
10690 &mut self.i64,
10691 decoder,
10692 offset + 48,
10693 _depth
10694 )?;
10695 fidl::decode!(
10696 fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10697 fidl::encoding::DefaultFuchsiaResourceDialect,
10698 &mut self.u8,
10699 decoder,
10700 offset + 96,
10701 _depth
10702 )?;
10703 fidl::decode!(
10704 fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10705 fidl::encoding::DefaultFuchsiaResourceDialect,
10706 &mut self.u16,
10707 decoder,
10708 offset + 102,
10709 _depth
10710 )?;
10711 fidl::decode!(
10712 fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10713 fidl::encoding::DefaultFuchsiaResourceDialect,
10714 &mut self.u32,
10715 decoder,
10716 offset + 116,
10717 _depth
10718 )?;
10719 fidl::decode!(
10720 fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10721 fidl::encoding::DefaultFuchsiaResourceDialect,
10722 &mut self.u64,
10723 decoder,
10724 offset + 144,
10725 _depth
10726 )?;
10727 fidl::decode!(
10728 fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10729 fidl::encoding::DefaultFuchsiaResourceDialect,
10730 &mut self.f32,
10731 decoder,
10732 offset + 192,
10733 _depth
10734 )?;
10735 fidl::decode!(
10736 fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10737 fidl::encoding::DefaultFuchsiaResourceDialect,
10738 &mut self.f64,
10739 decoder,
10740 offset + 216,
10741 _depth
10742 )?;
10743 fidl::decode!(
10744 fidl::encoding::Array<
10745 fidl::encoding::Array<
10746 fidl::encoding::HandleType<
10747 fidl::Handle,
10748 { fidl::ObjectType::NONE.into_raw() },
10749 2147483648,
10750 >,
10751 2,
10752 >,
10753 3,
10754 >,
10755 fidl::encoding::DefaultFuchsiaResourceDialect,
10756 &mut self.handle_handle,
10757 decoder,
10758 offset + 264,
10759 _depth
10760 )?;
10761 Ok(())
10762 }
10763 }
10764
10765 impl fidl::encoding::ResourceTypeMarker for Handles {
10766 type Borrowed<'a> = &'a mut Self;
10767 fn take_or_borrow<'a>(
10768 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10769 ) -> Self::Borrowed<'a> {
10770 value
10771 }
10772 }
10773
10774 unsafe impl fidl::encoding::TypeMarker for Handles {
10775 type Owned = Self;
10776
10777 #[inline(always)]
10778 fn inline_align(_context: fidl::encoding::Context) -> usize {
10779 4
10780 }
10781
10782 #[inline(always)]
10783 fn inline_size(_context: fidl::encoding::Context) -> usize {
10784 108
10785 }
10786 }
10787
10788 unsafe impl fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
10789 for &mut Handles
10790 {
10791 #[inline]
10792 unsafe fn encode(
10793 self,
10794 encoder: &mut fidl::encoding::Encoder<
10795 '_,
10796 fidl::encoding::DefaultFuchsiaResourceDialect,
10797 >,
10798 offset: usize,
10799 _depth: fidl::encoding::Depth,
10800 ) -> fidl::Result<()> {
10801 encoder.debug_check_bounds::<Handles>(offset);
10802 fidl::encoding::Encode::<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10804 (
10805 <fidl::encoding::HandleType<
10806 fidl::Handle,
10807 { fidl::ObjectType::NONE.into_raw() },
10808 2147483648,
10809 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10810 &mut self.handle_handle,
10811 ),
10812 <fidl::encoding::HandleType<
10813 fidl::Process,
10814 { fidl::ObjectType::PROCESS.into_raw() },
10815 2147483648,
10816 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10817 &mut self.process_handle,
10818 ),
10819 <fidl::encoding::HandleType<
10820 fidl::Thread,
10821 { fidl::ObjectType::THREAD.into_raw() },
10822 2147483648,
10823 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10824 &mut self.thread_handle,
10825 ),
10826 <fidl::encoding::HandleType<
10827 fidl::Vmo,
10828 { fidl::ObjectType::VMO.into_raw() },
10829 2147483648,
10830 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10831 &mut self.vmo_handle
10832 ),
10833 <fidl::encoding::HandleType<
10834 fidl::Event,
10835 { fidl::ObjectType::EVENT.into_raw() },
10836 2147483648,
10837 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10838 &mut self.event_handle,
10839 ),
10840 <fidl::encoding::HandleType<
10841 fidl::Port,
10842 { fidl::ObjectType::PORT.into_raw() },
10843 2147483648,
10844 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10845 &mut self.port_handle
10846 ),
10847 <fidl::encoding::HandleType<
10848 fidl::Socket,
10849 { fidl::ObjectType::SOCKET.into_raw() },
10850 2147483648,
10851 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10852 &mut self.socket_handle,
10853 ),
10854 <fidl::encoding::HandleType<
10855 fidl::EventPair,
10856 { fidl::ObjectType::EVENTPAIR.into_raw() },
10857 2147483648,
10858 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10859 &mut self.eventpair_handle,
10860 ),
10861 <fidl::encoding::HandleType<
10862 fidl::Job,
10863 { fidl::ObjectType::JOB.into_raw() },
10864 2147483648,
10865 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10866 &mut self.job_handle
10867 ),
10868 <fidl::encoding::HandleType<
10869 fidl::Vmar,
10870 { fidl::ObjectType::VMAR.into_raw() },
10871 2147483648,
10872 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10873 &mut self.vmar_handle
10874 ),
10875 <fidl::encoding::HandleType<
10876 fidl::Fifo,
10877 { fidl::ObjectType::FIFO.into_raw() },
10878 2147483648,
10879 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10880 &mut self.fifo_handle
10881 ),
10882 <fidl::encoding::HandleType<
10883 fidl::Timer,
10884 { fidl::ObjectType::TIMER.into_raw() },
10885 2147483648,
10886 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10887 &mut self.timer_handle,
10888 ),
10889 <fidl::encoding::Optional<
10890 fidl::encoding::HandleType<
10891 fidl::Handle,
10892 { fidl::ObjectType::NONE.into_raw() },
10893 2147483648,
10894 >,
10895 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10896 &mut self.nullable_handle_handle,
10897 ),
10898 <fidl::encoding::Optional<
10899 fidl::encoding::HandleType<
10900 fidl::Process,
10901 { fidl::ObjectType::PROCESS.into_raw() },
10902 2147483648,
10903 >,
10904 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10905 &mut self.nullable_process_handle,
10906 ),
10907 <fidl::encoding::Optional<
10908 fidl::encoding::HandleType<
10909 fidl::Thread,
10910 { fidl::ObjectType::THREAD.into_raw() },
10911 2147483648,
10912 >,
10913 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10914 &mut self.nullable_thread_handle,
10915 ),
10916 <fidl::encoding::Optional<
10917 fidl::encoding::HandleType<
10918 fidl::Vmo,
10919 { fidl::ObjectType::VMO.into_raw() },
10920 2147483648,
10921 >,
10922 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10923 &mut self.nullable_vmo_handle,
10924 ),
10925 <fidl::encoding::Optional<
10926 fidl::encoding::HandleType<
10927 fidl::Channel,
10928 { fidl::ObjectType::CHANNEL.into_raw() },
10929 2147483648,
10930 >,
10931 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10932 &mut self.nullable_channel_handle,
10933 ),
10934 <fidl::encoding::Optional<
10935 fidl::encoding::HandleType<
10936 fidl::Event,
10937 { fidl::ObjectType::EVENT.into_raw() },
10938 2147483648,
10939 >,
10940 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10941 &mut self.nullable_event_handle,
10942 ),
10943 <fidl::encoding::Optional<
10944 fidl::encoding::HandleType<
10945 fidl::Port,
10946 { fidl::ObjectType::PORT.into_raw() },
10947 2147483648,
10948 >,
10949 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10950 &mut self.nullable_port_handle,
10951 ),
10952 <fidl::encoding::Optional<
10953 fidl::encoding::HandleType<
10954 fidl::Interrupt,
10955 { fidl::ObjectType::INTERRUPT.into_raw() },
10956 2147483648,
10957 >,
10958 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10959 &mut self.nullable_interrupt_handle,
10960 ),
10961 <fidl::encoding::Optional<
10962 fidl::encoding::HandleType<
10963 fidl::DebugLog,
10964 { fidl::ObjectType::DEBUGLOG.into_raw() },
10965 2147483648,
10966 >,
10967 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10968 &mut self.nullable_log_handle,
10969 ),
10970 <fidl::encoding::Optional<
10971 fidl::encoding::HandleType<
10972 fidl::Socket,
10973 { fidl::ObjectType::SOCKET.into_raw() },
10974 2147483648,
10975 >,
10976 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10977 &mut self.nullable_socket_handle,
10978 ),
10979 <fidl::encoding::Optional<
10980 fidl::encoding::HandleType<
10981 fidl::EventPair,
10982 { fidl::ObjectType::EVENTPAIR.into_raw() },
10983 2147483648,
10984 >,
10985 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10986 &mut self.nullable_eventpair_handle,
10987 ),
10988 <fidl::encoding::Optional<
10989 fidl::encoding::HandleType<
10990 fidl::Job,
10991 { fidl::ObjectType::JOB.into_raw() },
10992 2147483648,
10993 >,
10994 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10995 &mut self.nullable_job_handle,
10996 ),
10997 <fidl::encoding::Optional<
10998 fidl::encoding::HandleType<
10999 fidl::Vmar,
11000 { fidl::ObjectType::VMAR.into_raw() },
11001 2147483648,
11002 >,
11003 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11004 &mut self.nullable_vmar_handle,
11005 ),
11006 <fidl::encoding::Optional<
11007 fidl::encoding::HandleType<
11008 fidl::Fifo,
11009 { fidl::ObjectType::FIFO.into_raw() },
11010 2147483648,
11011 >,
11012 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11013 &mut self.nullable_fifo_handle,
11014 ),
11015 <fidl::encoding::Optional<
11016 fidl::encoding::HandleType<
11017 fidl::Timer,
11018 { fidl::ObjectType::TIMER.into_raw() },
11019 2147483648,
11020 >,
11021 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11022 &mut self.nullable_timer_handle,
11023 ),
11024 ),
11025 encoder,
11026 offset,
11027 _depth,
11028 )
11029 }
11030 }
11031 unsafe impl<
11032 T0: fidl::encoding::Encode<
11033 fidl::encoding::HandleType<
11034 fidl::Handle,
11035 { fidl::ObjectType::NONE.into_raw() },
11036 2147483648,
11037 >,
11038 fidl::encoding::DefaultFuchsiaResourceDialect,
11039 >,
11040 T1: fidl::encoding::Encode<
11041 fidl::encoding::HandleType<
11042 fidl::Process,
11043 { fidl::ObjectType::PROCESS.into_raw() },
11044 2147483648,
11045 >,
11046 fidl::encoding::DefaultFuchsiaResourceDialect,
11047 >,
11048 T2: fidl::encoding::Encode<
11049 fidl::encoding::HandleType<
11050 fidl::Thread,
11051 { fidl::ObjectType::THREAD.into_raw() },
11052 2147483648,
11053 >,
11054 fidl::encoding::DefaultFuchsiaResourceDialect,
11055 >,
11056 T3: fidl::encoding::Encode<
11057 fidl::encoding::HandleType<
11058 fidl::Vmo,
11059 { fidl::ObjectType::VMO.into_raw() },
11060 2147483648,
11061 >,
11062 fidl::encoding::DefaultFuchsiaResourceDialect,
11063 >,
11064 T4: fidl::encoding::Encode<
11065 fidl::encoding::HandleType<
11066 fidl::Event,
11067 { fidl::ObjectType::EVENT.into_raw() },
11068 2147483648,
11069 >,
11070 fidl::encoding::DefaultFuchsiaResourceDialect,
11071 >,
11072 T5: fidl::encoding::Encode<
11073 fidl::encoding::HandleType<
11074 fidl::Port,
11075 { fidl::ObjectType::PORT.into_raw() },
11076 2147483648,
11077 >,
11078 fidl::encoding::DefaultFuchsiaResourceDialect,
11079 >,
11080 T6: fidl::encoding::Encode<
11081 fidl::encoding::HandleType<
11082 fidl::Socket,
11083 { fidl::ObjectType::SOCKET.into_raw() },
11084 2147483648,
11085 >,
11086 fidl::encoding::DefaultFuchsiaResourceDialect,
11087 >,
11088 T7: fidl::encoding::Encode<
11089 fidl::encoding::HandleType<
11090 fidl::EventPair,
11091 { fidl::ObjectType::EVENTPAIR.into_raw() },
11092 2147483648,
11093 >,
11094 fidl::encoding::DefaultFuchsiaResourceDialect,
11095 >,
11096 T8: fidl::encoding::Encode<
11097 fidl::encoding::HandleType<
11098 fidl::Job,
11099 { fidl::ObjectType::JOB.into_raw() },
11100 2147483648,
11101 >,
11102 fidl::encoding::DefaultFuchsiaResourceDialect,
11103 >,
11104 T9: fidl::encoding::Encode<
11105 fidl::encoding::HandleType<
11106 fidl::Vmar,
11107 { fidl::ObjectType::VMAR.into_raw() },
11108 2147483648,
11109 >,
11110 fidl::encoding::DefaultFuchsiaResourceDialect,
11111 >,
11112 T10: fidl::encoding::Encode<
11113 fidl::encoding::HandleType<
11114 fidl::Fifo,
11115 { fidl::ObjectType::FIFO.into_raw() },
11116 2147483648,
11117 >,
11118 fidl::encoding::DefaultFuchsiaResourceDialect,
11119 >,
11120 T11: fidl::encoding::Encode<
11121 fidl::encoding::HandleType<
11122 fidl::Timer,
11123 { fidl::ObjectType::TIMER.into_raw() },
11124 2147483648,
11125 >,
11126 fidl::encoding::DefaultFuchsiaResourceDialect,
11127 >,
11128 T12: fidl::encoding::Encode<
11129 fidl::encoding::Optional<
11130 fidl::encoding::HandleType<
11131 fidl::Handle,
11132 { fidl::ObjectType::NONE.into_raw() },
11133 2147483648,
11134 >,
11135 >,
11136 fidl::encoding::DefaultFuchsiaResourceDialect,
11137 >,
11138 T13: fidl::encoding::Encode<
11139 fidl::encoding::Optional<
11140 fidl::encoding::HandleType<
11141 fidl::Process,
11142 { fidl::ObjectType::PROCESS.into_raw() },
11143 2147483648,
11144 >,
11145 >,
11146 fidl::encoding::DefaultFuchsiaResourceDialect,
11147 >,
11148 T14: fidl::encoding::Encode<
11149 fidl::encoding::Optional<
11150 fidl::encoding::HandleType<
11151 fidl::Thread,
11152 { fidl::ObjectType::THREAD.into_raw() },
11153 2147483648,
11154 >,
11155 >,
11156 fidl::encoding::DefaultFuchsiaResourceDialect,
11157 >,
11158 T15: fidl::encoding::Encode<
11159 fidl::encoding::Optional<
11160 fidl::encoding::HandleType<
11161 fidl::Vmo,
11162 { fidl::ObjectType::VMO.into_raw() },
11163 2147483648,
11164 >,
11165 >,
11166 fidl::encoding::DefaultFuchsiaResourceDialect,
11167 >,
11168 T16: fidl::encoding::Encode<
11169 fidl::encoding::Optional<
11170 fidl::encoding::HandleType<
11171 fidl::Channel,
11172 { fidl::ObjectType::CHANNEL.into_raw() },
11173 2147483648,
11174 >,
11175 >,
11176 fidl::encoding::DefaultFuchsiaResourceDialect,
11177 >,
11178 T17: fidl::encoding::Encode<
11179 fidl::encoding::Optional<
11180 fidl::encoding::HandleType<
11181 fidl::Event,
11182 { fidl::ObjectType::EVENT.into_raw() },
11183 2147483648,
11184 >,
11185 >,
11186 fidl::encoding::DefaultFuchsiaResourceDialect,
11187 >,
11188 T18: fidl::encoding::Encode<
11189 fidl::encoding::Optional<
11190 fidl::encoding::HandleType<
11191 fidl::Port,
11192 { fidl::ObjectType::PORT.into_raw() },
11193 2147483648,
11194 >,
11195 >,
11196 fidl::encoding::DefaultFuchsiaResourceDialect,
11197 >,
11198 T19: fidl::encoding::Encode<
11199 fidl::encoding::Optional<
11200 fidl::encoding::HandleType<
11201 fidl::Interrupt,
11202 { fidl::ObjectType::INTERRUPT.into_raw() },
11203 2147483648,
11204 >,
11205 >,
11206 fidl::encoding::DefaultFuchsiaResourceDialect,
11207 >,
11208 T20: fidl::encoding::Encode<
11209 fidl::encoding::Optional<
11210 fidl::encoding::HandleType<
11211 fidl::DebugLog,
11212 { fidl::ObjectType::DEBUGLOG.into_raw() },
11213 2147483648,
11214 >,
11215 >,
11216 fidl::encoding::DefaultFuchsiaResourceDialect,
11217 >,
11218 T21: fidl::encoding::Encode<
11219 fidl::encoding::Optional<
11220 fidl::encoding::HandleType<
11221 fidl::Socket,
11222 { fidl::ObjectType::SOCKET.into_raw() },
11223 2147483648,
11224 >,
11225 >,
11226 fidl::encoding::DefaultFuchsiaResourceDialect,
11227 >,
11228 T22: fidl::encoding::Encode<
11229 fidl::encoding::Optional<
11230 fidl::encoding::HandleType<
11231 fidl::EventPair,
11232 { fidl::ObjectType::EVENTPAIR.into_raw() },
11233 2147483648,
11234 >,
11235 >,
11236 fidl::encoding::DefaultFuchsiaResourceDialect,
11237 >,
11238 T23: fidl::encoding::Encode<
11239 fidl::encoding::Optional<
11240 fidl::encoding::HandleType<
11241 fidl::Job,
11242 { fidl::ObjectType::JOB.into_raw() },
11243 2147483648,
11244 >,
11245 >,
11246 fidl::encoding::DefaultFuchsiaResourceDialect,
11247 >,
11248 T24: fidl::encoding::Encode<
11249 fidl::encoding::Optional<
11250 fidl::encoding::HandleType<
11251 fidl::Vmar,
11252 { fidl::ObjectType::VMAR.into_raw() },
11253 2147483648,
11254 >,
11255 >,
11256 fidl::encoding::DefaultFuchsiaResourceDialect,
11257 >,
11258 T25: fidl::encoding::Encode<
11259 fidl::encoding::Optional<
11260 fidl::encoding::HandleType<
11261 fidl::Fifo,
11262 { fidl::ObjectType::FIFO.into_raw() },
11263 2147483648,
11264 >,
11265 >,
11266 fidl::encoding::DefaultFuchsiaResourceDialect,
11267 >,
11268 T26: fidl::encoding::Encode<
11269 fidl::encoding::Optional<
11270 fidl::encoding::HandleType<
11271 fidl::Timer,
11272 { fidl::ObjectType::TIMER.into_raw() },
11273 2147483648,
11274 >,
11275 >,
11276 fidl::encoding::DefaultFuchsiaResourceDialect,
11277 >,
11278 > fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
11279 for (
11280 T0,
11281 T1,
11282 T2,
11283 T3,
11284 T4,
11285 T5,
11286 T6,
11287 T7,
11288 T8,
11289 T9,
11290 T10,
11291 T11,
11292 T12,
11293 T13,
11294 T14,
11295 T15,
11296 T16,
11297 T17,
11298 T18,
11299 T19,
11300 T20,
11301 T21,
11302 T22,
11303 T23,
11304 T24,
11305 T25,
11306 T26,
11307 )
11308 {
11309 #[inline]
11310 unsafe fn encode(
11311 self,
11312 encoder: &mut fidl::encoding::Encoder<
11313 '_,
11314 fidl::encoding::DefaultFuchsiaResourceDialect,
11315 >,
11316 offset: usize,
11317 depth: fidl::encoding::Depth,
11318 ) -> fidl::Result<()> {
11319 encoder.debug_check_bounds::<Handles>(offset);
11320 self.0.encode(encoder, offset + 0, depth)?;
11324 self.1.encode(encoder, offset + 4, depth)?;
11325 self.2.encode(encoder, offset + 8, depth)?;
11326 self.3.encode(encoder, offset + 12, depth)?;
11327 self.4.encode(encoder, offset + 16, depth)?;
11328 self.5.encode(encoder, offset + 20, depth)?;
11329 self.6.encode(encoder, offset + 24, depth)?;
11330 self.7.encode(encoder, offset + 28, depth)?;
11331 self.8.encode(encoder, offset + 32, depth)?;
11332 self.9.encode(encoder, offset + 36, depth)?;
11333 self.10.encode(encoder, offset + 40, depth)?;
11334 self.11.encode(encoder, offset + 44, depth)?;
11335 self.12.encode(encoder, offset + 48, depth)?;
11336 self.13.encode(encoder, offset + 52, depth)?;
11337 self.14.encode(encoder, offset + 56, depth)?;
11338 self.15.encode(encoder, offset + 60, depth)?;
11339 self.16.encode(encoder, offset + 64, depth)?;
11340 self.17.encode(encoder, offset + 68, depth)?;
11341 self.18.encode(encoder, offset + 72, depth)?;
11342 self.19.encode(encoder, offset + 76, depth)?;
11343 self.20.encode(encoder, offset + 80, depth)?;
11344 self.21.encode(encoder, offset + 84, depth)?;
11345 self.22.encode(encoder, offset + 88, depth)?;
11346 self.23.encode(encoder, offset + 92, depth)?;
11347 self.24.encode(encoder, offset + 96, depth)?;
11348 self.25.encode(encoder, offset + 100, depth)?;
11349 self.26.encode(encoder, offset + 104, depth)?;
11350 Ok(())
11351 }
11352 }
11353
11354 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {
11355 #[inline(always)]
11356 fn new_empty() -> Self {
11357 Self {
11358 handle_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11359 process_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11360 thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11361 vmo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11362 event_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11363 port_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11364 socket_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11365 eventpair_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11366 job_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11367 vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11368 fifo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11369 timer_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11370 nullable_handle_handle: fidl::new_empty!(
11371 fidl::encoding::Optional<
11372 fidl::encoding::HandleType<
11373 fidl::Handle,
11374 { fidl::ObjectType::NONE.into_raw() },
11375 2147483648,
11376 >,
11377 >,
11378 fidl::encoding::DefaultFuchsiaResourceDialect
11379 ),
11380 nullable_process_handle: fidl::new_empty!(
11381 fidl::encoding::Optional<
11382 fidl::encoding::HandleType<
11383 fidl::Process,
11384 { fidl::ObjectType::PROCESS.into_raw() },
11385 2147483648,
11386 >,
11387 >,
11388 fidl::encoding::DefaultFuchsiaResourceDialect
11389 ),
11390 nullable_thread_handle: fidl::new_empty!(
11391 fidl::encoding::Optional<
11392 fidl::encoding::HandleType<
11393 fidl::Thread,
11394 { fidl::ObjectType::THREAD.into_raw() },
11395 2147483648,
11396 >,
11397 >,
11398 fidl::encoding::DefaultFuchsiaResourceDialect
11399 ),
11400 nullable_vmo_handle: fidl::new_empty!(
11401 fidl::encoding::Optional<
11402 fidl::encoding::HandleType<
11403 fidl::Vmo,
11404 { fidl::ObjectType::VMO.into_raw() },
11405 2147483648,
11406 >,
11407 >,
11408 fidl::encoding::DefaultFuchsiaResourceDialect
11409 ),
11410 nullable_channel_handle: fidl::new_empty!(
11411 fidl::encoding::Optional<
11412 fidl::encoding::HandleType<
11413 fidl::Channel,
11414 { fidl::ObjectType::CHANNEL.into_raw() },
11415 2147483648,
11416 >,
11417 >,
11418 fidl::encoding::DefaultFuchsiaResourceDialect
11419 ),
11420 nullable_event_handle: fidl::new_empty!(
11421 fidl::encoding::Optional<
11422 fidl::encoding::HandleType<
11423 fidl::Event,
11424 { fidl::ObjectType::EVENT.into_raw() },
11425 2147483648,
11426 >,
11427 >,
11428 fidl::encoding::DefaultFuchsiaResourceDialect
11429 ),
11430 nullable_port_handle: fidl::new_empty!(
11431 fidl::encoding::Optional<
11432 fidl::encoding::HandleType<
11433 fidl::Port,
11434 { fidl::ObjectType::PORT.into_raw() },
11435 2147483648,
11436 >,
11437 >,
11438 fidl::encoding::DefaultFuchsiaResourceDialect
11439 ),
11440 nullable_interrupt_handle: fidl::new_empty!(
11441 fidl::encoding::Optional<
11442 fidl::encoding::HandleType<
11443 fidl::Interrupt,
11444 { fidl::ObjectType::INTERRUPT.into_raw() },
11445 2147483648,
11446 >,
11447 >,
11448 fidl::encoding::DefaultFuchsiaResourceDialect
11449 ),
11450 nullable_log_handle: fidl::new_empty!(
11451 fidl::encoding::Optional<
11452 fidl::encoding::HandleType<
11453 fidl::DebugLog,
11454 { fidl::ObjectType::DEBUGLOG.into_raw() },
11455 2147483648,
11456 >,
11457 >,
11458 fidl::encoding::DefaultFuchsiaResourceDialect
11459 ),
11460 nullable_socket_handle: fidl::new_empty!(
11461 fidl::encoding::Optional<
11462 fidl::encoding::HandleType<
11463 fidl::Socket,
11464 { fidl::ObjectType::SOCKET.into_raw() },
11465 2147483648,
11466 >,
11467 >,
11468 fidl::encoding::DefaultFuchsiaResourceDialect
11469 ),
11470 nullable_eventpair_handle: fidl::new_empty!(
11471 fidl::encoding::Optional<
11472 fidl::encoding::HandleType<
11473 fidl::EventPair,
11474 { fidl::ObjectType::EVENTPAIR.into_raw() },
11475 2147483648,
11476 >,
11477 >,
11478 fidl::encoding::DefaultFuchsiaResourceDialect
11479 ),
11480 nullable_job_handle: fidl::new_empty!(
11481 fidl::encoding::Optional<
11482 fidl::encoding::HandleType<
11483 fidl::Job,
11484 { fidl::ObjectType::JOB.into_raw() },
11485 2147483648,
11486 >,
11487 >,
11488 fidl::encoding::DefaultFuchsiaResourceDialect
11489 ),
11490 nullable_vmar_handle: fidl::new_empty!(
11491 fidl::encoding::Optional<
11492 fidl::encoding::HandleType<
11493 fidl::Vmar,
11494 { fidl::ObjectType::VMAR.into_raw() },
11495 2147483648,
11496 >,
11497 >,
11498 fidl::encoding::DefaultFuchsiaResourceDialect
11499 ),
11500 nullable_fifo_handle: fidl::new_empty!(
11501 fidl::encoding::Optional<
11502 fidl::encoding::HandleType<
11503 fidl::Fifo,
11504 { fidl::ObjectType::FIFO.into_raw() },
11505 2147483648,
11506 >,
11507 >,
11508 fidl::encoding::DefaultFuchsiaResourceDialect
11509 ),
11510 nullable_timer_handle: fidl::new_empty!(
11511 fidl::encoding::Optional<
11512 fidl::encoding::HandleType<
11513 fidl::Timer,
11514 { fidl::ObjectType::TIMER.into_raw() },
11515 2147483648,
11516 >,
11517 >,
11518 fidl::encoding::DefaultFuchsiaResourceDialect
11519 ),
11520 }
11521 }
11522
11523 #[inline]
11524 unsafe fn decode(
11525 &mut self,
11526 decoder: &mut fidl::encoding::Decoder<
11527 '_,
11528 fidl::encoding::DefaultFuchsiaResourceDialect,
11529 >,
11530 offset: usize,
11531 _depth: fidl::encoding::Depth,
11532 ) -> fidl::Result<()> {
11533 decoder.debug_check_bounds::<Self>(offset);
11534 fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle_handle, decoder, offset + 0, _depth)?;
11536 fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.process_handle, decoder, offset + 4, _depth)?;
11537 fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 8, _depth)?;
11538 fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo_handle, decoder, offset + 12, _depth)?;
11539 fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event_handle, decoder, offset + 16, _depth)?;
11540 fidl::decode!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.port_handle, decoder, offset + 20, _depth)?;
11541 fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket_handle, decoder, offset + 24, _depth)?;
11542 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair_handle, decoder, offset + 28, _depth)?;
11543 fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job_handle, decoder, offset + 32, _depth)?;
11544 fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 36, _depth)?;
11545 fidl::decode!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.fifo_handle, decoder, offset + 40, _depth)?;
11546 fidl::decode!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.timer_handle, decoder, offset + 44, _depth)?;
11547 fidl::decode!(
11548 fidl::encoding::Optional<
11549 fidl::encoding::HandleType<
11550 fidl::Handle,
11551 { fidl::ObjectType::NONE.into_raw() },
11552 2147483648,
11553 >,
11554 >,
11555 fidl::encoding::DefaultFuchsiaResourceDialect,
11556 &mut self.nullable_handle_handle,
11557 decoder,
11558 offset + 48,
11559 _depth
11560 )?;
11561 fidl::decode!(
11562 fidl::encoding::Optional<
11563 fidl::encoding::HandleType<
11564 fidl::Process,
11565 { fidl::ObjectType::PROCESS.into_raw() },
11566 2147483648,
11567 >,
11568 >,
11569 fidl::encoding::DefaultFuchsiaResourceDialect,
11570 &mut self.nullable_process_handle,
11571 decoder,
11572 offset + 52,
11573 _depth
11574 )?;
11575 fidl::decode!(
11576 fidl::encoding::Optional<
11577 fidl::encoding::HandleType<
11578 fidl::Thread,
11579 { fidl::ObjectType::THREAD.into_raw() },
11580 2147483648,
11581 >,
11582 >,
11583 fidl::encoding::DefaultFuchsiaResourceDialect,
11584 &mut self.nullable_thread_handle,
11585 decoder,
11586 offset + 56,
11587 _depth
11588 )?;
11589 fidl::decode!(
11590 fidl::encoding::Optional<
11591 fidl::encoding::HandleType<
11592 fidl::Vmo,
11593 { fidl::ObjectType::VMO.into_raw() },
11594 2147483648,
11595 >,
11596 >,
11597 fidl::encoding::DefaultFuchsiaResourceDialect,
11598 &mut self.nullable_vmo_handle,
11599 decoder,
11600 offset + 60,
11601 _depth
11602 )?;
11603 fidl::decode!(
11604 fidl::encoding::Optional<
11605 fidl::encoding::HandleType<
11606 fidl::Channel,
11607 { fidl::ObjectType::CHANNEL.into_raw() },
11608 2147483648,
11609 >,
11610 >,
11611 fidl::encoding::DefaultFuchsiaResourceDialect,
11612 &mut self.nullable_channel_handle,
11613 decoder,
11614 offset + 64,
11615 _depth
11616 )?;
11617 fidl::decode!(
11618 fidl::encoding::Optional<
11619 fidl::encoding::HandleType<
11620 fidl::Event,
11621 { fidl::ObjectType::EVENT.into_raw() },
11622 2147483648,
11623 >,
11624 >,
11625 fidl::encoding::DefaultFuchsiaResourceDialect,
11626 &mut self.nullable_event_handle,
11627 decoder,
11628 offset + 68,
11629 _depth
11630 )?;
11631 fidl::decode!(
11632 fidl::encoding::Optional<
11633 fidl::encoding::HandleType<
11634 fidl::Port,
11635 { fidl::ObjectType::PORT.into_raw() },
11636 2147483648,
11637 >,
11638 >,
11639 fidl::encoding::DefaultFuchsiaResourceDialect,
11640 &mut self.nullable_port_handle,
11641 decoder,
11642 offset + 72,
11643 _depth
11644 )?;
11645 fidl::decode!(
11646 fidl::encoding::Optional<
11647 fidl::encoding::HandleType<
11648 fidl::Interrupt,
11649 { fidl::ObjectType::INTERRUPT.into_raw() },
11650 2147483648,
11651 >,
11652 >,
11653 fidl::encoding::DefaultFuchsiaResourceDialect,
11654 &mut self.nullable_interrupt_handle,
11655 decoder,
11656 offset + 76,
11657 _depth
11658 )?;
11659 fidl::decode!(
11660 fidl::encoding::Optional<
11661 fidl::encoding::HandleType<
11662 fidl::DebugLog,
11663 { fidl::ObjectType::DEBUGLOG.into_raw() },
11664 2147483648,
11665 >,
11666 >,
11667 fidl::encoding::DefaultFuchsiaResourceDialect,
11668 &mut self.nullable_log_handle,
11669 decoder,
11670 offset + 80,
11671 _depth
11672 )?;
11673 fidl::decode!(
11674 fidl::encoding::Optional<
11675 fidl::encoding::HandleType<
11676 fidl::Socket,
11677 { fidl::ObjectType::SOCKET.into_raw() },
11678 2147483648,
11679 >,
11680 >,
11681 fidl::encoding::DefaultFuchsiaResourceDialect,
11682 &mut self.nullable_socket_handle,
11683 decoder,
11684 offset + 84,
11685 _depth
11686 )?;
11687 fidl::decode!(
11688 fidl::encoding::Optional<
11689 fidl::encoding::HandleType<
11690 fidl::EventPair,
11691 { fidl::ObjectType::EVENTPAIR.into_raw() },
11692 2147483648,
11693 >,
11694 >,
11695 fidl::encoding::DefaultFuchsiaResourceDialect,
11696 &mut self.nullable_eventpair_handle,
11697 decoder,
11698 offset + 88,
11699 _depth
11700 )?;
11701 fidl::decode!(
11702 fidl::encoding::Optional<
11703 fidl::encoding::HandleType<
11704 fidl::Job,
11705 { fidl::ObjectType::JOB.into_raw() },
11706 2147483648,
11707 >,
11708 >,
11709 fidl::encoding::DefaultFuchsiaResourceDialect,
11710 &mut self.nullable_job_handle,
11711 decoder,
11712 offset + 92,
11713 _depth
11714 )?;
11715 fidl::decode!(
11716 fidl::encoding::Optional<
11717 fidl::encoding::HandleType<
11718 fidl::Vmar,
11719 { fidl::ObjectType::VMAR.into_raw() },
11720 2147483648,
11721 >,
11722 >,
11723 fidl::encoding::DefaultFuchsiaResourceDialect,
11724 &mut self.nullable_vmar_handle,
11725 decoder,
11726 offset + 96,
11727 _depth
11728 )?;
11729 fidl::decode!(
11730 fidl::encoding::Optional<
11731 fidl::encoding::HandleType<
11732 fidl::Fifo,
11733 { fidl::ObjectType::FIFO.into_raw() },
11734 2147483648,
11735 >,
11736 >,
11737 fidl::encoding::DefaultFuchsiaResourceDialect,
11738 &mut self.nullable_fifo_handle,
11739 decoder,
11740 offset + 100,
11741 _depth
11742 )?;
11743 fidl::decode!(
11744 fidl::encoding::Optional<
11745 fidl::encoding::HandleType<
11746 fidl::Timer,
11747 { fidl::ObjectType::TIMER.into_raw() },
11748 2147483648,
11749 >,
11750 >,
11751 fidl::encoding::DefaultFuchsiaResourceDialect,
11752 &mut self.nullable_timer_handle,
11753 decoder,
11754 offset + 104,
11755 _depth
11756 )?;
11757 Ok(())
11758 }
11759 }
11760
11761 impl fidl::encoding::ResourceTypeMarker for Vectors {
11762 type Borrowed<'a> = &'a mut Self;
11763 fn take_or_borrow<'a>(
11764 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
11765 ) -> Self::Borrowed<'a> {
11766 value
11767 }
11768 }
11769
11770 unsafe impl fidl::encoding::TypeMarker for Vectors {
11771 type Owned = Self;
11772
11773 #[inline(always)]
11774 fn inline_align(_context: fidl::encoding::Context) -> usize {
11775 8
11776 }
11777
11778 #[inline(always)]
11779 fn inline_size(_context: fidl::encoding::Context) -> usize {
11780 1920
11781 }
11782 }
11783
11784 unsafe impl fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
11785 for &mut Vectors
11786 {
11787 #[inline]
11788 unsafe fn encode(
11789 self,
11790 encoder: &mut fidl::encoding::Encoder<
11791 '_,
11792 fidl::encoding::DefaultFuchsiaResourceDialect,
11793 >,
11794 offset: usize,
11795 _depth: fidl::encoding::Depth,
11796 ) -> fidl::Result<()> {
11797 encoder.debug_check_bounds::<Vectors>(offset);
11798 fidl::encoding::Encode::<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
11800 (
11801 <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_0),
11802 <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_0),
11803 <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_0),
11804 <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_0),
11805 <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_0),
11806 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_0),
11807 <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_0),
11808 <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_0),
11809 <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_0),
11810 <fidl::encoding::UnboundedVector<f32> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_0),
11811 <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_0),
11812 <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_0),
11813 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_1),
11814 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_1),
11815 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_1),
11816 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_1),
11817 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_1),
11818 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_1),
11819 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_1),
11820 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_1),
11821 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_1),
11822 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_1),
11823 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_1),
11824 <fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_1),
11825 <fidl::encoding::Vector<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_0),
11826 <fidl::encoding::Vector<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_0),
11827 <fidl::encoding::Vector<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_0),
11828 <fidl::encoding::Vector<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_0),
11829 <fidl::encoding::Vector<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_0),
11830 <fidl::encoding::Vector<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_0),
11831 <fidl::encoding::Vector<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_0),
11832 <fidl::encoding::Vector<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_0),
11833 <fidl::encoding::Vector<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_0),
11834 <fidl::encoding::Vector<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_0),
11835 <fidl::encoding::Vector<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_0),
11836 <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_0),
11837 <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_1),
11838 <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_1),
11839 <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_1),
11840 <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_1),
11841 <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_1),
11842 <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_1),
11843 <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_1),
11844 <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_1),
11845 <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_1),
11846 <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_1),
11847 <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_1),
11848 <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_1),
11849 <fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_2),
11850 <fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_2),
11851 <fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_2),
11852 <fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_2),
11853 <fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_2),
11854 <fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_2),
11855 <fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_2),
11856 <fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_2),
11857 <fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_2),
11858 <fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_2),
11859 <fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_2),
11860 <fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_2),
11861 <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_0),
11862 <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_0),
11863 <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_0),
11864 <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_0),
11865 <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_0),
11866 <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_0),
11867 <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_0),
11868 <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_0),
11869 <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_0),
11870 <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_0),
11871 <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_0),
11872 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_0),
11873 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_1),
11874 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_1),
11875 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_1),
11876 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_1),
11877 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_1),
11878 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_1),
11879 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_1),
11880 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_1),
11881 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_1),
11882 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_1),
11883 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_1),
11884 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_1),
11885 <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_0),
11886 <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_0),
11887 <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_0),
11888 <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_0),
11889 <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_0),
11890 <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_0),
11891 <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_0),
11892 <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_0),
11893 <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_0),
11894 <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_0),
11895 <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_0),
11896 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_0),
11897 <fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_1),
11898 <fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_1),
11899 <fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_1),
11900 <fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_1),
11901 <fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_1),
11902 <fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_1),
11903 <fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_1),
11904 <fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_1),
11905 <fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_1),
11906 <fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_1),
11907 <fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_1),
11908 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_1),
11909 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_2),
11910 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_2),
11911 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_2),
11912 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_2),
11913 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_2),
11914 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_2),
11915 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_2),
11916 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_2),
11917 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_2),
11918 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_2),
11919 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_2),
11920 <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_2),
11921 ),
11922 encoder, offset, _depth
11923 )
11924 }
11925 }
11926 unsafe impl<
11927 T0: fidl::encoding::Encode<
11928 fidl::encoding::UnboundedVector<bool>,
11929 fidl::encoding::DefaultFuchsiaResourceDialect,
11930 >,
11931 T1: fidl::encoding::Encode<
11932 fidl::encoding::UnboundedVector<i8>,
11933 fidl::encoding::DefaultFuchsiaResourceDialect,
11934 >,
11935 T2: fidl::encoding::Encode<
11936 fidl::encoding::UnboundedVector<i16>,
11937 fidl::encoding::DefaultFuchsiaResourceDialect,
11938 >,
11939 T3: fidl::encoding::Encode<
11940 fidl::encoding::UnboundedVector<i32>,
11941 fidl::encoding::DefaultFuchsiaResourceDialect,
11942 >,
11943 T4: fidl::encoding::Encode<
11944 fidl::encoding::UnboundedVector<i64>,
11945 fidl::encoding::DefaultFuchsiaResourceDialect,
11946 >,
11947 T5: fidl::encoding::Encode<
11948 fidl::encoding::UnboundedVector<u8>,
11949 fidl::encoding::DefaultFuchsiaResourceDialect,
11950 >,
11951 T6: fidl::encoding::Encode<
11952 fidl::encoding::UnboundedVector<u16>,
11953 fidl::encoding::DefaultFuchsiaResourceDialect,
11954 >,
11955 T7: fidl::encoding::Encode<
11956 fidl::encoding::UnboundedVector<u32>,
11957 fidl::encoding::DefaultFuchsiaResourceDialect,
11958 >,
11959 T8: fidl::encoding::Encode<
11960 fidl::encoding::UnboundedVector<u64>,
11961 fidl::encoding::DefaultFuchsiaResourceDialect,
11962 >,
11963 T9: fidl::encoding::Encode<
11964 fidl::encoding::UnboundedVector<f32>,
11965 fidl::encoding::DefaultFuchsiaResourceDialect,
11966 >,
11967 T10: fidl::encoding::Encode<
11968 fidl::encoding::UnboundedVector<f64>,
11969 fidl::encoding::DefaultFuchsiaResourceDialect,
11970 >,
11971 T11: fidl::encoding::Encode<
11972 fidl::encoding::UnboundedVector<
11973 fidl::encoding::HandleType<
11974 fidl::Handle,
11975 { fidl::ObjectType::NONE.into_raw() },
11976 2147483648,
11977 >,
11978 >,
11979 fidl::encoding::DefaultFuchsiaResourceDialect,
11980 >,
11981 T12: fidl::encoding::Encode<
11982 fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
11983 fidl::encoding::DefaultFuchsiaResourceDialect,
11984 >,
11985 T13: fidl::encoding::Encode<
11986 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
11987 fidl::encoding::DefaultFuchsiaResourceDialect,
11988 >,
11989 T14: fidl::encoding::Encode<
11990 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
11991 fidl::encoding::DefaultFuchsiaResourceDialect,
11992 >,
11993 T15: fidl::encoding::Encode<
11994 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
11995 fidl::encoding::DefaultFuchsiaResourceDialect,
11996 >,
11997 T16: fidl::encoding::Encode<
11998 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
11999 fidl::encoding::DefaultFuchsiaResourceDialect,
12000 >,
12001 T17: fidl::encoding::Encode<
12002 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12003 fidl::encoding::DefaultFuchsiaResourceDialect,
12004 >,
12005 T18: fidl::encoding::Encode<
12006 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12007 fidl::encoding::DefaultFuchsiaResourceDialect,
12008 >,
12009 T19: fidl::encoding::Encode<
12010 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12011 fidl::encoding::DefaultFuchsiaResourceDialect,
12012 >,
12013 T20: fidl::encoding::Encode<
12014 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12015 fidl::encoding::DefaultFuchsiaResourceDialect,
12016 >,
12017 T21: fidl::encoding::Encode<
12018 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12019 fidl::encoding::DefaultFuchsiaResourceDialect,
12020 >,
12021 T22: fidl::encoding::Encode<
12022 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12023 fidl::encoding::DefaultFuchsiaResourceDialect,
12024 >,
12025 T23: fidl::encoding::Encode<
12026 fidl::encoding::UnboundedVector<
12027 fidl::encoding::Vector<
12028 fidl::encoding::HandleType<
12029 fidl::Handle,
12030 { fidl::ObjectType::NONE.into_raw() },
12031 2147483648,
12032 >,
12033 2,
12034 >,
12035 >,
12036 fidl::encoding::DefaultFuchsiaResourceDialect,
12037 >,
12038 T24: fidl::encoding::Encode<
12039 fidl::encoding::Vector<bool, 1>,
12040 fidl::encoding::DefaultFuchsiaResourceDialect,
12041 >,
12042 T25: fidl::encoding::Encode<
12043 fidl::encoding::Vector<i8, 1>,
12044 fidl::encoding::DefaultFuchsiaResourceDialect,
12045 >,
12046 T26: fidl::encoding::Encode<
12047 fidl::encoding::Vector<i16, 1>,
12048 fidl::encoding::DefaultFuchsiaResourceDialect,
12049 >,
12050 T27: fidl::encoding::Encode<
12051 fidl::encoding::Vector<i32, 1>,
12052 fidl::encoding::DefaultFuchsiaResourceDialect,
12053 >,
12054 T28: fidl::encoding::Encode<
12055 fidl::encoding::Vector<i64, 1>,
12056 fidl::encoding::DefaultFuchsiaResourceDialect,
12057 >,
12058 T29: fidl::encoding::Encode<
12059 fidl::encoding::Vector<u8, 1>,
12060 fidl::encoding::DefaultFuchsiaResourceDialect,
12061 >,
12062 T30: fidl::encoding::Encode<
12063 fidl::encoding::Vector<u16, 1>,
12064 fidl::encoding::DefaultFuchsiaResourceDialect,
12065 >,
12066 T31: fidl::encoding::Encode<
12067 fidl::encoding::Vector<u32, 1>,
12068 fidl::encoding::DefaultFuchsiaResourceDialect,
12069 >,
12070 T32: fidl::encoding::Encode<
12071 fidl::encoding::Vector<u64, 1>,
12072 fidl::encoding::DefaultFuchsiaResourceDialect,
12073 >,
12074 T33: fidl::encoding::Encode<
12075 fidl::encoding::Vector<f32, 1>,
12076 fidl::encoding::DefaultFuchsiaResourceDialect,
12077 >,
12078 T34: fidl::encoding::Encode<
12079 fidl::encoding::Vector<f64, 1>,
12080 fidl::encoding::DefaultFuchsiaResourceDialect,
12081 >,
12082 T35: fidl::encoding::Encode<
12083 fidl::encoding::Vector<
12084 fidl::encoding::HandleType<
12085 fidl::Handle,
12086 { fidl::ObjectType::NONE.into_raw() },
12087 2147483648,
12088 >,
12089 1,
12090 >,
12091 fidl::encoding::DefaultFuchsiaResourceDialect,
12092 >,
12093 T36: fidl::encoding::Encode<
12094 fidl::encoding::Vector<bool, 3>,
12095 fidl::encoding::DefaultFuchsiaResourceDialect,
12096 >,
12097 T37: fidl::encoding::Encode<
12098 fidl::encoding::Vector<i8, 3>,
12099 fidl::encoding::DefaultFuchsiaResourceDialect,
12100 >,
12101 T38: fidl::encoding::Encode<
12102 fidl::encoding::Vector<i16, 3>,
12103 fidl::encoding::DefaultFuchsiaResourceDialect,
12104 >,
12105 T39: fidl::encoding::Encode<
12106 fidl::encoding::Vector<i32, 3>,
12107 fidl::encoding::DefaultFuchsiaResourceDialect,
12108 >,
12109 T40: fidl::encoding::Encode<
12110 fidl::encoding::Vector<i64, 3>,
12111 fidl::encoding::DefaultFuchsiaResourceDialect,
12112 >,
12113 T41: fidl::encoding::Encode<
12114 fidl::encoding::Vector<u8, 3>,
12115 fidl::encoding::DefaultFuchsiaResourceDialect,
12116 >,
12117 T42: fidl::encoding::Encode<
12118 fidl::encoding::Vector<u16, 3>,
12119 fidl::encoding::DefaultFuchsiaResourceDialect,
12120 >,
12121 T43: fidl::encoding::Encode<
12122 fidl::encoding::Vector<u32, 3>,
12123 fidl::encoding::DefaultFuchsiaResourceDialect,
12124 >,
12125 T44: fidl::encoding::Encode<
12126 fidl::encoding::Vector<u64, 3>,
12127 fidl::encoding::DefaultFuchsiaResourceDialect,
12128 >,
12129 T45: fidl::encoding::Encode<
12130 fidl::encoding::Vector<f32, 3>,
12131 fidl::encoding::DefaultFuchsiaResourceDialect,
12132 >,
12133 T46: fidl::encoding::Encode<
12134 fidl::encoding::Vector<f64, 3>,
12135 fidl::encoding::DefaultFuchsiaResourceDialect,
12136 >,
12137 T47: fidl::encoding::Encode<
12138 fidl::encoding::Vector<
12139 fidl::encoding::HandleType<
12140 fidl::Handle,
12141 { fidl::ObjectType::NONE.into_raw() },
12142 2147483648,
12143 >,
12144 3,
12145 >,
12146 fidl::encoding::DefaultFuchsiaResourceDialect,
12147 >,
12148 T48: fidl::encoding::Encode<
12149 fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12150 fidl::encoding::DefaultFuchsiaResourceDialect,
12151 >,
12152 T49: fidl::encoding::Encode<
12153 fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12154 fidl::encoding::DefaultFuchsiaResourceDialect,
12155 >,
12156 T50: fidl::encoding::Encode<
12157 fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12158 fidl::encoding::DefaultFuchsiaResourceDialect,
12159 >,
12160 T51: fidl::encoding::Encode<
12161 fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12162 fidl::encoding::DefaultFuchsiaResourceDialect,
12163 >,
12164 T52: fidl::encoding::Encode<
12165 fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12166 fidl::encoding::DefaultFuchsiaResourceDialect,
12167 >,
12168 T53: fidl::encoding::Encode<
12169 fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12170 fidl::encoding::DefaultFuchsiaResourceDialect,
12171 >,
12172 T54: fidl::encoding::Encode<
12173 fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12174 fidl::encoding::DefaultFuchsiaResourceDialect,
12175 >,
12176 T55: fidl::encoding::Encode<
12177 fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12178 fidl::encoding::DefaultFuchsiaResourceDialect,
12179 >,
12180 T56: fidl::encoding::Encode<
12181 fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12182 fidl::encoding::DefaultFuchsiaResourceDialect,
12183 >,
12184 T57: fidl::encoding::Encode<
12185 fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12186 fidl::encoding::DefaultFuchsiaResourceDialect,
12187 >,
12188 T58: fidl::encoding::Encode<
12189 fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12190 fidl::encoding::DefaultFuchsiaResourceDialect,
12191 >,
12192 T59: fidl::encoding::Encode<
12193 fidl::encoding::Vector<
12194 fidl::encoding::Vector<
12195 fidl::encoding::HandleType<
12196 fidl::Handle,
12197 { fidl::ObjectType::NONE.into_raw() },
12198 2147483648,
12199 >,
12200 2,
12201 >,
12202 3,
12203 >,
12204 fidl::encoding::DefaultFuchsiaResourceDialect,
12205 >,
12206 T60: fidl::encoding::Encode<
12207 fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12208 fidl::encoding::DefaultFuchsiaResourceDialect,
12209 >,
12210 T61: fidl::encoding::Encode<
12211 fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12212 fidl::encoding::DefaultFuchsiaResourceDialect,
12213 >,
12214 T62: fidl::encoding::Encode<
12215 fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12216 fidl::encoding::DefaultFuchsiaResourceDialect,
12217 >,
12218 T63: fidl::encoding::Encode<
12219 fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12220 fidl::encoding::DefaultFuchsiaResourceDialect,
12221 >,
12222 T64: fidl::encoding::Encode<
12223 fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12224 fidl::encoding::DefaultFuchsiaResourceDialect,
12225 >,
12226 T65: fidl::encoding::Encode<
12227 fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12228 fidl::encoding::DefaultFuchsiaResourceDialect,
12229 >,
12230 T66: fidl::encoding::Encode<
12231 fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12232 fidl::encoding::DefaultFuchsiaResourceDialect,
12233 >,
12234 T67: fidl::encoding::Encode<
12235 fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12236 fidl::encoding::DefaultFuchsiaResourceDialect,
12237 >,
12238 T68: fidl::encoding::Encode<
12239 fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12240 fidl::encoding::DefaultFuchsiaResourceDialect,
12241 >,
12242 T69: fidl::encoding::Encode<
12243 fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12244 fidl::encoding::DefaultFuchsiaResourceDialect,
12245 >,
12246 T70: fidl::encoding::Encode<
12247 fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12248 fidl::encoding::DefaultFuchsiaResourceDialect,
12249 >,
12250 T71: fidl::encoding::Encode<
12251 fidl::encoding::Optional<
12252 fidl::encoding::Vector<
12253 fidl::encoding::HandleType<
12254 fidl::Handle,
12255 { fidl::ObjectType::NONE.into_raw() },
12256 2147483648,
12257 >,
12258 1,
12259 >,
12260 >,
12261 fidl::encoding::DefaultFuchsiaResourceDialect,
12262 >,
12263 T72: fidl::encoding::Encode<
12264 fidl::encoding::Optional<
12265 fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12266 >,
12267 fidl::encoding::DefaultFuchsiaResourceDialect,
12268 >,
12269 T73: fidl::encoding::Encode<
12270 fidl::encoding::Optional<
12271 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12272 >,
12273 fidl::encoding::DefaultFuchsiaResourceDialect,
12274 >,
12275 T74: fidl::encoding::Encode<
12276 fidl::encoding::Optional<
12277 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12278 >,
12279 fidl::encoding::DefaultFuchsiaResourceDialect,
12280 >,
12281 T75: fidl::encoding::Encode<
12282 fidl::encoding::Optional<
12283 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12284 >,
12285 fidl::encoding::DefaultFuchsiaResourceDialect,
12286 >,
12287 T76: fidl::encoding::Encode<
12288 fidl::encoding::Optional<
12289 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12290 >,
12291 fidl::encoding::DefaultFuchsiaResourceDialect,
12292 >,
12293 T77: fidl::encoding::Encode<
12294 fidl::encoding::Optional<
12295 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12296 >,
12297 fidl::encoding::DefaultFuchsiaResourceDialect,
12298 >,
12299 T78: fidl::encoding::Encode<
12300 fidl::encoding::Optional<
12301 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12302 >,
12303 fidl::encoding::DefaultFuchsiaResourceDialect,
12304 >,
12305 T79: fidl::encoding::Encode<
12306 fidl::encoding::Optional<
12307 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12308 >,
12309 fidl::encoding::DefaultFuchsiaResourceDialect,
12310 >,
12311 T80: fidl::encoding::Encode<
12312 fidl::encoding::Optional<
12313 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12314 >,
12315 fidl::encoding::DefaultFuchsiaResourceDialect,
12316 >,
12317 T81: fidl::encoding::Encode<
12318 fidl::encoding::Optional<
12319 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12320 >,
12321 fidl::encoding::DefaultFuchsiaResourceDialect,
12322 >,
12323 T82: fidl::encoding::Encode<
12324 fidl::encoding::Optional<
12325 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12326 >,
12327 fidl::encoding::DefaultFuchsiaResourceDialect,
12328 >,
12329 T83: fidl::encoding::Encode<
12330 fidl::encoding::Optional<
12331 fidl::encoding::UnboundedVector<
12332 fidl::encoding::Vector<
12333 fidl::encoding::HandleType<
12334 fidl::Handle,
12335 { fidl::ObjectType::NONE.into_raw() },
12336 2147483648,
12337 >,
12338 2,
12339 >,
12340 >,
12341 >,
12342 fidl::encoding::DefaultFuchsiaResourceDialect,
12343 >,
12344 T84: fidl::encoding::Encode<
12345 fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12346 fidl::encoding::DefaultFuchsiaResourceDialect,
12347 >,
12348 T85: fidl::encoding::Encode<
12349 fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12350 fidl::encoding::DefaultFuchsiaResourceDialect,
12351 >,
12352 T86: fidl::encoding::Encode<
12353 fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12354 fidl::encoding::DefaultFuchsiaResourceDialect,
12355 >,
12356 T87: fidl::encoding::Encode<
12357 fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12358 fidl::encoding::DefaultFuchsiaResourceDialect,
12359 >,
12360 T88: fidl::encoding::Encode<
12361 fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12362 fidl::encoding::DefaultFuchsiaResourceDialect,
12363 >,
12364 T89: fidl::encoding::Encode<
12365 fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12366 fidl::encoding::DefaultFuchsiaResourceDialect,
12367 >,
12368 T90: fidl::encoding::Encode<
12369 fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12370 fidl::encoding::DefaultFuchsiaResourceDialect,
12371 >,
12372 T91: fidl::encoding::Encode<
12373 fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12374 fidl::encoding::DefaultFuchsiaResourceDialect,
12375 >,
12376 T92: fidl::encoding::Encode<
12377 fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12378 fidl::encoding::DefaultFuchsiaResourceDialect,
12379 >,
12380 T93: fidl::encoding::Encode<
12381 fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12382 fidl::encoding::DefaultFuchsiaResourceDialect,
12383 >,
12384 T94: fidl::encoding::Encode<
12385 fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12386 fidl::encoding::DefaultFuchsiaResourceDialect,
12387 >,
12388 T95: fidl::encoding::Encode<
12389 fidl::encoding::Optional<
12390 fidl::encoding::Vector<
12391 fidl::encoding::HandleType<
12392 fidl::Handle,
12393 { fidl::ObjectType::NONE.into_raw() },
12394 2147483648,
12395 >,
12396 1,
12397 >,
12398 >,
12399 fidl::encoding::DefaultFuchsiaResourceDialect,
12400 >,
12401 T96: fidl::encoding::Encode<
12402 fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
12403 fidl::encoding::DefaultFuchsiaResourceDialect,
12404 >,
12405 T97: fidl::encoding::Encode<
12406 fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
12407 fidl::encoding::DefaultFuchsiaResourceDialect,
12408 >,
12409 T98: fidl::encoding::Encode<
12410 fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
12411 fidl::encoding::DefaultFuchsiaResourceDialect,
12412 >,
12413 T99: fidl::encoding::Encode<
12414 fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
12415 fidl::encoding::DefaultFuchsiaResourceDialect,
12416 >,
12417 T100: fidl::encoding::Encode<
12418 fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
12419 fidl::encoding::DefaultFuchsiaResourceDialect,
12420 >,
12421 T101: fidl::encoding::Encode<
12422 fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
12423 fidl::encoding::DefaultFuchsiaResourceDialect,
12424 >,
12425 T102: fidl::encoding::Encode<
12426 fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
12427 fidl::encoding::DefaultFuchsiaResourceDialect,
12428 >,
12429 T103: fidl::encoding::Encode<
12430 fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
12431 fidl::encoding::DefaultFuchsiaResourceDialect,
12432 >,
12433 T104: fidl::encoding::Encode<
12434 fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
12435 fidl::encoding::DefaultFuchsiaResourceDialect,
12436 >,
12437 T105: fidl::encoding::Encode<
12438 fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
12439 fidl::encoding::DefaultFuchsiaResourceDialect,
12440 >,
12441 T106: fidl::encoding::Encode<
12442 fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
12443 fidl::encoding::DefaultFuchsiaResourceDialect,
12444 >,
12445 T107: fidl::encoding::Encode<
12446 fidl::encoding::Optional<
12447 fidl::encoding::Vector<
12448 fidl::encoding::HandleType<
12449 fidl::Handle,
12450 { fidl::ObjectType::NONE.into_raw() },
12451 2147483648,
12452 >,
12453 3,
12454 >,
12455 >,
12456 fidl::encoding::DefaultFuchsiaResourceDialect,
12457 >,
12458 T108: fidl::encoding::Encode<
12459 fidl::encoding::Optional<
12460 fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12461 >,
12462 fidl::encoding::DefaultFuchsiaResourceDialect,
12463 >,
12464 T109: fidl::encoding::Encode<
12465 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
12466 fidl::encoding::DefaultFuchsiaResourceDialect,
12467 >,
12468 T110: fidl::encoding::Encode<
12469 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
12470 fidl::encoding::DefaultFuchsiaResourceDialect,
12471 >,
12472 T111: fidl::encoding::Encode<
12473 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
12474 fidl::encoding::DefaultFuchsiaResourceDialect,
12475 >,
12476 T112: fidl::encoding::Encode<
12477 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
12478 fidl::encoding::DefaultFuchsiaResourceDialect,
12479 >,
12480 T113: fidl::encoding::Encode<
12481 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
12482 fidl::encoding::DefaultFuchsiaResourceDialect,
12483 >,
12484 T114: fidl::encoding::Encode<
12485 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
12486 fidl::encoding::DefaultFuchsiaResourceDialect,
12487 >,
12488 T115: fidl::encoding::Encode<
12489 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
12490 fidl::encoding::DefaultFuchsiaResourceDialect,
12491 >,
12492 T116: fidl::encoding::Encode<
12493 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
12494 fidl::encoding::DefaultFuchsiaResourceDialect,
12495 >,
12496 T117: fidl::encoding::Encode<
12497 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
12498 fidl::encoding::DefaultFuchsiaResourceDialect,
12499 >,
12500 T118: fidl::encoding::Encode<
12501 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
12502 fidl::encoding::DefaultFuchsiaResourceDialect,
12503 >,
12504 T119: fidl::encoding::Encode<
12505 fidl::encoding::Optional<
12506 fidl::encoding::Vector<
12507 fidl::encoding::Vector<
12508 fidl::encoding::HandleType<
12509 fidl::Handle,
12510 { fidl::ObjectType::NONE.into_raw() },
12511 2147483648,
12512 >,
12513 2,
12514 >,
12515 3,
12516 >,
12517 >,
12518 fidl::encoding::DefaultFuchsiaResourceDialect,
12519 >,
12520 > fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
12521 for (
12522 T0,
12523 T1,
12524 T2,
12525 T3,
12526 T4,
12527 T5,
12528 T6,
12529 T7,
12530 T8,
12531 T9,
12532 T10,
12533 T11,
12534 T12,
12535 T13,
12536 T14,
12537 T15,
12538 T16,
12539 T17,
12540 T18,
12541 T19,
12542 T20,
12543 T21,
12544 T22,
12545 T23,
12546 T24,
12547 T25,
12548 T26,
12549 T27,
12550 T28,
12551 T29,
12552 T30,
12553 T31,
12554 T32,
12555 T33,
12556 T34,
12557 T35,
12558 T36,
12559 T37,
12560 T38,
12561 T39,
12562 T40,
12563 T41,
12564 T42,
12565 T43,
12566 T44,
12567 T45,
12568 T46,
12569 T47,
12570 T48,
12571 T49,
12572 T50,
12573 T51,
12574 T52,
12575 T53,
12576 T54,
12577 T55,
12578 T56,
12579 T57,
12580 T58,
12581 T59,
12582 T60,
12583 T61,
12584 T62,
12585 T63,
12586 T64,
12587 T65,
12588 T66,
12589 T67,
12590 T68,
12591 T69,
12592 T70,
12593 T71,
12594 T72,
12595 T73,
12596 T74,
12597 T75,
12598 T76,
12599 T77,
12600 T78,
12601 T79,
12602 T80,
12603 T81,
12604 T82,
12605 T83,
12606 T84,
12607 T85,
12608 T86,
12609 T87,
12610 T88,
12611 T89,
12612 T90,
12613 T91,
12614 T92,
12615 T93,
12616 T94,
12617 T95,
12618 T96,
12619 T97,
12620 T98,
12621 T99,
12622 T100,
12623 T101,
12624 T102,
12625 T103,
12626 T104,
12627 T105,
12628 T106,
12629 T107,
12630 T108,
12631 T109,
12632 T110,
12633 T111,
12634 T112,
12635 T113,
12636 T114,
12637 T115,
12638 T116,
12639 T117,
12640 T118,
12641 T119,
12642 )
12643 {
12644 #[inline]
12645 unsafe fn encode(
12646 self,
12647 encoder: &mut fidl::encoding::Encoder<
12648 '_,
12649 fidl::encoding::DefaultFuchsiaResourceDialect,
12650 >,
12651 offset: usize,
12652 depth: fidl::encoding::Depth,
12653 ) -> fidl::Result<()> {
12654 encoder.debug_check_bounds::<Vectors>(offset);
12655 self.0.encode(encoder, offset + 0, depth)?;
12659 self.1.encode(encoder, offset + 16, depth)?;
12660 self.2.encode(encoder, offset + 32, depth)?;
12661 self.3.encode(encoder, offset + 48, depth)?;
12662 self.4.encode(encoder, offset + 64, depth)?;
12663 self.5.encode(encoder, offset + 80, depth)?;
12664 self.6.encode(encoder, offset + 96, depth)?;
12665 self.7.encode(encoder, offset + 112, depth)?;
12666 self.8.encode(encoder, offset + 128, depth)?;
12667 self.9.encode(encoder, offset + 144, depth)?;
12668 self.10.encode(encoder, offset + 160, depth)?;
12669 self.11.encode(encoder, offset + 176, depth)?;
12670 self.12.encode(encoder, offset + 192, depth)?;
12671 self.13.encode(encoder, offset + 208, depth)?;
12672 self.14.encode(encoder, offset + 224, depth)?;
12673 self.15.encode(encoder, offset + 240, depth)?;
12674 self.16.encode(encoder, offset + 256, depth)?;
12675 self.17.encode(encoder, offset + 272, depth)?;
12676 self.18.encode(encoder, offset + 288, depth)?;
12677 self.19.encode(encoder, offset + 304, depth)?;
12678 self.20.encode(encoder, offset + 320, depth)?;
12679 self.21.encode(encoder, offset + 336, depth)?;
12680 self.22.encode(encoder, offset + 352, depth)?;
12681 self.23.encode(encoder, offset + 368, depth)?;
12682 self.24.encode(encoder, offset + 384, depth)?;
12683 self.25.encode(encoder, offset + 400, depth)?;
12684 self.26.encode(encoder, offset + 416, depth)?;
12685 self.27.encode(encoder, offset + 432, depth)?;
12686 self.28.encode(encoder, offset + 448, depth)?;
12687 self.29.encode(encoder, offset + 464, depth)?;
12688 self.30.encode(encoder, offset + 480, depth)?;
12689 self.31.encode(encoder, offset + 496, depth)?;
12690 self.32.encode(encoder, offset + 512, depth)?;
12691 self.33.encode(encoder, offset + 528, depth)?;
12692 self.34.encode(encoder, offset + 544, depth)?;
12693 self.35.encode(encoder, offset + 560, depth)?;
12694 self.36.encode(encoder, offset + 576, depth)?;
12695 self.37.encode(encoder, offset + 592, depth)?;
12696 self.38.encode(encoder, offset + 608, depth)?;
12697 self.39.encode(encoder, offset + 624, depth)?;
12698 self.40.encode(encoder, offset + 640, depth)?;
12699 self.41.encode(encoder, offset + 656, depth)?;
12700 self.42.encode(encoder, offset + 672, depth)?;
12701 self.43.encode(encoder, offset + 688, depth)?;
12702 self.44.encode(encoder, offset + 704, depth)?;
12703 self.45.encode(encoder, offset + 720, depth)?;
12704 self.46.encode(encoder, offset + 736, depth)?;
12705 self.47.encode(encoder, offset + 752, depth)?;
12706 self.48.encode(encoder, offset + 768, depth)?;
12707 self.49.encode(encoder, offset + 784, depth)?;
12708 self.50.encode(encoder, offset + 800, depth)?;
12709 self.51.encode(encoder, offset + 816, depth)?;
12710 self.52.encode(encoder, offset + 832, depth)?;
12711 self.53.encode(encoder, offset + 848, depth)?;
12712 self.54.encode(encoder, offset + 864, depth)?;
12713 self.55.encode(encoder, offset + 880, depth)?;
12714 self.56.encode(encoder, offset + 896, depth)?;
12715 self.57.encode(encoder, offset + 912, depth)?;
12716 self.58.encode(encoder, offset + 928, depth)?;
12717 self.59.encode(encoder, offset + 944, depth)?;
12718 self.60.encode(encoder, offset + 960, depth)?;
12719 self.61.encode(encoder, offset + 976, depth)?;
12720 self.62.encode(encoder, offset + 992, depth)?;
12721 self.63.encode(encoder, offset + 1008, depth)?;
12722 self.64.encode(encoder, offset + 1024, depth)?;
12723 self.65.encode(encoder, offset + 1040, depth)?;
12724 self.66.encode(encoder, offset + 1056, depth)?;
12725 self.67.encode(encoder, offset + 1072, depth)?;
12726 self.68.encode(encoder, offset + 1088, depth)?;
12727 self.69.encode(encoder, offset + 1104, depth)?;
12728 self.70.encode(encoder, offset + 1120, depth)?;
12729 self.71.encode(encoder, offset + 1136, depth)?;
12730 self.72.encode(encoder, offset + 1152, depth)?;
12731 self.73.encode(encoder, offset + 1168, depth)?;
12732 self.74.encode(encoder, offset + 1184, depth)?;
12733 self.75.encode(encoder, offset + 1200, depth)?;
12734 self.76.encode(encoder, offset + 1216, depth)?;
12735 self.77.encode(encoder, offset + 1232, depth)?;
12736 self.78.encode(encoder, offset + 1248, depth)?;
12737 self.79.encode(encoder, offset + 1264, depth)?;
12738 self.80.encode(encoder, offset + 1280, depth)?;
12739 self.81.encode(encoder, offset + 1296, depth)?;
12740 self.82.encode(encoder, offset + 1312, depth)?;
12741 self.83.encode(encoder, offset + 1328, depth)?;
12742 self.84.encode(encoder, offset + 1344, depth)?;
12743 self.85.encode(encoder, offset + 1360, depth)?;
12744 self.86.encode(encoder, offset + 1376, depth)?;
12745 self.87.encode(encoder, offset + 1392, depth)?;
12746 self.88.encode(encoder, offset + 1408, depth)?;
12747 self.89.encode(encoder, offset + 1424, depth)?;
12748 self.90.encode(encoder, offset + 1440, depth)?;
12749 self.91.encode(encoder, offset + 1456, depth)?;
12750 self.92.encode(encoder, offset + 1472, depth)?;
12751 self.93.encode(encoder, offset + 1488, depth)?;
12752 self.94.encode(encoder, offset + 1504, depth)?;
12753 self.95.encode(encoder, offset + 1520, depth)?;
12754 self.96.encode(encoder, offset + 1536, depth)?;
12755 self.97.encode(encoder, offset + 1552, depth)?;
12756 self.98.encode(encoder, offset + 1568, depth)?;
12757 self.99.encode(encoder, offset + 1584, depth)?;
12758 self.100.encode(encoder, offset + 1600, depth)?;
12759 self.101.encode(encoder, offset + 1616, depth)?;
12760 self.102.encode(encoder, offset + 1632, depth)?;
12761 self.103.encode(encoder, offset + 1648, depth)?;
12762 self.104.encode(encoder, offset + 1664, depth)?;
12763 self.105.encode(encoder, offset + 1680, depth)?;
12764 self.106.encode(encoder, offset + 1696, depth)?;
12765 self.107.encode(encoder, offset + 1712, depth)?;
12766 self.108.encode(encoder, offset + 1728, depth)?;
12767 self.109.encode(encoder, offset + 1744, depth)?;
12768 self.110.encode(encoder, offset + 1760, depth)?;
12769 self.111.encode(encoder, offset + 1776, depth)?;
12770 self.112.encode(encoder, offset + 1792, depth)?;
12771 self.113.encode(encoder, offset + 1808, depth)?;
12772 self.114.encode(encoder, offset + 1824, depth)?;
12773 self.115.encode(encoder, offset + 1840, depth)?;
12774 self.116.encode(encoder, offset + 1856, depth)?;
12775 self.117.encode(encoder, offset + 1872, depth)?;
12776 self.118.encode(encoder, offset + 1888, depth)?;
12777 self.119.encode(encoder, offset + 1904, depth)?;
12778 Ok(())
12779 }
12780 }
12781
12782 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {
12783 #[inline(always)]
12784 fn new_empty() -> Self {
12785 Self {
12786 b_0: fidl::new_empty!(
12787 fidl::encoding::UnboundedVector<bool>,
12788 fidl::encoding::DefaultFuchsiaResourceDialect
12789 ),
12790 i8_0: fidl::new_empty!(
12791 fidl::encoding::UnboundedVector<i8>,
12792 fidl::encoding::DefaultFuchsiaResourceDialect
12793 ),
12794 i16_0: fidl::new_empty!(
12795 fidl::encoding::UnboundedVector<i16>,
12796 fidl::encoding::DefaultFuchsiaResourceDialect
12797 ),
12798 i32_0: fidl::new_empty!(
12799 fidl::encoding::UnboundedVector<i32>,
12800 fidl::encoding::DefaultFuchsiaResourceDialect
12801 ),
12802 i64_0: fidl::new_empty!(
12803 fidl::encoding::UnboundedVector<i64>,
12804 fidl::encoding::DefaultFuchsiaResourceDialect
12805 ),
12806 u8_0: fidl::new_empty!(
12807 fidl::encoding::UnboundedVector<u8>,
12808 fidl::encoding::DefaultFuchsiaResourceDialect
12809 ),
12810 u16_0: fidl::new_empty!(
12811 fidl::encoding::UnboundedVector<u16>,
12812 fidl::encoding::DefaultFuchsiaResourceDialect
12813 ),
12814 u32_0: fidl::new_empty!(
12815 fidl::encoding::UnboundedVector<u32>,
12816 fidl::encoding::DefaultFuchsiaResourceDialect
12817 ),
12818 u64_0: fidl::new_empty!(
12819 fidl::encoding::UnboundedVector<u64>,
12820 fidl::encoding::DefaultFuchsiaResourceDialect
12821 ),
12822 f32_0: fidl::new_empty!(
12823 fidl::encoding::UnboundedVector<f32>,
12824 fidl::encoding::DefaultFuchsiaResourceDialect
12825 ),
12826 f64_0: fidl::new_empty!(
12827 fidl::encoding::UnboundedVector<f64>,
12828 fidl::encoding::DefaultFuchsiaResourceDialect
12829 ),
12830 handle_0: fidl::new_empty!(
12831 fidl::encoding::UnboundedVector<
12832 fidl::encoding::HandleType<
12833 fidl::Handle,
12834 { fidl::ObjectType::NONE.into_raw() },
12835 2147483648,
12836 >,
12837 >,
12838 fidl::encoding::DefaultFuchsiaResourceDialect
12839 ),
12840 b_1: fidl::new_empty!(
12841 fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12842 fidl::encoding::DefaultFuchsiaResourceDialect
12843 ),
12844 i8_1: fidl::new_empty!(
12845 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12846 fidl::encoding::DefaultFuchsiaResourceDialect
12847 ),
12848 i16_1: fidl::new_empty!(
12849 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12850 fidl::encoding::DefaultFuchsiaResourceDialect
12851 ),
12852 i32_1: fidl::new_empty!(
12853 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12854 fidl::encoding::DefaultFuchsiaResourceDialect
12855 ),
12856 i64_1: fidl::new_empty!(
12857 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12858 fidl::encoding::DefaultFuchsiaResourceDialect
12859 ),
12860 u8_1: fidl::new_empty!(
12861 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12862 fidl::encoding::DefaultFuchsiaResourceDialect
12863 ),
12864 u16_1: fidl::new_empty!(
12865 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12866 fidl::encoding::DefaultFuchsiaResourceDialect
12867 ),
12868 u32_1: fidl::new_empty!(
12869 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12870 fidl::encoding::DefaultFuchsiaResourceDialect
12871 ),
12872 u64_1: fidl::new_empty!(
12873 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12874 fidl::encoding::DefaultFuchsiaResourceDialect
12875 ),
12876 f32_1: fidl::new_empty!(
12877 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12878 fidl::encoding::DefaultFuchsiaResourceDialect
12879 ),
12880 f64_1: fidl::new_empty!(
12881 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12882 fidl::encoding::DefaultFuchsiaResourceDialect
12883 ),
12884 handle_1: fidl::new_empty!(
12885 fidl::encoding::UnboundedVector<
12886 fidl::encoding::Vector<
12887 fidl::encoding::HandleType<
12888 fidl::Handle,
12889 { fidl::ObjectType::NONE.into_raw() },
12890 2147483648,
12891 >,
12892 2,
12893 >,
12894 >,
12895 fidl::encoding::DefaultFuchsiaResourceDialect
12896 ),
12897 b_sized_0: fidl::new_empty!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12898 i8_sized_0: fidl::new_empty!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12899 i16_sized_0: fidl::new_empty!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12900 i32_sized_0: fidl::new_empty!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12901 i64_sized_0: fidl::new_empty!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12902 u8_sized_0: fidl::new_empty!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12903 u16_sized_0: fidl::new_empty!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12904 u32_sized_0: fidl::new_empty!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12905 u64_sized_0: fidl::new_empty!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12906 f32_sized_0: fidl::new_empty!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12907 f64_sized_0: fidl::new_empty!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12908 handle_sized_0: fidl::new_empty!(
12909 fidl::encoding::Vector<
12910 fidl::encoding::HandleType<
12911 fidl::Handle,
12912 { fidl::ObjectType::NONE.into_raw() },
12913 2147483648,
12914 >,
12915 1,
12916 >,
12917 fidl::encoding::DefaultFuchsiaResourceDialect
12918 ),
12919 b_sized_1: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12920 i8_sized_1: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12921 i16_sized_1: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12922 i32_sized_1: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12923 i64_sized_1: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12924 u8_sized_1: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12925 u16_sized_1: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12926 u32_sized_1: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12927 u64_sized_1: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12928 f32_sized_1: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12929 f64_sized_1: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12930 handle_sized_1: fidl::new_empty!(
12931 fidl::encoding::Vector<
12932 fidl::encoding::HandleType<
12933 fidl::Handle,
12934 { fidl::ObjectType::NONE.into_raw() },
12935 2147483648,
12936 >,
12937 3,
12938 >,
12939 fidl::encoding::DefaultFuchsiaResourceDialect
12940 ),
12941 b_sized_2: fidl::new_empty!(
12942 fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12943 fidl::encoding::DefaultFuchsiaResourceDialect
12944 ),
12945 i8_sized_2: fidl::new_empty!(
12946 fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12947 fidl::encoding::DefaultFuchsiaResourceDialect
12948 ),
12949 i16_sized_2: fidl::new_empty!(
12950 fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12951 fidl::encoding::DefaultFuchsiaResourceDialect
12952 ),
12953 i32_sized_2: fidl::new_empty!(
12954 fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12955 fidl::encoding::DefaultFuchsiaResourceDialect
12956 ),
12957 i64_sized_2: fidl::new_empty!(
12958 fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12959 fidl::encoding::DefaultFuchsiaResourceDialect
12960 ),
12961 u8_sized_2: fidl::new_empty!(
12962 fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12963 fidl::encoding::DefaultFuchsiaResourceDialect
12964 ),
12965 u16_sized_2: fidl::new_empty!(
12966 fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12967 fidl::encoding::DefaultFuchsiaResourceDialect
12968 ),
12969 u32_sized_2: fidl::new_empty!(
12970 fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12971 fidl::encoding::DefaultFuchsiaResourceDialect
12972 ),
12973 u64_sized_2: fidl::new_empty!(
12974 fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12975 fidl::encoding::DefaultFuchsiaResourceDialect
12976 ),
12977 f32_sized_2: fidl::new_empty!(
12978 fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12979 fidl::encoding::DefaultFuchsiaResourceDialect
12980 ),
12981 f64_sized_2: fidl::new_empty!(
12982 fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12983 fidl::encoding::DefaultFuchsiaResourceDialect
12984 ),
12985 handle_sized_2: fidl::new_empty!(
12986 fidl::encoding::Vector<
12987 fidl::encoding::Vector<
12988 fidl::encoding::HandleType<
12989 fidl::Handle,
12990 { fidl::ObjectType::NONE.into_raw() },
12991 2147483648,
12992 >,
12993 2,
12994 >,
12995 3,
12996 >,
12997 fidl::encoding::DefaultFuchsiaResourceDialect
12998 ),
12999 b_nullable_0: fidl::new_empty!(
13000 fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13001 fidl::encoding::DefaultFuchsiaResourceDialect
13002 ),
13003 i8_nullable_0: fidl::new_empty!(
13004 fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13005 fidl::encoding::DefaultFuchsiaResourceDialect
13006 ),
13007 i16_nullable_0: fidl::new_empty!(
13008 fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13009 fidl::encoding::DefaultFuchsiaResourceDialect
13010 ),
13011 i32_nullable_0: fidl::new_empty!(
13012 fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13013 fidl::encoding::DefaultFuchsiaResourceDialect
13014 ),
13015 i64_nullable_0: fidl::new_empty!(
13016 fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13017 fidl::encoding::DefaultFuchsiaResourceDialect
13018 ),
13019 u8_nullable_0: fidl::new_empty!(
13020 fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13021 fidl::encoding::DefaultFuchsiaResourceDialect
13022 ),
13023 u16_nullable_0: fidl::new_empty!(
13024 fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13025 fidl::encoding::DefaultFuchsiaResourceDialect
13026 ),
13027 u32_nullable_0: fidl::new_empty!(
13028 fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13029 fidl::encoding::DefaultFuchsiaResourceDialect
13030 ),
13031 u64_nullable_0: fidl::new_empty!(
13032 fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13033 fidl::encoding::DefaultFuchsiaResourceDialect
13034 ),
13035 f32_nullable_0: fidl::new_empty!(
13036 fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13037 fidl::encoding::DefaultFuchsiaResourceDialect
13038 ),
13039 f64_nullable_0: fidl::new_empty!(
13040 fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13041 fidl::encoding::DefaultFuchsiaResourceDialect
13042 ),
13043 handle_nullable_0: fidl::new_empty!(
13044 fidl::encoding::Optional<
13045 fidl::encoding::Vector<
13046 fidl::encoding::HandleType<
13047 fidl::Handle,
13048 { fidl::ObjectType::NONE.into_raw() },
13049 2147483648,
13050 >,
13051 1,
13052 >,
13053 >,
13054 fidl::encoding::DefaultFuchsiaResourceDialect
13055 ),
13056 b_nullable_1: fidl::new_empty!(
13057 fidl::encoding::Optional<
13058 fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13059 >,
13060 fidl::encoding::DefaultFuchsiaResourceDialect
13061 ),
13062 i8_nullable_1: fidl::new_empty!(
13063 fidl::encoding::Optional<
13064 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13065 >,
13066 fidl::encoding::DefaultFuchsiaResourceDialect
13067 ),
13068 i16_nullable_1: fidl::new_empty!(
13069 fidl::encoding::Optional<
13070 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13071 >,
13072 fidl::encoding::DefaultFuchsiaResourceDialect
13073 ),
13074 i32_nullable_1: fidl::new_empty!(
13075 fidl::encoding::Optional<
13076 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13077 >,
13078 fidl::encoding::DefaultFuchsiaResourceDialect
13079 ),
13080 i64_nullable_1: fidl::new_empty!(
13081 fidl::encoding::Optional<
13082 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13083 >,
13084 fidl::encoding::DefaultFuchsiaResourceDialect
13085 ),
13086 u8_nullable_1: fidl::new_empty!(
13087 fidl::encoding::Optional<
13088 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13089 >,
13090 fidl::encoding::DefaultFuchsiaResourceDialect
13091 ),
13092 u16_nullable_1: fidl::new_empty!(
13093 fidl::encoding::Optional<
13094 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13095 >,
13096 fidl::encoding::DefaultFuchsiaResourceDialect
13097 ),
13098 u32_nullable_1: fidl::new_empty!(
13099 fidl::encoding::Optional<
13100 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13101 >,
13102 fidl::encoding::DefaultFuchsiaResourceDialect
13103 ),
13104 u64_nullable_1: fidl::new_empty!(
13105 fidl::encoding::Optional<
13106 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13107 >,
13108 fidl::encoding::DefaultFuchsiaResourceDialect
13109 ),
13110 f32_nullable_1: fidl::new_empty!(
13111 fidl::encoding::Optional<
13112 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13113 >,
13114 fidl::encoding::DefaultFuchsiaResourceDialect
13115 ),
13116 f64_nullable_1: fidl::new_empty!(
13117 fidl::encoding::Optional<
13118 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13119 >,
13120 fidl::encoding::DefaultFuchsiaResourceDialect
13121 ),
13122 handle_nullable_1: fidl::new_empty!(
13123 fidl::encoding::Optional<
13124 fidl::encoding::UnboundedVector<
13125 fidl::encoding::Vector<
13126 fidl::encoding::HandleType<
13127 fidl::Handle,
13128 { fidl::ObjectType::NONE.into_raw() },
13129 2147483648,
13130 >,
13131 2,
13132 >,
13133 >,
13134 >,
13135 fidl::encoding::DefaultFuchsiaResourceDialect
13136 ),
13137 b_nullable_sized_0: fidl::new_empty!(
13138 fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13139 fidl::encoding::DefaultFuchsiaResourceDialect
13140 ),
13141 i8_nullable_sized_0: fidl::new_empty!(
13142 fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13143 fidl::encoding::DefaultFuchsiaResourceDialect
13144 ),
13145 i16_nullable_sized_0: fidl::new_empty!(
13146 fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13147 fidl::encoding::DefaultFuchsiaResourceDialect
13148 ),
13149 i32_nullable_sized_0: fidl::new_empty!(
13150 fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13151 fidl::encoding::DefaultFuchsiaResourceDialect
13152 ),
13153 i64_nullable_sized_0: fidl::new_empty!(
13154 fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13155 fidl::encoding::DefaultFuchsiaResourceDialect
13156 ),
13157 u8_nullable_sized_0: fidl::new_empty!(
13158 fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13159 fidl::encoding::DefaultFuchsiaResourceDialect
13160 ),
13161 u16_nullable_sized_0: fidl::new_empty!(
13162 fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13163 fidl::encoding::DefaultFuchsiaResourceDialect
13164 ),
13165 u32_nullable_sized_0: fidl::new_empty!(
13166 fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13167 fidl::encoding::DefaultFuchsiaResourceDialect
13168 ),
13169 u64_nullable_sized_0: fidl::new_empty!(
13170 fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13171 fidl::encoding::DefaultFuchsiaResourceDialect
13172 ),
13173 f32_nullable_sized_0: fidl::new_empty!(
13174 fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13175 fidl::encoding::DefaultFuchsiaResourceDialect
13176 ),
13177 f64_nullable_sized_0: fidl::new_empty!(
13178 fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13179 fidl::encoding::DefaultFuchsiaResourceDialect
13180 ),
13181 handle_nullable_sized_0: fidl::new_empty!(
13182 fidl::encoding::Optional<
13183 fidl::encoding::Vector<
13184 fidl::encoding::HandleType<
13185 fidl::Handle,
13186 { fidl::ObjectType::NONE.into_raw() },
13187 2147483648,
13188 >,
13189 1,
13190 >,
13191 >,
13192 fidl::encoding::DefaultFuchsiaResourceDialect
13193 ),
13194 b_nullable_sized_1: fidl::new_empty!(
13195 fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
13196 fidl::encoding::DefaultFuchsiaResourceDialect
13197 ),
13198 i8_nullable_sized_1: fidl::new_empty!(
13199 fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
13200 fidl::encoding::DefaultFuchsiaResourceDialect
13201 ),
13202 i16_nullable_sized_1: fidl::new_empty!(
13203 fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
13204 fidl::encoding::DefaultFuchsiaResourceDialect
13205 ),
13206 i32_nullable_sized_1: fidl::new_empty!(
13207 fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
13208 fidl::encoding::DefaultFuchsiaResourceDialect
13209 ),
13210 i64_nullable_sized_1: fidl::new_empty!(
13211 fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
13212 fidl::encoding::DefaultFuchsiaResourceDialect
13213 ),
13214 u8_nullable_sized_1: fidl::new_empty!(
13215 fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
13216 fidl::encoding::DefaultFuchsiaResourceDialect
13217 ),
13218 u16_nullable_sized_1: fidl::new_empty!(
13219 fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
13220 fidl::encoding::DefaultFuchsiaResourceDialect
13221 ),
13222 u32_nullable_sized_1: fidl::new_empty!(
13223 fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
13224 fidl::encoding::DefaultFuchsiaResourceDialect
13225 ),
13226 u64_nullable_sized_1: fidl::new_empty!(
13227 fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
13228 fidl::encoding::DefaultFuchsiaResourceDialect
13229 ),
13230 f32_nullable_sized_1: fidl::new_empty!(
13231 fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
13232 fidl::encoding::DefaultFuchsiaResourceDialect
13233 ),
13234 f64_nullable_sized_1: fidl::new_empty!(
13235 fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
13236 fidl::encoding::DefaultFuchsiaResourceDialect
13237 ),
13238 handle_nullable_sized_1: fidl::new_empty!(
13239 fidl::encoding::Optional<
13240 fidl::encoding::Vector<
13241 fidl::encoding::HandleType<
13242 fidl::Handle,
13243 { fidl::ObjectType::NONE.into_raw() },
13244 2147483648,
13245 >,
13246 3,
13247 >,
13248 >,
13249 fidl::encoding::DefaultFuchsiaResourceDialect
13250 ),
13251 b_nullable_sized_2: fidl::new_empty!(
13252 fidl::encoding::Optional<
13253 fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13254 >,
13255 fidl::encoding::DefaultFuchsiaResourceDialect
13256 ),
13257 i8_nullable_sized_2: fidl::new_empty!(
13258 fidl::encoding::Optional<
13259 fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13260 >,
13261 fidl::encoding::DefaultFuchsiaResourceDialect
13262 ),
13263 i16_nullable_sized_2: fidl::new_empty!(
13264 fidl::encoding::Optional<
13265 fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13266 >,
13267 fidl::encoding::DefaultFuchsiaResourceDialect
13268 ),
13269 i32_nullable_sized_2: fidl::new_empty!(
13270 fidl::encoding::Optional<
13271 fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13272 >,
13273 fidl::encoding::DefaultFuchsiaResourceDialect
13274 ),
13275 i64_nullable_sized_2: fidl::new_empty!(
13276 fidl::encoding::Optional<
13277 fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13278 >,
13279 fidl::encoding::DefaultFuchsiaResourceDialect
13280 ),
13281 u8_nullable_sized_2: fidl::new_empty!(
13282 fidl::encoding::Optional<
13283 fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13284 >,
13285 fidl::encoding::DefaultFuchsiaResourceDialect
13286 ),
13287 u16_nullable_sized_2: fidl::new_empty!(
13288 fidl::encoding::Optional<
13289 fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13290 >,
13291 fidl::encoding::DefaultFuchsiaResourceDialect
13292 ),
13293 u32_nullable_sized_2: fidl::new_empty!(
13294 fidl::encoding::Optional<
13295 fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13296 >,
13297 fidl::encoding::DefaultFuchsiaResourceDialect
13298 ),
13299 u64_nullable_sized_2: fidl::new_empty!(
13300 fidl::encoding::Optional<
13301 fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13302 >,
13303 fidl::encoding::DefaultFuchsiaResourceDialect
13304 ),
13305 f32_nullable_sized_2: fidl::new_empty!(
13306 fidl::encoding::Optional<
13307 fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13308 >,
13309 fidl::encoding::DefaultFuchsiaResourceDialect
13310 ),
13311 f64_nullable_sized_2: fidl::new_empty!(
13312 fidl::encoding::Optional<
13313 fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13314 >,
13315 fidl::encoding::DefaultFuchsiaResourceDialect
13316 ),
13317 handle_nullable_sized_2: fidl::new_empty!(
13318 fidl::encoding::Optional<
13319 fidl::encoding::Vector<
13320 fidl::encoding::Vector<
13321 fidl::encoding::HandleType<
13322 fidl::Handle,
13323 { fidl::ObjectType::NONE.into_raw() },
13324 2147483648,
13325 >,
13326 2,
13327 >,
13328 3,
13329 >,
13330 >,
13331 fidl::encoding::DefaultFuchsiaResourceDialect
13332 ),
13333 }
13334 }
13335
13336 #[inline]
13337 unsafe fn decode(
13338 &mut self,
13339 decoder: &mut fidl::encoding::Decoder<
13340 '_,
13341 fidl::encoding::DefaultFuchsiaResourceDialect,
13342 >,
13343 offset: usize,
13344 _depth: fidl::encoding::Depth,
13345 ) -> fidl::Result<()> {
13346 decoder.debug_check_bounds::<Self>(offset);
13347 fidl::decode!(
13349 fidl::encoding::UnboundedVector<bool>,
13350 fidl::encoding::DefaultFuchsiaResourceDialect,
13351 &mut self.b_0,
13352 decoder,
13353 offset + 0,
13354 _depth
13355 )?;
13356 fidl::decode!(
13357 fidl::encoding::UnboundedVector<i8>,
13358 fidl::encoding::DefaultFuchsiaResourceDialect,
13359 &mut self.i8_0,
13360 decoder,
13361 offset + 16,
13362 _depth
13363 )?;
13364 fidl::decode!(
13365 fidl::encoding::UnboundedVector<i16>,
13366 fidl::encoding::DefaultFuchsiaResourceDialect,
13367 &mut self.i16_0,
13368 decoder,
13369 offset + 32,
13370 _depth
13371 )?;
13372 fidl::decode!(
13373 fidl::encoding::UnboundedVector<i32>,
13374 fidl::encoding::DefaultFuchsiaResourceDialect,
13375 &mut self.i32_0,
13376 decoder,
13377 offset + 48,
13378 _depth
13379 )?;
13380 fidl::decode!(
13381 fidl::encoding::UnboundedVector<i64>,
13382 fidl::encoding::DefaultFuchsiaResourceDialect,
13383 &mut self.i64_0,
13384 decoder,
13385 offset + 64,
13386 _depth
13387 )?;
13388 fidl::decode!(
13389 fidl::encoding::UnboundedVector<u8>,
13390 fidl::encoding::DefaultFuchsiaResourceDialect,
13391 &mut self.u8_0,
13392 decoder,
13393 offset + 80,
13394 _depth
13395 )?;
13396 fidl::decode!(
13397 fidl::encoding::UnboundedVector<u16>,
13398 fidl::encoding::DefaultFuchsiaResourceDialect,
13399 &mut self.u16_0,
13400 decoder,
13401 offset + 96,
13402 _depth
13403 )?;
13404 fidl::decode!(
13405 fidl::encoding::UnboundedVector<u32>,
13406 fidl::encoding::DefaultFuchsiaResourceDialect,
13407 &mut self.u32_0,
13408 decoder,
13409 offset + 112,
13410 _depth
13411 )?;
13412 fidl::decode!(
13413 fidl::encoding::UnboundedVector<u64>,
13414 fidl::encoding::DefaultFuchsiaResourceDialect,
13415 &mut self.u64_0,
13416 decoder,
13417 offset + 128,
13418 _depth
13419 )?;
13420 fidl::decode!(
13421 fidl::encoding::UnboundedVector<f32>,
13422 fidl::encoding::DefaultFuchsiaResourceDialect,
13423 &mut self.f32_0,
13424 decoder,
13425 offset + 144,
13426 _depth
13427 )?;
13428 fidl::decode!(
13429 fidl::encoding::UnboundedVector<f64>,
13430 fidl::encoding::DefaultFuchsiaResourceDialect,
13431 &mut self.f64_0,
13432 decoder,
13433 offset + 160,
13434 _depth
13435 )?;
13436 fidl::decode!(
13437 fidl::encoding::UnboundedVector<
13438 fidl::encoding::HandleType<
13439 fidl::Handle,
13440 { fidl::ObjectType::NONE.into_raw() },
13441 2147483648,
13442 >,
13443 >,
13444 fidl::encoding::DefaultFuchsiaResourceDialect,
13445 &mut self.handle_0,
13446 decoder,
13447 offset + 176,
13448 _depth
13449 )?;
13450 fidl::decode!(
13451 fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13452 fidl::encoding::DefaultFuchsiaResourceDialect,
13453 &mut self.b_1,
13454 decoder,
13455 offset + 192,
13456 _depth
13457 )?;
13458 fidl::decode!(
13459 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13460 fidl::encoding::DefaultFuchsiaResourceDialect,
13461 &mut self.i8_1,
13462 decoder,
13463 offset + 208,
13464 _depth
13465 )?;
13466 fidl::decode!(
13467 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13468 fidl::encoding::DefaultFuchsiaResourceDialect,
13469 &mut self.i16_1,
13470 decoder,
13471 offset + 224,
13472 _depth
13473 )?;
13474 fidl::decode!(
13475 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13476 fidl::encoding::DefaultFuchsiaResourceDialect,
13477 &mut self.i32_1,
13478 decoder,
13479 offset + 240,
13480 _depth
13481 )?;
13482 fidl::decode!(
13483 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13484 fidl::encoding::DefaultFuchsiaResourceDialect,
13485 &mut self.i64_1,
13486 decoder,
13487 offset + 256,
13488 _depth
13489 )?;
13490 fidl::decode!(
13491 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13492 fidl::encoding::DefaultFuchsiaResourceDialect,
13493 &mut self.u8_1,
13494 decoder,
13495 offset + 272,
13496 _depth
13497 )?;
13498 fidl::decode!(
13499 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13500 fidl::encoding::DefaultFuchsiaResourceDialect,
13501 &mut self.u16_1,
13502 decoder,
13503 offset + 288,
13504 _depth
13505 )?;
13506 fidl::decode!(
13507 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13508 fidl::encoding::DefaultFuchsiaResourceDialect,
13509 &mut self.u32_1,
13510 decoder,
13511 offset + 304,
13512 _depth
13513 )?;
13514 fidl::decode!(
13515 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13516 fidl::encoding::DefaultFuchsiaResourceDialect,
13517 &mut self.u64_1,
13518 decoder,
13519 offset + 320,
13520 _depth
13521 )?;
13522 fidl::decode!(
13523 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13524 fidl::encoding::DefaultFuchsiaResourceDialect,
13525 &mut self.f32_1,
13526 decoder,
13527 offset + 336,
13528 _depth
13529 )?;
13530 fidl::decode!(
13531 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13532 fidl::encoding::DefaultFuchsiaResourceDialect,
13533 &mut self.f64_1,
13534 decoder,
13535 offset + 352,
13536 _depth
13537 )?;
13538 fidl::decode!(
13539 fidl::encoding::UnboundedVector<
13540 fidl::encoding::Vector<
13541 fidl::encoding::HandleType<
13542 fidl::Handle,
13543 { fidl::ObjectType::NONE.into_raw() },
13544 2147483648,
13545 >,
13546 2,
13547 >,
13548 >,
13549 fidl::encoding::DefaultFuchsiaResourceDialect,
13550 &mut self.handle_1,
13551 decoder,
13552 offset + 368,
13553 _depth
13554 )?;
13555 fidl::decode!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_0, decoder, offset + 384, _depth)?;
13556 fidl::decode!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_0, decoder, offset + 400, _depth)?;
13557 fidl::decode!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_0, decoder, offset + 416, _depth)?;
13558 fidl::decode!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_0, decoder, offset + 432, _depth)?;
13559 fidl::decode!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_0, decoder, offset + 448, _depth)?;
13560 fidl::decode!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_0, decoder, offset + 464, _depth)?;
13561 fidl::decode!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_0, decoder, offset + 480, _depth)?;
13562 fidl::decode!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_0, decoder, offset + 496, _depth)?;
13563 fidl::decode!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_0, decoder, offset + 512, _depth)?;
13564 fidl::decode!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_0, decoder, offset + 528, _depth)?;
13565 fidl::decode!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_0, decoder, offset + 544, _depth)?;
13566 fidl::decode!(
13567 fidl::encoding::Vector<
13568 fidl::encoding::HandleType<
13569 fidl::Handle,
13570 { fidl::ObjectType::NONE.into_raw() },
13571 2147483648,
13572 >,
13573 1,
13574 >,
13575 fidl::encoding::DefaultFuchsiaResourceDialect,
13576 &mut self.handle_sized_0,
13577 decoder,
13578 offset + 560,
13579 _depth
13580 )?;
13581 fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_1, decoder, offset + 576, _depth)?;
13582 fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_1, decoder, offset + 592, _depth)?;
13583 fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_1, decoder, offset + 608, _depth)?;
13584 fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_1, decoder, offset + 624, _depth)?;
13585 fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_1, decoder, offset + 640, _depth)?;
13586 fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_1, decoder, offset + 656, _depth)?;
13587 fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_1, decoder, offset + 672, _depth)?;
13588 fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_1, decoder, offset + 688, _depth)?;
13589 fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_1, decoder, offset + 704, _depth)?;
13590 fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_1, decoder, offset + 720, _depth)?;
13591 fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_1, decoder, offset + 736, _depth)?;
13592 fidl::decode!(
13593 fidl::encoding::Vector<
13594 fidl::encoding::HandleType<
13595 fidl::Handle,
13596 { fidl::ObjectType::NONE.into_raw() },
13597 2147483648,
13598 >,
13599 3,
13600 >,
13601 fidl::encoding::DefaultFuchsiaResourceDialect,
13602 &mut self.handle_sized_1,
13603 decoder,
13604 offset + 752,
13605 _depth
13606 )?;
13607 fidl::decode!(
13608 fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13609 fidl::encoding::DefaultFuchsiaResourceDialect,
13610 &mut self.b_sized_2,
13611 decoder,
13612 offset + 768,
13613 _depth
13614 )?;
13615 fidl::decode!(
13616 fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13617 fidl::encoding::DefaultFuchsiaResourceDialect,
13618 &mut self.i8_sized_2,
13619 decoder,
13620 offset + 784,
13621 _depth
13622 )?;
13623 fidl::decode!(
13624 fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13625 fidl::encoding::DefaultFuchsiaResourceDialect,
13626 &mut self.i16_sized_2,
13627 decoder,
13628 offset + 800,
13629 _depth
13630 )?;
13631 fidl::decode!(
13632 fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13633 fidl::encoding::DefaultFuchsiaResourceDialect,
13634 &mut self.i32_sized_2,
13635 decoder,
13636 offset + 816,
13637 _depth
13638 )?;
13639 fidl::decode!(
13640 fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13641 fidl::encoding::DefaultFuchsiaResourceDialect,
13642 &mut self.i64_sized_2,
13643 decoder,
13644 offset + 832,
13645 _depth
13646 )?;
13647 fidl::decode!(
13648 fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13649 fidl::encoding::DefaultFuchsiaResourceDialect,
13650 &mut self.u8_sized_2,
13651 decoder,
13652 offset + 848,
13653 _depth
13654 )?;
13655 fidl::decode!(
13656 fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13657 fidl::encoding::DefaultFuchsiaResourceDialect,
13658 &mut self.u16_sized_2,
13659 decoder,
13660 offset + 864,
13661 _depth
13662 )?;
13663 fidl::decode!(
13664 fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13665 fidl::encoding::DefaultFuchsiaResourceDialect,
13666 &mut self.u32_sized_2,
13667 decoder,
13668 offset + 880,
13669 _depth
13670 )?;
13671 fidl::decode!(
13672 fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13673 fidl::encoding::DefaultFuchsiaResourceDialect,
13674 &mut self.u64_sized_2,
13675 decoder,
13676 offset + 896,
13677 _depth
13678 )?;
13679 fidl::decode!(
13680 fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13681 fidl::encoding::DefaultFuchsiaResourceDialect,
13682 &mut self.f32_sized_2,
13683 decoder,
13684 offset + 912,
13685 _depth
13686 )?;
13687 fidl::decode!(
13688 fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13689 fidl::encoding::DefaultFuchsiaResourceDialect,
13690 &mut self.f64_sized_2,
13691 decoder,
13692 offset + 928,
13693 _depth
13694 )?;
13695 fidl::decode!(
13696 fidl::encoding::Vector<
13697 fidl::encoding::Vector<
13698 fidl::encoding::HandleType<
13699 fidl::Handle,
13700 { fidl::ObjectType::NONE.into_raw() },
13701 2147483648,
13702 >,
13703 2,
13704 >,
13705 3,
13706 >,
13707 fidl::encoding::DefaultFuchsiaResourceDialect,
13708 &mut self.handle_sized_2,
13709 decoder,
13710 offset + 944,
13711 _depth
13712 )?;
13713 fidl::decode!(
13714 fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13715 fidl::encoding::DefaultFuchsiaResourceDialect,
13716 &mut self.b_nullable_0,
13717 decoder,
13718 offset + 960,
13719 _depth
13720 )?;
13721 fidl::decode!(
13722 fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13723 fidl::encoding::DefaultFuchsiaResourceDialect,
13724 &mut self.i8_nullable_0,
13725 decoder,
13726 offset + 976,
13727 _depth
13728 )?;
13729 fidl::decode!(
13730 fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13731 fidl::encoding::DefaultFuchsiaResourceDialect,
13732 &mut self.i16_nullable_0,
13733 decoder,
13734 offset + 992,
13735 _depth
13736 )?;
13737 fidl::decode!(
13738 fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13739 fidl::encoding::DefaultFuchsiaResourceDialect,
13740 &mut self.i32_nullable_0,
13741 decoder,
13742 offset + 1008,
13743 _depth
13744 )?;
13745 fidl::decode!(
13746 fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13747 fidl::encoding::DefaultFuchsiaResourceDialect,
13748 &mut self.i64_nullable_0,
13749 decoder,
13750 offset + 1024,
13751 _depth
13752 )?;
13753 fidl::decode!(
13754 fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13755 fidl::encoding::DefaultFuchsiaResourceDialect,
13756 &mut self.u8_nullable_0,
13757 decoder,
13758 offset + 1040,
13759 _depth
13760 )?;
13761 fidl::decode!(
13762 fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13763 fidl::encoding::DefaultFuchsiaResourceDialect,
13764 &mut self.u16_nullable_0,
13765 decoder,
13766 offset + 1056,
13767 _depth
13768 )?;
13769 fidl::decode!(
13770 fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13771 fidl::encoding::DefaultFuchsiaResourceDialect,
13772 &mut self.u32_nullable_0,
13773 decoder,
13774 offset + 1072,
13775 _depth
13776 )?;
13777 fidl::decode!(
13778 fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13779 fidl::encoding::DefaultFuchsiaResourceDialect,
13780 &mut self.u64_nullable_0,
13781 decoder,
13782 offset + 1088,
13783 _depth
13784 )?;
13785 fidl::decode!(
13786 fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13787 fidl::encoding::DefaultFuchsiaResourceDialect,
13788 &mut self.f32_nullable_0,
13789 decoder,
13790 offset + 1104,
13791 _depth
13792 )?;
13793 fidl::decode!(
13794 fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13795 fidl::encoding::DefaultFuchsiaResourceDialect,
13796 &mut self.f64_nullable_0,
13797 decoder,
13798 offset + 1120,
13799 _depth
13800 )?;
13801 fidl::decode!(
13802 fidl::encoding::Optional<
13803 fidl::encoding::Vector<
13804 fidl::encoding::HandleType<
13805 fidl::Handle,
13806 { fidl::ObjectType::NONE.into_raw() },
13807 2147483648,
13808 >,
13809 1,
13810 >,
13811 >,
13812 fidl::encoding::DefaultFuchsiaResourceDialect,
13813 &mut self.handle_nullable_0,
13814 decoder,
13815 offset + 1136,
13816 _depth
13817 )?;
13818 fidl::decode!(
13819 fidl::encoding::Optional<
13820 fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13821 >,
13822 fidl::encoding::DefaultFuchsiaResourceDialect,
13823 &mut self.b_nullable_1,
13824 decoder,
13825 offset + 1152,
13826 _depth
13827 )?;
13828 fidl::decode!(
13829 fidl::encoding::Optional<
13830 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13831 >,
13832 fidl::encoding::DefaultFuchsiaResourceDialect,
13833 &mut self.i8_nullable_1,
13834 decoder,
13835 offset + 1168,
13836 _depth
13837 )?;
13838 fidl::decode!(
13839 fidl::encoding::Optional<
13840 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13841 >,
13842 fidl::encoding::DefaultFuchsiaResourceDialect,
13843 &mut self.i16_nullable_1,
13844 decoder,
13845 offset + 1184,
13846 _depth
13847 )?;
13848 fidl::decode!(
13849 fidl::encoding::Optional<
13850 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13851 >,
13852 fidl::encoding::DefaultFuchsiaResourceDialect,
13853 &mut self.i32_nullable_1,
13854 decoder,
13855 offset + 1200,
13856 _depth
13857 )?;
13858 fidl::decode!(
13859 fidl::encoding::Optional<
13860 fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13861 >,
13862 fidl::encoding::DefaultFuchsiaResourceDialect,
13863 &mut self.i64_nullable_1,
13864 decoder,
13865 offset + 1216,
13866 _depth
13867 )?;
13868 fidl::decode!(
13869 fidl::encoding::Optional<
13870 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13871 >,
13872 fidl::encoding::DefaultFuchsiaResourceDialect,
13873 &mut self.u8_nullable_1,
13874 decoder,
13875 offset + 1232,
13876 _depth
13877 )?;
13878 fidl::decode!(
13879 fidl::encoding::Optional<
13880 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13881 >,
13882 fidl::encoding::DefaultFuchsiaResourceDialect,
13883 &mut self.u16_nullable_1,
13884 decoder,
13885 offset + 1248,
13886 _depth
13887 )?;
13888 fidl::decode!(
13889 fidl::encoding::Optional<
13890 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13891 >,
13892 fidl::encoding::DefaultFuchsiaResourceDialect,
13893 &mut self.u32_nullable_1,
13894 decoder,
13895 offset + 1264,
13896 _depth
13897 )?;
13898 fidl::decode!(
13899 fidl::encoding::Optional<
13900 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13901 >,
13902 fidl::encoding::DefaultFuchsiaResourceDialect,
13903 &mut self.u64_nullable_1,
13904 decoder,
13905 offset + 1280,
13906 _depth
13907 )?;
13908 fidl::decode!(
13909 fidl::encoding::Optional<
13910 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13911 >,
13912 fidl::encoding::DefaultFuchsiaResourceDialect,
13913 &mut self.f32_nullable_1,
13914 decoder,
13915 offset + 1296,
13916 _depth
13917 )?;
13918 fidl::decode!(
13919 fidl::encoding::Optional<
13920 fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13921 >,
13922 fidl::encoding::DefaultFuchsiaResourceDialect,
13923 &mut self.f64_nullable_1,
13924 decoder,
13925 offset + 1312,
13926 _depth
13927 )?;
13928 fidl::decode!(
13929 fidl::encoding::Optional<
13930 fidl::encoding::UnboundedVector<
13931 fidl::encoding::Vector<
13932 fidl::encoding::HandleType<
13933 fidl::Handle,
13934 { fidl::ObjectType::NONE.into_raw() },
13935 2147483648,
13936 >,
13937 2,
13938 >,
13939 >,
13940 >,
13941 fidl::encoding::DefaultFuchsiaResourceDialect,
13942 &mut self.handle_nullable_1,
13943 decoder,
13944 offset + 1328,
13945 _depth
13946 )?;
13947 fidl::decode!(
13948 fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13949 fidl::encoding::DefaultFuchsiaResourceDialect,
13950 &mut self.b_nullable_sized_0,
13951 decoder,
13952 offset + 1344,
13953 _depth
13954 )?;
13955 fidl::decode!(
13956 fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13957 fidl::encoding::DefaultFuchsiaResourceDialect,
13958 &mut self.i8_nullable_sized_0,
13959 decoder,
13960 offset + 1360,
13961 _depth
13962 )?;
13963 fidl::decode!(
13964 fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13965 fidl::encoding::DefaultFuchsiaResourceDialect,
13966 &mut self.i16_nullable_sized_0,
13967 decoder,
13968 offset + 1376,
13969 _depth
13970 )?;
13971 fidl::decode!(
13972 fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13973 fidl::encoding::DefaultFuchsiaResourceDialect,
13974 &mut self.i32_nullable_sized_0,
13975 decoder,
13976 offset + 1392,
13977 _depth
13978 )?;
13979 fidl::decode!(
13980 fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13981 fidl::encoding::DefaultFuchsiaResourceDialect,
13982 &mut self.i64_nullable_sized_0,
13983 decoder,
13984 offset + 1408,
13985 _depth
13986 )?;
13987 fidl::decode!(
13988 fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13989 fidl::encoding::DefaultFuchsiaResourceDialect,
13990 &mut self.u8_nullable_sized_0,
13991 decoder,
13992 offset + 1424,
13993 _depth
13994 )?;
13995 fidl::decode!(
13996 fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13997 fidl::encoding::DefaultFuchsiaResourceDialect,
13998 &mut self.u16_nullable_sized_0,
13999 decoder,
14000 offset + 1440,
14001 _depth
14002 )?;
14003 fidl::decode!(
14004 fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
14005 fidl::encoding::DefaultFuchsiaResourceDialect,
14006 &mut self.u32_nullable_sized_0,
14007 decoder,
14008 offset + 1456,
14009 _depth
14010 )?;
14011 fidl::decode!(
14012 fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
14013 fidl::encoding::DefaultFuchsiaResourceDialect,
14014 &mut self.u64_nullable_sized_0,
14015 decoder,
14016 offset + 1472,
14017 _depth
14018 )?;
14019 fidl::decode!(
14020 fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
14021 fidl::encoding::DefaultFuchsiaResourceDialect,
14022 &mut self.f32_nullable_sized_0,
14023 decoder,
14024 offset + 1488,
14025 _depth
14026 )?;
14027 fidl::decode!(
14028 fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
14029 fidl::encoding::DefaultFuchsiaResourceDialect,
14030 &mut self.f64_nullable_sized_0,
14031 decoder,
14032 offset + 1504,
14033 _depth
14034 )?;
14035 fidl::decode!(
14036 fidl::encoding::Optional<
14037 fidl::encoding::Vector<
14038 fidl::encoding::HandleType<
14039 fidl::Handle,
14040 { fidl::ObjectType::NONE.into_raw() },
14041 2147483648,
14042 >,
14043 1,
14044 >,
14045 >,
14046 fidl::encoding::DefaultFuchsiaResourceDialect,
14047 &mut self.handle_nullable_sized_0,
14048 decoder,
14049 offset + 1520,
14050 _depth
14051 )?;
14052 fidl::decode!(
14053 fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
14054 fidl::encoding::DefaultFuchsiaResourceDialect,
14055 &mut self.b_nullable_sized_1,
14056 decoder,
14057 offset + 1536,
14058 _depth
14059 )?;
14060 fidl::decode!(
14061 fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
14062 fidl::encoding::DefaultFuchsiaResourceDialect,
14063 &mut self.i8_nullable_sized_1,
14064 decoder,
14065 offset + 1552,
14066 _depth
14067 )?;
14068 fidl::decode!(
14069 fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
14070 fidl::encoding::DefaultFuchsiaResourceDialect,
14071 &mut self.i16_nullable_sized_1,
14072 decoder,
14073 offset + 1568,
14074 _depth
14075 )?;
14076 fidl::decode!(
14077 fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
14078 fidl::encoding::DefaultFuchsiaResourceDialect,
14079 &mut self.i32_nullable_sized_1,
14080 decoder,
14081 offset + 1584,
14082 _depth
14083 )?;
14084 fidl::decode!(
14085 fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
14086 fidl::encoding::DefaultFuchsiaResourceDialect,
14087 &mut self.i64_nullable_sized_1,
14088 decoder,
14089 offset + 1600,
14090 _depth
14091 )?;
14092 fidl::decode!(
14093 fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
14094 fidl::encoding::DefaultFuchsiaResourceDialect,
14095 &mut self.u8_nullable_sized_1,
14096 decoder,
14097 offset + 1616,
14098 _depth
14099 )?;
14100 fidl::decode!(
14101 fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
14102 fidl::encoding::DefaultFuchsiaResourceDialect,
14103 &mut self.u16_nullable_sized_1,
14104 decoder,
14105 offset + 1632,
14106 _depth
14107 )?;
14108 fidl::decode!(
14109 fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
14110 fidl::encoding::DefaultFuchsiaResourceDialect,
14111 &mut self.u32_nullable_sized_1,
14112 decoder,
14113 offset + 1648,
14114 _depth
14115 )?;
14116 fidl::decode!(
14117 fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
14118 fidl::encoding::DefaultFuchsiaResourceDialect,
14119 &mut self.u64_nullable_sized_1,
14120 decoder,
14121 offset + 1664,
14122 _depth
14123 )?;
14124 fidl::decode!(
14125 fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
14126 fidl::encoding::DefaultFuchsiaResourceDialect,
14127 &mut self.f32_nullable_sized_1,
14128 decoder,
14129 offset + 1680,
14130 _depth
14131 )?;
14132 fidl::decode!(
14133 fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
14134 fidl::encoding::DefaultFuchsiaResourceDialect,
14135 &mut self.f64_nullable_sized_1,
14136 decoder,
14137 offset + 1696,
14138 _depth
14139 )?;
14140 fidl::decode!(
14141 fidl::encoding::Optional<
14142 fidl::encoding::Vector<
14143 fidl::encoding::HandleType<
14144 fidl::Handle,
14145 { fidl::ObjectType::NONE.into_raw() },
14146 2147483648,
14147 >,
14148 3,
14149 >,
14150 >,
14151 fidl::encoding::DefaultFuchsiaResourceDialect,
14152 &mut self.handle_nullable_sized_1,
14153 decoder,
14154 offset + 1712,
14155 _depth
14156 )?;
14157 fidl::decode!(
14158 fidl::encoding::Optional<
14159 fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
14160 >,
14161 fidl::encoding::DefaultFuchsiaResourceDialect,
14162 &mut self.b_nullable_sized_2,
14163 decoder,
14164 offset + 1728,
14165 _depth
14166 )?;
14167 fidl::decode!(
14168 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
14169 fidl::encoding::DefaultFuchsiaResourceDialect,
14170 &mut self.i8_nullable_sized_2,
14171 decoder,
14172 offset + 1744,
14173 _depth
14174 )?;
14175 fidl::decode!(
14176 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
14177 fidl::encoding::DefaultFuchsiaResourceDialect,
14178 &mut self.i16_nullable_sized_2,
14179 decoder,
14180 offset + 1760,
14181 _depth
14182 )?;
14183 fidl::decode!(
14184 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
14185 fidl::encoding::DefaultFuchsiaResourceDialect,
14186 &mut self.i32_nullable_sized_2,
14187 decoder,
14188 offset + 1776,
14189 _depth
14190 )?;
14191 fidl::decode!(
14192 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
14193 fidl::encoding::DefaultFuchsiaResourceDialect,
14194 &mut self.i64_nullable_sized_2,
14195 decoder,
14196 offset + 1792,
14197 _depth
14198 )?;
14199 fidl::decode!(
14200 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
14201 fidl::encoding::DefaultFuchsiaResourceDialect,
14202 &mut self.u8_nullable_sized_2,
14203 decoder,
14204 offset + 1808,
14205 _depth
14206 )?;
14207 fidl::decode!(
14208 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
14209 fidl::encoding::DefaultFuchsiaResourceDialect,
14210 &mut self.u16_nullable_sized_2,
14211 decoder,
14212 offset + 1824,
14213 _depth
14214 )?;
14215 fidl::decode!(
14216 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
14217 fidl::encoding::DefaultFuchsiaResourceDialect,
14218 &mut self.u32_nullable_sized_2,
14219 decoder,
14220 offset + 1840,
14221 _depth
14222 )?;
14223 fidl::decode!(
14224 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
14225 fidl::encoding::DefaultFuchsiaResourceDialect,
14226 &mut self.u64_nullable_sized_2,
14227 decoder,
14228 offset + 1856,
14229 _depth
14230 )?;
14231 fidl::decode!(
14232 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
14233 fidl::encoding::DefaultFuchsiaResourceDialect,
14234 &mut self.f32_nullable_sized_2,
14235 decoder,
14236 offset + 1872,
14237 _depth
14238 )?;
14239 fidl::decode!(
14240 fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
14241 fidl::encoding::DefaultFuchsiaResourceDialect,
14242 &mut self.f64_nullable_sized_2,
14243 decoder,
14244 offset + 1888,
14245 _depth
14246 )?;
14247 fidl::decode!(
14248 fidl::encoding::Optional<
14249 fidl::encoding::Vector<
14250 fidl::encoding::Vector<
14251 fidl::encoding::HandleType<
14252 fidl::Handle,
14253 { fidl::ObjectType::NONE.into_raw() },
14254 2147483648,
14255 >,
14256 2,
14257 >,
14258 3,
14259 >,
14260 >,
14261 fidl::encoding::DefaultFuchsiaResourceDialect,
14262 &mut self.handle_nullable_sized_2,
14263 decoder,
14264 offset + 1904,
14265 _depth
14266 )?;
14267 Ok(())
14268 }
14269 }
14270
14271 impl AllTypesTable {
14272 #[inline(always)]
14273 fn max_ordinal_present(&self) -> u64 {
14274 if let Some(_) = self.xunion_member {
14275 return 21;
14276 }
14277 if let Some(_) = self.table_member {
14278 return 20;
14279 }
14280 if let Some(_) = self.vector_member {
14281 return 19;
14282 }
14283 if let Some(_) = self.array_member {
14284 return 18;
14285 }
14286 if let Some(_) = self.union_member {
14287 return 17;
14288 }
14289 if let Some(_) = self.struct_member {
14290 return 16;
14291 }
14292 if let Some(_) = self.string_member {
14293 return 15;
14294 }
14295 if let Some(_) = self.handle_member {
14296 return 14;
14297 }
14298 if let Some(_) = self.bits_member {
14299 return 13;
14300 }
14301 if let Some(_) = self.enum_member {
14302 return 12;
14303 }
14304 if let Some(_) = self.float64_member {
14305 return 11;
14306 }
14307 if let Some(_) = self.float32_member {
14308 return 10;
14309 }
14310 if let Some(_) = self.uint64_member {
14311 return 9;
14312 }
14313 if let Some(_) = self.uint32_member {
14314 return 8;
14315 }
14316 if let Some(_) = self.uint16_member {
14317 return 7;
14318 }
14319 if let Some(_) = self.uint8_member {
14320 return 6;
14321 }
14322 if let Some(_) = self.int64_member {
14323 return 5;
14324 }
14325 if let Some(_) = self.int32_member {
14326 return 4;
14327 }
14328 if let Some(_) = self.int16_member {
14329 return 3;
14330 }
14331 if let Some(_) = self.int8_member {
14332 return 2;
14333 }
14334 if let Some(_) = self.bool_member {
14335 return 1;
14336 }
14337 0
14338 }
14339 }
14340
14341 impl fidl::encoding::ResourceTypeMarker for AllTypesTable {
14342 type Borrowed<'a> = &'a mut Self;
14343 fn take_or_borrow<'a>(
14344 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
14345 ) -> Self::Borrowed<'a> {
14346 value
14347 }
14348 }
14349
14350 unsafe impl fidl::encoding::TypeMarker for AllTypesTable {
14351 type Owned = Self;
14352
14353 #[inline(always)]
14354 fn inline_align(_context: fidl::encoding::Context) -> usize {
14355 8
14356 }
14357
14358 #[inline(always)]
14359 fn inline_size(_context: fidl::encoding::Context) -> usize {
14360 16
14361 }
14362 }
14363
14364 unsafe impl fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
14365 for &mut AllTypesTable
14366 {
14367 unsafe fn encode(
14368 self,
14369 encoder: &mut fidl::encoding::Encoder<
14370 '_,
14371 fidl::encoding::DefaultFuchsiaResourceDialect,
14372 >,
14373 offset: usize,
14374 mut depth: fidl::encoding::Depth,
14375 ) -> fidl::Result<()> {
14376 encoder.debug_check_bounds::<AllTypesTable>(offset);
14377 let max_ordinal: u64 = self.max_ordinal_present();
14379 encoder.write_num(max_ordinal, offset);
14380 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14381 if max_ordinal == 0 {
14383 return Ok(());
14384 }
14385 depth.increment()?;
14386 let envelope_size = 8;
14387 let bytes_len = max_ordinal as usize * envelope_size;
14388 #[allow(unused_variables)]
14389 let offset = encoder.out_of_line_offset(bytes_len);
14390 let mut _prev_end_offset: usize = 0;
14391 if 1 > max_ordinal {
14392 return Ok(());
14393 }
14394
14395 let cur_offset: usize = (1 - 1) * envelope_size;
14398
14399 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14401
14402 fidl::encoding::encode_in_envelope_optional::<
14407 bool,
14408 fidl::encoding::DefaultFuchsiaResourceDialect,
14409 >(
14410 self.bool_member.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
14411 encoder,
14412 offset + cur_offset,
14413 depth,
14414 )?;
14415
14416 _prev_end_offset = cur_offset + envelope_size;
14417 if 2 > max_ordinal {
14418 return Ok(());
14419 }
14420
14421 let cur_offset: usize = (2 - 1) * envelope_size;
14424
14425 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14427
14428 fidl::encoding::encode_in_envelope_optional::<
14433 i8,
14434 fidl::encoding::DefaultFuchsiaResourceDialect,
14435 >(
14436 self.int8_member.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
14437 encoder,
14438 offset + cur_offset,
14439 depth,
14440 )?;
14441
14442 _prev_end_offset = cur_offset + envelope_size;
14443 if 3 > max_ordinal {
14444 return Ok(());
14445 }
14446
14447 let cur_offset: usize = (3 - 1) * envelope_size;
14450
14451 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14453
14454 fidl::encoding::encode_in_envelope_optional::<
14459 i16,
14460 fidl::encoding::DefaultFuchsiaResourceDialect,
14461 >(
14462 self.int16_member.as_ref().map(<i16 as fidl::encoding::ValueTypeMarker>::borrow),
14463 encoder,
14464 offset + cur_offset,
14465 depth,
14466 )?;
14467
14468 _prev_end_offset = cur_offset + envelope_size;
14469 if 4 > max_ordinal {
14470 return Ok(());
14471 }
14472
14473 let cur_offset: usize = (4 - 1) * envelope_size;
14476
14477 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14479
14480 fidl::encoding::encode_in_envelope_optional::<
14485 i32,
14486 fidl::encoding::DefaultFuchsiaResourceDialect,
14487 >(
14488 self.int32_member.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
14489 encoder,
14490 offset + cur_offset,
14491 depth,
14492 )?;
14493
14494 _prev_end_offset = cur_offset + envelope_size;
14495 if 5 > max_ordinal {
14496 return Ok(());
14497 }
14498
14499 let cur_offset: usize = (5 - 1) * envelope_size;
14502
14503 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14505
14506 fidl::encoding::encode_in_envelope_optional::<
14511 i64,
14512 fidl::encoding::DefaultFuchsiaResourceDialect,
14513 >(
14514 self.int64_member.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
14515 encoder,
14516 offset + cur_offset,
14517 depth,
14518 )?;
14519
14520 _prev_end_offset = cur_offset + envelope_size;
14521 if 6 > max_ordinal {
14522 return Ok(());
14523 }
14524
14525 let cur_offset: usize = (6 - 1) * envelope_size;
14528
14529 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14531
14532 fidl::encoding::encode_in_envelope_optional::<
14537 u8,
14538 fidl::encoding::DefaultFuchsiaResourceDialect,
14539 >(
14540 self.uint8_member.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
14541 encoder,
14542 offset + cur_offset,
14543 depth,
14544 )?;
14545
14546 _prev_end_offset = cur_offset + envelope_size;
14547 if 7 > max_ordinal {
14548 return Ok(());
14549 }
14550
14551 let cur_offset: usize = (7 - 1) * envelope_size;
14554
14555 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14557
14558 fidl::encoding::encode_in_envelope_optional::<
14563 u16,
14564 fidl::encoding::DefaultFuchsiaResourceDialect,
14565 >(
14566 self.uint16_member.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
14567 encoder,
14568 offset + cur_offset,
14569 depth,
14570 )?;
14571
14572 _prev_end_offset = cur_offset + envelope_size;
14573 if 8 > max_ordinal {
14574 return Ok(());
14575 }
14576
14577 let cur_offset: usize = (8 - 1) * envelope_size;
14580
14581 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14583
14584 fidl::encoding::encode_in_envelope_optional::<
14589 u32,
14590 fidl::encoding::DefaultFuchsiaResourceDialect,
14591 >(
14592 self.uint32_member.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
14593 encoder,
14594 offset + cur_offset,
14595 depth,
14596 )?;
14597
14598 _prev_end_offset = cur_offset + envelope_size;
14599 if 9 > max_ordinal {
14600 return Ok(());
14601 }
14602
14603 let cur_offset: usize = (9 - 1) * envelope_size;
14606
14607 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14609
14610 fidl::encoding::encode_in_envelope_optional::<
14615 u64,
14616 fidl::encoding::DefaultFuchsiaResourceDialect,
14617 >(
14618 self.uint64_member.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14619 encoder,
14620 offset + cur_offset,
14621 depth,
14622 )?;
14623
14624 _prev_end_offset = cur_offset + envelope_size;
14625 if 10 > max_ordinal {
14626 return Ok(());
14627 }
14628
14629 let cur_offset: usize = (10 - 1) * envelope_size;
14632
14633 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14635
14636 fidl::encoding::encode_in_envelope_optional::<
14641 f32,
14642 fidl::encoding::DefaultFuchsiaResourceDialect,
14643 >(
14644 self.float32_member.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
14645 encoder,
14646 offset + cur_offset,
14647 depth,
14648 )?;
14649
14650 _prev_end_offset = cur_offset + envelope_size;
14651 if 11 > max_ordinal {
14652 return Ok(());
14653 }
14654
14655 let cur_offset: usize = (11 - 1) * envelope_size;
14658
14659 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14661
14662 fidl::encoding::encode_in_envelope_optional::<
14667 f64,
14668 fidl::encoding::DefaultFuchsiaResourceDialect,
14669 >(
14670 self.float64_member.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
14671 encoder,
14672 offset + cur_offset,
14673 depth,
14674 )?;
14675
14676 _prev_end_offset = cur_offset + envelope_size;
14677 if 12 > max_ordinal {
14678 return Ok(());
14679 }
14680
14681 let cur_offset: usize = (12 - 1) * envelope_size;
14684
14685 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14687
14688 fidl::encoding::encode_in_envelope_optional::<
14693 DefaultEnum,
14694 fidl::encoding::DefaultFuchsiaResourceDialect,
14695 >(
14696 self.enum_member
14697 .as_ref()
14698 .map(<DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow),
14699 encoder,
14700 offset + cur_offset,
14701 depth,
14702 )?;
14703
14704 _prev_end_offset = cur_offset + envelope_size;
14705 if 13 > max_ordinal {
14706 return Ok(());
14707 }
14708
14709 let cur_offset: usize = (13 - 1) * envelope_size;
14712
14713 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14715
14716 fidl::encoding::encode_in_envelope_optional::<
14721 DefaultBits,
14722 fidl::encoding::DefaultFuchsiaResourceDialect,
14723 >(
14724 self.bits_member
14725 .as_ref()
14726 .map(<DefaultBits as fidl::encoding::ValueTypeMarker>::borrow),
14727 encoder,
14728 offset + cur_offset,
14729 depth,
14730 )?;
14731
14732 _prev_end_offset = cur_offset + envelope_size;
14733 if 14 > max_ordinal {
14734 return Ok(());
14735 }
14736
14737 let cur_offset: usize = (14 - 1) * envelope_size;
14740
14741 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14743
14744 fidl::encoding::encode_in_envelope_optional::<
14749 fidl::encoding::HandleType<
14750 fidl::Handle,
14751 { fidl::ObjectType::NONE.into_raw() },
14752 2147483648,
14753 >,
14754 fidl::encoding::DefaultFuchsiaResourceDialect,
14755 >(
14756 self.handle_member.as_mut().map(
14757 <fidl::encoding::HandleType<
14758 fidl::Handle,
14759 { fidl::ObjectType::NONE.into_raw() },
14760 2147483648,
14761 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
14762 ),
14763 encoder,
14764 offset + cur_offset,
14765 depth,
14766 )?;
14767
14768 _prev_end_offset = cur_offset + envelope_size;
14769 if 15 > max_ordinal {
14770 return Ok(());
14771 }
14772
14773 let cur_offset: usize = (15 - 1) * envelope_size;
14776
14777 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14779
14780 fidl::encoding::encode_in_envelope_optional::<
14785 fidl::encoding::UnboundedString,
14786 fidl::encoding::DefaultFuchsiaResourceDialect,
14787 >(
14788 self.string_member.as_ref().map(
14789 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
14790 ),
14791 encoder,
14792 offset + cur_offset,
14793 depth,
14794 )?;
14795
14796 _prev_end_offset = cur_offset + envelope_size;
14797 if 16 > max_ordinal {
14798 return Ok(());
14799 }
14800
14801 let cur_offset: usize = (16 - 1) * envelope_size;
14804
14805 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14807
14808 fidl::encoding::encode_in_envelope_optional::<
14813 ThisIsAStruct,
14814 fidl::encoding::DefaultFuchsiaResourceDialect,
14815 >(
14816 self.struct_member
14817 .as_ref()
14818 .map(<ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow),
14819 encoder,
14820 offset + cur_offset,
14821 depth,
14822 )?;
14823
14824 _prev_end_offset = cur_offset + envelope_size;
14825 if 17 > max_ordinal {
14826 return Ok(());
14827 }
14828
14829 let cur_offset: usize = (17 - 1) * envelope_size;
14832
14833 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14835
14836 fidl::encoding::encode_in_envelope_optional::<
14841 ThisIsAUnion,
14842 fidl::encoding::DefaultFuchsiaResourceDialect,
14843 >(
14844 self.union_member
14845 .as_ref()
14846 .map(<ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow),
14847 encoder,
14848 offset + cur_offset,
14849 depth,
14850 )?;
14851
14852 _prev_end_offset = cur_offset + envelope_size;
14853 if 18 > max_ordinal {
14854 return Ok(());
14855 }
14856
14857 let cur_offset: usize = (18 - 1) * envelope_size;
14860
14861 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14863
14864 fidl::encoding::encode_in_envelope_optional::<
14869 fidl::encoding::Array<u32, 3>,
14870 fidl::encoding::DefaultFuchsiaResourceDialect,
14871 >(
14872 self.array_member.as_ref().map(
14873 <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
14874 ),
14875 encoder,
14876 offset + cur_offset,
14877 depth,
14878 )?;
14879
14880 _prev_end_offset = cur_offset + envelope_size;
14881 if 19 > max_ordinal {
14882 return Ok(());
14883 }
14884
14885 let cur_offset: usize = (19 - 1) * envelope_size;
14888
14889 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14891
14892 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
14897 self.vector_member.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
14898 encoder, offset + cur_offset, depth
14899 )?;
14900
14901 _prev_end_offset = cur_offset + envelope_size;
14902 if 20 > max_ordinal {
14903 return Ok(());
14904 }
14905
14906 let cur_offset: usize = (20 - 1) * envelope_size;
14909
14910 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14912
14913 fidl::encoding::encode_in_envelope_optional::<
14918 ThisIsATable,
14919 fidl::encoding::DefaultFuchsiaResourceDialect,
14920 >(
14921 self.table_member
14922 .as_ref()
14923 .map(<ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow),
14924 encoder,
14925 offset + cur_offset,
14926 depth,
14927 )?;
14928
14929 _prev_end_offset = cur_offset + envelope_size;
14930 if 21 > max_ordinal {
14931 return Ok(());
14932 }
14933
14934 let cur_offset: usize = (21 - 1) * envelope_size;
14937
14938 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14940
14941 fidl::encoding::encode_in_envelope_optional::<
14946 ThisIsAXunion,
14947 fidl::encoding::DefaultFuchsiaResourceDialect,
14948 >(
14949 self.xunion_member
14950 .as_ref()
14951 .map(<ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow),
14952 encoder,
14953 offset + cur_offset,
14954 depth,
14955 )?;
14956
14957 _prev_end_offset = cur_offset + envelope_size;
14958
14959 Ok(())
14960 }
14961 }
14962
14963 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {
14964 #[inline(always)]
14965 fn new_empty() -> Self {
14966 Self::default()
14967 }
14968
14969 unsafe fn decode(
14970 &mut self,
14971 decoder: &mut fidl::encoding::Decoder<
14972 '_,
14973 fidl::encoding::DefaultFuchsiaResourceDialect,
14974 >,
14975 offset: usize,
14976 mut depth: fidl::encoding::Depth,
14977 ) -> fidl::Result<()> {
14978 decoder.debug_check_bounds::<Self>(offset);
14979 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14980 None => return Err(fidl::Error::NotNullable),
14981 Some(len) => len,
14982 };
14983 if len == 0 {
14985 return Ok(());
14986 };
14987 depth.increment()?;
14988 let envelope_size = 8;
14989 let bytes_len = len * envelope_size;
14990 let offset = decoder.out_of_line_offset(bytes_len)?;
14991 let mut _next_ordinal_to_read = 0;
14993 let mut next_offset = offset;
14994 let end_offset = offset + bytes_len;
14995 _next_ordinal_to_read += 1;
14996 if next_offset >= end_offset {
14997 return Ok(());
14998 }
14999
15000 while _next_ordinal_to_read < 1 {
15002 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15003 _next_ordinal_to_read += 1;
15004 next_offset += envelope_size;
15005 }
15006
15007 let next_out_of_line = decoder.next_out_of_line();
15008 let handles_before = decoder.remaining_handles();
15009 if let Some((inlined, num_bytes, num_handles)) =
15010 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15011 {
15012 let member_inline_size =
15013 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15014 if inlined != (member_inline_size <= 4) {
15015 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15016 }
15017 let inner_offset;
15018 let mut inner_depth = depth.clone();
15019 if inlined {
15020 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15021 inner_offset = next_offset;
15022 } else {
15023 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15024 inner_depth.increment()?;
15025 }
15026 let val_ref = self.bool_member.get_or_insert_with(|| {
15027 fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
15028 });
15029 fidl::decode!(
15030 bool,
15031 fidl::encoding::DefaultFuchsiaResourceDialect,
15032 val_ref,
15033 decoder,
15034 inner_offset,
15035 inner_depth
15036 )?;
15037 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15038 {
15039 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15040 }
15041 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15042 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15043 }
15044 }
15045
15046 next_offset += envelope_size;
15047 _next_ordinal_to_read += 1;
15048 if next_offset >= end_offset {
15049 return Ok(());
15050 }
15051
15052 while _next_ordinal_to_read < 2 {
15054 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15055 _next_ordinal_to_read += 1;
15056 next_offset += envelope_size;
15057 }
15058
15059 let next_out_of_line = decoder.next_out_of_line();
15060 let handles_before = decoder.remaining_handles();
15061 if let Some((inlined, num_bytes, num_handles)) =
15062 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15063 {
15064 let member_inline_size =
15065 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15066 if inlined != (member_inline_size <= 4) {
15067 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15068 }
15069 let inner_offset;
15070 let mut inner_depth = depth.clone();
15071 if inlined {
15072 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15073 inner_offset = next_offset;
15074 } else {
15075 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15076 inner_depth.increment()?;
15077 }
15078 let val_ref = self.int8_member.get_or_insert_with(|| {
15079 fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect)
15080 });
15081 fidl::decode!(
15082 i8,
15083 fidl::encoding::DefaultFuchsiaResourceDialect,
15084 val_ref,
15085 decoder,
15086 inner_offset,
15087 inner_depth
15088 )?;
15089 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15090 {
15091 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15092 }
15093 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15094 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15095 }
15096 }
15097
15098 next_offset += envelope_size;
15099 _next_ordinal_to_read += 1;
15100 if next_offset >= end_offset {
15101 return Ok(());
15102 }
15103
15104 while _next_ordinal_to_read < 3 {
15106 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15107 _next_ordinal_to_read += 1;
15108 next_offset += envelope_size;
15109 }
15110
15111 let next_out_of_line = decoder.next_out_of_line();
15112 let handles_before = decoder.remaining_handles();
15113 if let Some((inlined, num_bytes, num_handles)) =
15114 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15115 {
15116 let member_inline_size =
15117 <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15118 if inlined != (member_inline_size <= 4) {
15119 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15120 }
15121 let inner_offset;
15122 let mut inner_depth = depth.clone();
15123 if inlined {
15124 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15125 inner_offset = next_offset;
15126 } else {
15127 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15128 inner_depth.increment()?;
15129 }
15130 let val_ref = self.int16_member.get_or_insert_with(|| {
15131 fidl::new_empty!(i16, fidl::encoding::DefaultFuchsiaResourceDialect)
15132 });
15133 fidl::decode!(
15134 i16,
15135 fidl::encoding::DefaultFuchsiaResourceDialect,
15136 val_ref,
15137 decoder,
15138 inner_offset,
15139 inner_depth
15140 )?;
15141 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15142 {
15143 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15144 }
15145 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15146 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15147 }
15148 }
15149
15150 next_offset += envelope_size;
15151 _next_ordinal_to_read += 1;
15152 if next_offset >= end_offset {
15153 return Ok(());
15154 }
15155
15156 while _next_ordinal_to_read < 4 {
15158 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15159 _next_ordinal_to_read += 1;
15160 next_offset += envelope_size;
15161 }
15162
15163 let next_out_of_line = decoder.next_out_of_line();
15164 let handles_before = decoder.remaining_handles();
15165 if let Some((inlined, num_bytes, num_handles)) =
15166 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15167 {
15168 let member_inline_size =
15169 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15170 if inlined != (member_inline_size <= 4) {
15171 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15172 }
15173 let inner_offset;
15174 let mut inner_depth = depth.clone();
15175 if inlined {
15176 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15177 inner_offset = next_offset;
15178 } else {
15179 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15180 inner_depth.increment()?;
15181 }
15182 let val_ref = self.int32_member.get_or_insert_with(|| {
15183 fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
15184 });
15185 fidl::decode!(
15186 i32,
15187 fidl::encoding::DefaultFuchsiaResourceDialect,
15188 val_ref,
15189 decoder,
15190 inner_offset,
15191 inner_depth
15192 )?;
15193 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15194 {
15195 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15196 }
15197 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15198 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15199 }
15200 }
15201
15202 next_offset += envelope_size;
15203 _next_ordinal_to_read += 1;
15204 if next_offset >= end_offset {
15205 return Ok(());
15206 }
15207
15208 while _next_ordinal_to_read < 5 {
15210 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15211 _next_ordinal_to_read += 1;
15212 next_offset += envelope_size;
15213 }
15214
15215 let next_out_of_line = decoder.next_out_of_line();
15216 let handles_before = decoder.remaining_handles();
15217 if let Some((inlined, num_bytes, num_handles)) =
15218 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15219 {
15220 let member_inline_size =
15221 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15222 if inlined != (member_inline_size <= 4) {
15223 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15224 }
15225 let inner_offset;
15226 let mut inner_depth = depth.clone();
15227 if inlined {
15228 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15229 inner_offset = next_offset;
15230 } else {
15231 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15232 inner_depth.increment()?;
15233 }
15234 let val_ref = self.int64_member.get_or_insert_with(|| {
15235 fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
15236 });
15237 fidl::decode!(
15238 i64,
15239 fidl::encoding::DefaultFuchsiaResourceDialect,
15240 val_ref,
15241 decoder,
15242 inner_offset,
15243 inner_depth
15244 )?;
15245 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15246 {
15247 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15248 }
15249 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15250 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15251 }
15252 }
15253
15254 next_offset += envelope_size;
15255 _next_ordinal_to_read += 1;
15256 if next_offset >= end_offset {
15257 return Ok(());
15258 }
15259
15260 while _next_ordinal_to_read < 6 {
15262 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15263 _next_ordinal_to_read += 1;
15264 next_offset += envelope_size;
15265 }
15266
15267 let next_out_of_line = decoder.next_out_of_line();
15268 let handles_before = decoder.remaining_handles();
15269 if let Some((inlined, num_bytes, num_handles)) =
15270 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15271 {
15272 let member_inline_size =
15273 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15274 if inlined != (member_inline_size <= 4) {
15275 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15276 }
15277 let inner_offset;
15278 let mut inner_depth = depth.clone();
15279 if inlined {
15280 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15281 inner_offset = next_offset;
15282 } else {
15283 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15284 inner_depth.increment()?;
15285 }
15286 let val_ref = self.uint8_member.get_or_insert_with(|| {
15287 fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
15288 });
15289 fidl::decode!(
15290 u8,
15291 fidl::encoding::DefaultFuchsiaResourceDialect,
15292 val_ref,
15293 decoder,
15294 inner_offset,
15295 inner_depth
15296 )?;
15297 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15298 {
15299 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15300 }
15301 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15302 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15303 }
15304 }
15305
15306 next_offset += envelope_size;
15307 _next_ordinal_to_read += 1;
15308 if next_offset >= end_offset {
15309 return Ok(());
15310 }
15311
15312 while _next_ordinal_to_read < 7 {
15314 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15315 _next_ordinal_to_read += 1;
15316 next_offset += envelope_size;
15317 }
15318
15319 let next_out_of_line = decoder.next_out_of_line();
15320 let handles_before = decoder.remaining_handles();
15321 if let Some((inlined, num_bytes, num_handles)) =
15322 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15323 {
15324 let member_inline_size =
15325 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15326 if inlined != (member_inline_size <= 4) {
15327 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15328 }
15329 let inner_offset;
15330 let mut inner_depth = depth.clone();
15331 if inlined {
15332 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15333 inner_offset = next_offset;
15334 } else {
15335 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15336 inner_depth.increment()?;
15337 }
15338 let val_ref = self.uint16_member.get_or_insert_with(|| {
15339 fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
15340 });
15341 fidl::decode!(
15342 u16,
15343 fidl::encoding::DefaultFuchsiaResourceDialect,
15344 val_ref,
15345 decoder,
15346 inner_offset,
15347 inner_depth
15348 )?;
15349 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15350 {
15351 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15352 }
15353 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15354 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15355 }
15356 }
15357
15358 next_offset += envelope_size;
15359 _next_ordinal_to_read += 1;
15360 if next_offset >= end_offset {
15361 return Ok(());
15362 }
15363
15364 while _next_ordinal_to_read < 8 {
15366 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15367 _next_ordinal_to_read += 1;
15368 next_offset += envelope_size;
15369 }
15370
15371 let next_out_of_line = decoder.next_out_of_line();
15372 let handles_before = decoder.remaining_handles();
15373 if let Some((inlined, num_bytes, num_handles)) =
15374 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15375 {
15376 let member_inline_size =
15377 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15378 if inlined != (member_inline_size <= 4) {
15379 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15380 }
15381 let inner_offset;
15382 let mut inner_depth = depth.clone();
15383 if inlined {
15384 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15385 inner_offset = next_offset;
15386 } else {
15387 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15388 inner_depth.increment()?;
15389 }
15390 let val_ref = self.uint32_member.get_or_insert_with(|| {
15391 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
15392 });
15393 fidl::decode!(
15394 u32,
15395 fidl::encoding::DefaultFuchsiaResourceDialect,
15396 val_ref,
15397 decoder,
15398 inner_offset,
15399 inner_depth
15400 )?;
15401 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15402 {
15403 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15404 }
15405 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15406 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15407 }
15408 }
15409
15410 next_offset += envelope_size;
15411 _next_ordinal_to_read += 1;
15412 if next_offset >= end_offset {
15413 return Ok(());
15414 }
15415
15416 while _next_ordinal_to_read < 9 {
15418 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15419 _next_ordinal_to_read += 1;
15420 next_offset += envelope_size;
15421 }
15422
15423 let next_out_of_line = decoder.next_out_of_line();
15424 let handles_before = decoder.remaining_handles();
15425 if let Some((inlined, num_bytes, num_handles)) =
15426 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15427 {
15428 let member_inline_size =
15429 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15430 if inlined != (member_inline_size <= 4) {
15431 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15432 }
15433 let inner_offset;
15434 let mut inner_depth = depth.clone();
15435 if inlined {
15436 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15437 inner_offset = next_offset;
15438 } else {
15439 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15440 inner_depth.increment()?;
15441 }
15442 let val_ref = self.uint64_member.get_or_insert_with(|| {
15443 fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
15444 });
15445 fidl::decode!(
15446 u64,
15447 fidl::encoding::DefaultFuchsiaResourceDialect,
15448 val_ref,
15449 decoder,
15450 inner_offset,
15451 inner_depth
15452 )?;
15453 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15454 {
15455 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15456 }
15457 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15458 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15459 }
15460 }
15461
15462 next_offset += envelope_size;
15463 _next_ordinal_to_read += 1;
15464 if next_offset >= end_offset {
15465 return Ok(());
15466 }
15467
15468 while _next_ordinal_to_read < 10 {
15470 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15471 _next_ordinal_to_read += 1;
15472 next_offset += envelope_size;
15473 }
15474
15475 let next_out_of_line = decoder.next_out_of_line();
15476 let handles_before = decoder.remaining_handles();
15477 if let Some((inlined, num_bytes, num_handles)) =
15478 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15479 {
15480 let member_inline_size =
15481 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15482 if inlined != (member_inline_size <= 4) {
15483 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15484 }
15485 let inner_offset;
15486 let mut inner_depth = depth.clone();
15487 if inlined {
15488 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15489 inner_offset = next_offset;
15490 } else {
15491 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15492 inner_depth.increment()?;
15493 }
15494 let val_ref = self.float32_member.get_or_insert_with(|| {
15495 fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
15496 });
15497 fidl::decode!(
15498 f32,
15499 fidl::encoding::DefaultFuchsiaResourceDialect,
15500 val_ref,
15501 decoder,
15502 inner_offset,
15503 inner_depth
15504 )?;
15505 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15506 {
15507 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15508 }
15509 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15510 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15511 }
15512 }
15513
15514 next_offset += envelope_size;
15515 _next_ordinal_to_read += 1;
15516 if next_offset >= end_offset {
15517 return Ok(());
15518 }
15519
15520 while _next_ordinal_to_read < 11 {
15522 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15523 _next_ordinal_to_read += 1;
15524 next_offset += envelope_size;
15525 }
15526
15527 let next_out_of_line = decoder.next_out_of_line();
15528 let handles_before = decoder.remaining_handles();
15529 if let Some((inlined, num_bytes, num_handles)) =
15530 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15531 {
15532 let member_inline_size =
15533 <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15534 if inlined != (member_inline_size <= 4) {
15535 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15536 }
15537 let inner_offset;
15538 let mut inner_depth = depth.clone();
15539 if inlined {
15540 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15541 inner_offset = next_offset;
15542 } else {
15543 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15544 inner_depth.increment()?;
15545 }
15546 let val_ref = self.float64_member.get_or_insert_with(|| {
15547 fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect)
15548 });
15549 fidl::decode!(
15550 f64,
15551 fidl::encoding::DefaultFuchsiaResourceDialect,
15552 val_ref,
15553 decoder,
15554 inner_offset,
15555 inner_depth
15556 )?;
15557 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15558 {
15559 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15560 }
15561 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15562 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15563 }
15564 }
15565
15566 next_offset += envelope_size;
15567 _next_ordinal_to_read += 1;
15568 if next_offset >= end_offset {
15569 return Ok(());
15570 }
15571
15572 while _next_ordinal_to_read < 12 {
15574 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15575 _next_ordinal_to_read += 1;
15576 next_offset += envelope_size;
15577 }
15578
15579 let next_out_of_line = decoder.next_out_of_line();
15580 let handles_before = decoder.remaining_handles();
15581 if let Some((inlined, num_bytes, num_handles)) =
15582 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15583 {
15584 let member_inline_size =
15585 <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15586 if inlined != (member_inline_size <= 4) {
15587 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15588 }
15589 let inner_offset;
15590 let mut inner_depth = depth.clone();
15591 if inlined {
15592 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15593 inner_offset = next_offset;
15594 } else {
15595 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15596 inner_depth.increment()?;
15597 }
15598 let val_ref = self.enum_member.get_or_insert_with(|| {
15599 fidl::new_empty!(DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect)
15600 });
15601 fidl::decode!(
15602 DefaultEnum,
15603 fidl::encoding::DefaultFuchsiaResourceDialect,
15604 val_ref,
15605 decoder,
15606 inner_offset,
15607 inner_depth
15608 )?;
15609 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15610 {
15611 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15612 }
15613 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15614 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15615 }
15616 }
15617
15618 next_offset += envelope_size;
15619 _next_ordinal_to_read += 1;
15620 if next_offset >= end_offset {
15621 return Ok(());
15622 }
15623
15624 while _next_ordinal_to_read < 13 {
15626 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15627 _next_ordinal_to_read += 1;
15628 next_offset += envelope_size;
15629 }
15630
15631 let next_out_of_line = decoder.next_out_of_line();
15632 let handles_before = decoder.remaining_handles();
15633 if let Some((inlined, num_bytes, num_handles)) =
15634 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15635 {
15636 let member_inline_size =
15637 <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15638 if inlined != (member_inline_size <= 4) {
15639 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15640 }
15641 let inner_offset;
15642 let mut inner_depth = depth.clone();
15643 if inlined {
15644 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15645 inner_offset = next_offset;
15646 } else {
15647 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15648 inner_depth.increment()?;
15649 }
15650 let val_ref = self.bits_member.get_or_insert_with(|| {
15651 fidl::new_empty!(DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect)
15652 });
15653 fidl::decode!(
15654 DefaultBits,
15655 fidl::encoding::DefaultFuchsiaResourceDialect,
15656 val_ref,
15657 decoder,
15658 inner_offset,
15659 inner_depth
15660 )?;
15661 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15662 {
15663 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15664 }
15665 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15666 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15667 }
15668 }
15669
15670 next_offset += envelope_size;
15671 _next_ordinal_to_read += 1;
15672 if next_offset >= end_offset {
15673 return Ok(());
15674 }
15675
15676 while _next_ordinal_to_read < 14 {
15678 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15679 _next_ordinal_to_read += 1;
15680 next_offset += envelope_size;
15681 }
15682
15683 let next_out_of_line = decoder.next_out_of_line();
15684 let handles_before = decoder.remaining_handles();
15685 if let Some((inlined, num_bytes, num_handles)) =
15686 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15687 {
15688 let member_inline_size = <fidl::encoding::HandleType<
15689 fidl::Handle,
15690 { fidl::ObjectType::NONE.into_raw() },
15691 2147483648,
15692 > as fidl::encoding::TypeMarker>::inline_size(
15693 decoder.context
15694 );
15695 if inlined != (member_inline_size <= 4) {
15696 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15697 }
15698 let inner_offset;
15699 let mut inner_depth = depth.clone();
15700 if inlined {
15701 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15702 inner_offset = next_offset;
15703 } else {
15704 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15705 inner_depth.increment()?;
15706 }
15707 let val_ref =
15708 self.handle_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
15709 fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15710 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15711 {
15712 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15713 }
15714 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15715 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15716 }
15717 }
15718
15719 next_offset += envelope_size;
15720 _next_ordinal_to_read += 1;
15721 if next_offset >= end_offset {
15722 return Ok(());
15723 }
15724
15725 while _next_ordinal_to_read < 15 {
15727 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15728 _next_ordinal_to_read += 1;
15729 next_offset += envelope_size;
15730 }
15731
15732 let next_out_of_line = decoder.next_out_of_line();
15733 let handles_before = decoder.remaining_handles();
15734 if let Some((inlined, num_bytes, num_handles)) =
15735 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15736 {
15737 let member_inline_size =
15738 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15739 decoder.context,
15740 );
15741 if inlined != (member_inline_size <= 4) {
15742 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15743 }
15744 let inner_offset;
15745 let mut inner_depth = depth.clone();
15746 if inlined {
15747 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15748 inner_offset = next_offset;
15749 } else {
15750 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15751 inner_depth.increment()?;
15752 }
15753 let val_ref = self.string_member.get_or_insert_with(|| {
15754 fidl::new_empty!(
15755 fidl::encoding::UnboundedString,
15756 fidl::encoding::DefaultFuchsiaResourceDialect
15757 )
15758 });
15759 fidl::decode!(
15760 fidl::encoding::UnboundedString,
15761 fidl::encoding::DefaultFuchsiaResourceDialect,
15762 val_ref,
15763 decoder,
15764 inner_offset,
15765 inner_depth
15766 )?;
15767 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15768 {
15769 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15770 }
15771 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15772 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15773 }
15774 }
15775
15776 next_offset += envelope_size;
15777 _next_ordinal_to_read += 1;
15778 if next_offset >= end_offset {
15779 return Ok(());
15780 }
15781
15782 while _next_ordinal_to_read < 16 {
15784 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15785 _next_ordinal_to_read += 1;
15786 next_offset += envelope_size;
15787 }
15788
15789 let next_out_of_line = decoder.next_out_of_line();
15790 let handles_before = decoder.remaining_handles();
15791 if let Some((inlined, num_bytes, num_handles)) =
15792 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15793 {
15794 let member_inline_size =
15795 <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15796 if inlined != (member_inline_size <= 4) {
15797 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15798 }
15799 let inner_offset;
15800 let mut inner_depth = depth.clone();
15801 if inlined {
15802 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15803 inner_offset = next_offset;
15804 } else {
15805 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15806 inner_depth.increment()?;
15807 }
15808 let val_ref = self.struct_member.get_or_insert_with(|| {
15809 fidl::new_empty!(ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect)
15810 });
15811 fidl::decode!(
15812 ThisIsAStruct,
15813 fidl::encoding::DefaultFuchsiaResourceDialect,
15814 val_ref,
15815 decoder,
15816 inner_offset,
15817 inner_depth
15818 )?;
15819 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15820 {
15821 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15822 }
15823 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15824 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15825 }
15826 }
15827
15828 next_offset += envelope_size;
15829 _next_ordinal_to_read += 1;
15830 if next_offset >= end_offset {
15831 return Ok(());
15832 }
15833
15834 while _next_ordinal_to_read < 17 {
15836 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15837 _next_ordinal_to_read += 1;
15838 next_offset += envelope_size;
15839 }
15840
15841 let next_out_of_line = decoder.next_out_of_line();
15842 let handles_before = decoder.remaining_handles();
15843 if let Some((inlined, num_bytes, num_handles)) =
15844 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15845 {
15846 let member_inline_size =
15847 <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15848 if inlined != (member_inline_size <= 4) {
15849 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15850 }
15851 let inner_offset;
15852 let mut inner_depth = depth.clone();
15853 if inlined {
15854 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15855 inner_offset = next_offset;
15856 } else {
15857 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15858 inner_depth.increment()?;
15859 }
15860 let val_ref = self.union_member.get_or_insert_with(|| {
15861 fidl::new_empty!(ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect)
15862 });
15863 fidl::decode!(
15864 ThisIsAUnion,
15865 fidl::encoding::DefaultFuchsiaResourceDialect,
15866 val_ref,
15867 decoder,
15868 inner_offset,
15869 inner_depth
15870 )?;
15871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15872 {
15873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15874 }
15875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15877 }
15878 }
15879
15880 next_offset += envelope_size;
15881 _next_ordinal_to_read += 1;
15882 if next_offset >= end_offset {
15883 return Ok(());
15884 }
15885
15886 while _next_ordinal_to_read < 18 {
15888 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15889 _next_ordinal_to_read += 1;
15890 next_offset += envelope_size;
15891 }
15892
15893 let next_out_of_line = decoder.next_out_of_line();
15894 let handles_before = decoder.remaining_handles();
15895 if let Some((inlined, num_bytes, num_handles)) =
15896 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15897 {
15898 let member_inline_size =
15899 <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(
15900 decoder.context,
15901 );
15902 if inlined != (member_inline_size <= 4) {
15903 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15904 }
15905 let inner_offset;
15906 let mut inner_depth = depth.clone();
15907 if inlined {
15908 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15909 inner_offset = next_offset;
15910 } else {
15911 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15912 inner_depth.increment()?;
15913 }
15914 let val_ref =
15915 self.array_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect));
15916 fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15917 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15918 {
15919 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15920 }
15921 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15922 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15923 }
15924 }
15925
15926 next_offset += envelope_size;
15927 _next_ordinal_to_read += 1;
15928 if next_offset >= end_offset {
15929 return Ok(());
15930 }
15931
15932 while _next_ordinal_to_read < 19 {
15934 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15935 _next_ordinal_to_read += 1;
15936 next_offset += envelope_size;
15937 }
15938
15939 let next_out_of_line = decoder.next_out_of_line();
15940 let handles_before = decoder.remaining_handles();
15941 if let Some((inlined, num_bytes, num_handles)) =
15942 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15943 {
15944 let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15945 if inlined != (member_inline_size <= 4) {
15946 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15947 }
15948 let inner_offset;
15949 let mut inner_depth = depth.clone();
15950 if inlined {
15951 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15952 inner_offset = next_offset;
15953 } else {
15954 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15955 inner_depth.increment()?;
15956 }
15957 let val_ref = self.vector_member.get_or_insert_with(|| {
15958 fidl::new_empty!(
15959 fidl::encoding::UnboundedVector<u32>,
15960 fidl::encoding::DefaultFuchsiaResourceDialect
15961 )
15962 });
15963 fidl::decode!(
15964 fidl::encoding::UnboundedVector<u32>,
15965 fidl::encoding::DefaultFuchsiaResourceDialect,
15966 val_ref,
15967 decoder,
15968 inner_offset,
15969 inner_depth
15970 )?;
15971 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15972 {
15973 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15974 }
15975 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15976 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15977 }
15978 }
15979
15980 next_offset += envelope_size;
15981 _next_ordinal_to_read += 1;
15982 if next_offset >= end_offset {
15983 return Ok(());
15984 }
15985
15986 while _next_ordinal_to_read < 20 {
15988 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15989 _next_ordinal_to_read += 1;
15990 next_offset += envelope_size;
15991 }
15992
15993 let next_out_of_line = decoder.next_out_of_line();
15994 let handles_before = decoder.remaining_handles();
15995 if let Some((inlined, num_bytes, num_handles)) =
15996 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15997 {
15998 let member_inline_size =
15999 <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16000 if inlined != (member_inline_size <= 4) {
16001 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16002 }
16003 let inner_offset;
16004 let mut inner_depth = depth.clone();
16005 if inlined {
16006 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16007 inner_offset = next_offset;
16008 } else {
16009 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16010 inner_depth.increment()?;
16011 }
16012 let val_ref = self.table_member.get_or_insert_with(|| {
16013 fidl::new_empty!(ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect)
16014 });
16015 fidl::decode!(
16016 ThisIsATable,
16017 fidl::encoding::DefaultFuchsiaResourceDialect,
16018 val_ref,
16019 decoder,
16020 inner_offset,
16021 inner_depth
16022 )?;
16023 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16024 {
16025 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16026 }
16027 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16028 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16029 }
16030 }
16031
16032 next_offset += envelope_size;
16033 _next_ordinal_to_read += 1;
16034 if next_offset >= end_offset {
16035 return Ok(());
16036 }
16037
16038 while _next_ordinal_to_read < 21 {
16040 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16041 _next_ordinal_to_read += 1;
16042 next_offset += envelope_size;
16043 }
16044
16045 let next_out_of_line = decoder.next_out_of_line();
16046 let handles_before = decoder.remaining_handles();
16047 if let Some((inlined, num_bytes, num_handles)) =
16048 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16049 {
16050 let member_inline_size =
16051 <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16052 if inlined != (member_inline_size <= 4) {
16053 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16054 }
16055 let inner_offset;
16056 let mut inner_depth = depth.clone();
16057 if inlined {
16058 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16059 inner_offset = next_offset;
16060 } else {
16061 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16062 inner_depth.increment()?;
16063 }
16064 let val_ref = self.xunion_member.get_or_insert_with(|| {
16065 fidl::new_empty!(ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect)
16066 });
16067 fidl::decode!(
16068 ThisIsAXunion,
16069 fidl::encoding::DefaultFuchsiaResourceDialect,
16070 val_ref,
16071 decoder,
16072 inner_offset,
16073 inner_depth
16074 )?;
16075 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16076 {
16077 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16078 }
16079 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16080 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16081 }
16082 }
16083
16084 next_offset += envelope_size;
16085
16086 while next_offset < end_offset {
16088 _next_ordinal_to_read += 1;
16089 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16090 next_offset += envelope_size;
16091 }
16092
16093 Ok(())
16094 }
16095 }
16096
16097 impl fidl::encoding::ResourceTypeMarker for AllTypesXunion {
16098 type Borrowed<'a> = &'a mut Self;
16099 fn take_or_borrow<'a>(
16100 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16101 ) -> Self::Borrowed<'a> {
16102 value
16103 }
16104 }
16105
16106 unsafe impl fidl::encoding::TypeMarker for AllTypesXunion {
16107 type Owned = Self;
16108
16109 #[inline(always)]
16110 fn inline_align(_context: fidl::encoding::Context) -> usize {
16111 8
16112 }
16113
16114 #[inline(always)]
16115 fn inline_size(_context: fidl::encoding::Context) -> usize {
16116 16
16117 }
16118 }
16119
16120 unsafe impl
16121 fidl::encoding::Encode<AllTypesXunion, fidl::encoding::DefaultFuchsiaResourceDialect>
16122 for &mut AllTypesXunion
16123 {
16124 #[inline]
16125 unsafe fn encode(
16126 self,
16127 encoder: &mut fidl::encoding::Encoder<
16128 '_,
16129 fidl::encoding::DefaultFuchsiaResourceDialect,
16130 >,
16131 offset: usize,
16132 _depth: fidl::encoding::Depth,
16133 ) -> fidl::Result<()> {
16134 encoder.debug_check_bounds::<AllTypesXunion>(offset);
16135 encoder.write_num::<u64>(self.ordinal(), offset);
16136 match self {
16137 AllTypesXunion::BoolMember(ref val) => {
16138 fidl::encoding::encode_in_envelope::<bool, fidl::encoding::DefaultFuchsiaResourceDialect>(
16139 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
16140 encoder, offset + 8, _depth
16141 )
16142 }
16143 AllTypesXunion::Int8Member(ref val) => {
16144 fidl::encoding::encode_in_envelope::<i8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16145 <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16146 encoder, offset + 8, _depth
16147 )
16148 }
16149 AllTypesXunion::Int16Member(ref val) => {
16150 fidl::encoding::encode_in_envelope::<i16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16151 <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16152 encoder, offset + 8, _depth
16153 )
16154 }
16155 AllTypesXunion::Int32Member(ref val) => {
16156 fidl::encoding::encode_in_envelope::<i32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16157 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16158 encoder, offset + 8, _depth
16159 )
16160 }
16161 AllTypesXunion::Int64Member(ref val) => {
16162 fidl::encoding::encode_in_envelope::<i64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16163 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16164 encoder, offset + 8, _depth
16165 )
16166 }
16167 AllTypesXunion::Uint8Member(ref val) => {
16168 fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16169 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16170 encoder, offset + 8, _depth
16171 )
16172 }
16173 AllTypesXunion::Uint16Member(ref val) => {
16174 fidl::encoding::encode_in_envelope::<u16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16175 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16176 encoder, offset + 8, _depth
16177 )
16178 }
16179 AllTypesXunion::Uint32Member(ref val) => {
16180 fidl::encoding::encode_in_envelope::<u32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16181 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16182 encoder, offset + 8, _depth
16183 )
16184 }
16185 AllTypesXunion::Uint64Member(ref val) => {
16186 fidl::encoding::encode_in_envelope::<u64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16187 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16188 encoder, offset + 8, _depth
16189 )
16190 }
16191 AllTypesXunion::Float32Member(ref val) => {
16192 fidl::encoding::encode_in_envelope::<f32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16193 <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16194 encoder, offset + 8, _depth
16195 )
16196 }
16197 AllTypesXunion::Float64Member(ref val) => {
16198 fidl::encoding::encode_in_envelope::<f64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16199 <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16200 encoder, offset + 8, _depth
16201 )
16202 }
16203 AllTypesXunion::EnumMember(ref val) => {
16204 fidl::encoding::encode_in_envelope::<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>(
16205 <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(val),
16206 encoder, offset + 8, _depth
16207 )
16208 }
16209 AllTypesXunion::BitsMember(ref val) => {
16210 fidl::encoding::encode_in_envelope::<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>(
16211 <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(val),
16212 encoder, offset + 8, _depth
16213 )
16214 }
16215 AllTypesXunion::HandleMember(ref mut val) => {
16216 fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16217 <fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
16218 encoder, offset + 8, _depth
16219 )
16220 }
16221 AllTypesXunion::StringMember(ref val) => {
16222 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
16223 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
16224 encoder, offset + 8, _depth
16225 )
16226 }
16227 AllTypesXunion::StructMember(ref val) => {
16228 fidl::encoding::encode_in_envelope::<ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect>(
16229 <ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
16230 encoder, offset + 8, _depth
16231 )
16232 }
16233 AllTypesXunion::UnionMember(ref val) => {
16234 fidl::encoding::encode_in_envelope::<ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16235 <ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
16236 encoder, offset + 8, _depth
16237 )
16238 }
16239 AllTypesXunion::ArrayMember(ref val) => {
16240 fidl::encoding::encode_in_envelope::<fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16241 <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(val),
16242 encoder, offset + 8, _depth
16243 )
16244 }
16245 AllTypesXunion::VectorMember(ref val) => {
16246 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16247 <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
16248 encoder, offset + 8, _depth
16249 )
16250 }
16251 AllTypesXunion::TableMember(ref val) => {
16252 fidl::encoding::encode_in_envelope::<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>(
16253 <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(val),
16254 encoder, offset + 8, _depth
16255 )
16256 }
16257 AllTypesXunion::XunionMember(ref val) => {
16258 fidl::encoding::encode_in_envelope::<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16259 <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(val),
16260 encoder, offset + 8, _depth
16261 )
16262 }
16263 AllTypesXunion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16264 }
16265 }
16266 }
16267
16268 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16269 for AllTypesXunion
16270 {
16271 #[inline(always)]
16272 fn new_empty() -> Self {
16273 Self::__SourceBreaking { unknown_ordinal: 0 }
16274 }
16275
16276 #[inline]
16277 unsafe fn decode(
16278 &mut self,
16279 decoder: &mut fidl::encoding::Decoder<
16280 '_,
16281 fidl::encoding::DefaultFuchsiaResourceDialect,
16282 >,
16283 offset: usize,
16284 mut depth: fidl::encoding::Depth,
16285 ) -> fidl::Result<()> {
16286 decoder.debug_check_bounds::<Self>(offset);
16287 #[allow(unused_variables)]
16288 let next_out_of_line = decoder.next_out_of_line();
16289 let handles_before = decoder.remaining_handles();
16290 let (ordinal, inlined, num_bytes, num_handles) =
16291 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16292
16293 let member_inline_size = match ordinal {
16294 1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16295 2 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16296 3 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16297 4 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16298 5 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16299 6 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16300 7 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16301 8 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16302 9 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16303 10 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16304 11 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16305 12 => <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16306 13 => <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16307 14 => <fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16308 15 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16309 16 => <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16310 17 => <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16311 18 => <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16312 19 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16313 20 => <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16314 21 => <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16315 0 => return Err(fidl::Error::UnknownUnionTag),
16316 _ => num_bytes as usize,
16317 };
16318
16319 if inlined != (member_inline_size <= 4) {
16320 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16321 }
16322 let _inner_offset;
16323 if inlined {
16324 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16325 _inner_offset = offset + 8;
16326 } else {
16327 depth.increment()?;
16328 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16329 }
16330 match ordinal {
16331 1 => {
16332 #[allow(irrefutable_let_patterns)]
16333 if let AllTypesXunion::BoolMember(_) = self {
16334 } else {
16336 *self = AllTypesXunion::BoolMember(fidl::new_empty!(
16338 bool,
16339 fidl::encoding::DefaultFuchsiaResourceDialect
16340 ));
16341 }
16342 #[allow(irrefutable_let_patterns)]
16343 if let AllTypesXunion::BoolMember(ref mut val) = self {
16344 fidl::decode!(
16345 bool,
16346 fidl::encoding::DefaultFuchsiaResourceDialect,
16347 val,
16348 decoder,
16349 _inner_offset,
16350 depth
16351 )?;
16352 } else {
16353 unreachable!()
16354 }
16355 }
16356 2 => {
16357 #[allow(irrefutable_let_patterns)]
16358 if let AllTypesXunion::Int8Member(_) = self {
16359 } else {
16361 *self = AllTypesXunion::Int8Member(fidl::new_empty!(
16363 i8,
16364 fidl::encoding::DefaultFuchsiaResourceDialect
16365 ));
16366 }
16367 #[allow(irrefutable_let_patterns)]
16368 if let AllTypesXunion::Int8Member(ref mut val) = self {
16369 fidl::decode!(
16370 i8,
16371 fidl::encoding::DefaultFuchsiaResourceDialect,
16372 val,
16373 decoder,
16374 _inner_offset,
16375 depth
16376 )?;
16377 } else {
16378 unreachable!()
16379 }
16380 }
16381 3 => {
16382 #[allow(irrefutable_let_patterns)]
16383 if let AllTypesXunion::Int16Member(_) = self {
16384 } else {
16386 *self = AllTypesXunion::Int16Member(fidl::new_empty!(
16388 i16,
16389 fidl::encoding::DefaultFuchsiaResourceDialect
16390 ));
16391 }
16392 #[allow(irrefutable_let_patterns)]
16393 if let AllTypesXunion::Int16Member(ref mut val) = self {
16394 fidl::decode!(
16395 i16,
16396 fidl::encoding::DefaultFuchsiaResourceDialect,
16397 val,
16398 decoder,
16399 _inner_offset,
16400 depth
16401 )?;
16402 } else {
16403 unreachable!()
16404 }
16405 }
16406 4 => {
16407 #[allow(irrefutable_let_patterns)]
16408 if let AllTypesXunion::Int32Member(_) = self {
16409 } else {
16411 *self = AllTypesXunion::Int32Member(fidl::new_empty!(
16413 i32,
16414 fidl::encoding::DefaultFuchsiaResourceDialect
16415 ));
16416 }
16417 #[allow(irrefutable_let_patterns)]
16418 if let AllTypesXunion::Int32Member(ref mut val) = self {
16419 fidl::decode!(
16420 i32,
16421 fidl::encoding::DefaultFuchsiaResourceDialect,
16422 val,
16423 decoder,
16424 _inner_offset,
16425 depth
16426 )?;
16427 } else {
16428 unreachable!()
16429 }
16430 }
16431 5 => {
16432 #[allow(irrefutable_let_patterns)]
16433 if let AllTypesXunion::Int64Member(_) = self {
16434 } else {
16436 *self = AllTypesXunion::Int64Member(fidl::new_empty!(
16438 i64,
16439 fidl::encoding::DefaultFuchsiaResourceDialect
16440 ));
16441 }
16442 #[allow(irrefutable_let_patterns)]
16443 if let AllTypesXunion::Int64Member(ref mut val) = self {
16444 fidl::decode!(
16445 i64,
16446 fidl::encoding::DefaultFuchsiaResourceDialect,
16447 val,
16448 decoder,
16449 _inner_offset,
16450 depth
16451 )?;
16452 } else {
16453 unreachable!()
16454 }
16455 }
16456 6 => {
16457 #[allow(irrefutable_let_patterns)]
16458 if let AllTypesXunion::Uint8Member(_) = self {
16459 } else {
16461 *self = AllTypesXunion::Uint8Member(fidl::new_empty!(
16463 u8,
16464 fidl::encoding::DefaultFuchsiaResourceDialect
16465 ));
16466 }
16467 #[allow(irrefutable_let_patterns)]
16468 if let AllTypesXunion::Uint8Member(ref mut val) = self {
16469 fidl::decode!(
16470 u8,
16471 fidl::encoding::DefaultFuchsiaResourceDialect,
16472 val,
16473 decoder,
16474 _inner_offset,
16475 depth
16476 )?;
16477 } else {
16478 unreachable!()
16479 }
16480 }
16481 7 => {
16482 #[allow(irrefutable_let_patterns)]
16483 if let AllTypesXunion::Uint16Member(_) = self {
16484 } else {
16486 *self = AllTypesXunion::Uint16Member(fidl::new_empty!(
16488 u16,
16489 fidl::encoding::DefaultFuchsiaResourceDialect
16490 ));
16491 }
16492 #[allow(irrefutable_let_patterns)]
16493 if let AllTypesXunion::Uint16Member(ref mut val) = self {
16494 fidl::decode!(
16495 u16,
16496 fidl::encoding::DefaultFuchsiaResourceDialect,
16497 val,
16498 decoder,
16499 _inner_offset,
16500 depth
16501 )?;
16502 } else {
16503 unreachable!()
16504 }
16505 }
16506 8 => {
16507 #[allow(irrefutable_let_patterns)]
16508 if let AllTypesXunion::Uint32Member(_) = self {
16509 } else {
16511 *self = AllTypesXunion::Uint32Member(fidl::new_empty!(
16513 u32,
16514 fidl::encoding::DefaultFuchsiaResourceDialect
16515 ));
16516 }
16517 #[allow(irrefutable_let_patterns)]
16518 if let AllTypesXunion::Uint32Member(ref mut val) = self {
16519 fidl::decode!(
16520 u32,
16521 fidl::encoding::DefaultFuchsiaResourceDialect,
16522 val,
16523 decoder,
16524 _inner_offset,
16525 depth
16526 )?;
16527 } else {
16528 unreachable!()
16529 }
16530 }
16531 9 => {
16532 #[allow(irrefutable_let_patterns)]
16533 if let AllTypesXunion::Uint64Member(_) = self {
16534 } else {
16536 *self = AllTypesXunion::Uint64Member(fidl::new_empty!(
16538 u64,
16539 fidl::encoding::DefaultFuchsiaResourceDialect
16540 ));
16541 }
16542 #[allow(irrefutable_let_patterns)]
16543 if let AllTypesXunion::Uint64Member(ref mut val) = self {
16544 fidl::decode!(
16545 u64,
16546 fidl::encoding::DefaultFuchsiaResourceDialect,
16547 val,
16548 decoder,
16549 _inner_offset,
16550 depth
16551 )?;
16552 } else {
16553 unreachable!()
16554 }
16555 }
16556 10 => {
16557 #[allow(irrefutable_let_patterns)]
16558 if let AllTypesXunion::Float32Member(_) = self {
16559 } else {
16561 *self = AllTypesXunion::Float32Member(fidl::new_empty!(
16563 f32,
16564 fidl::encoding::DefaultFuchsiaResourceDialect
16565 ));
16566 }
16567 #[allow(irrefutable_let_patterns)]
16568 if let AllTypesXunion::Float32Member(ref mut val) = self {
16569 fidl::decode!(
16570 f32,
16571 fidl::encoding::DefaultFuchsiaResourceDialect,
16572 val,
16573 decoder,
16574 _inner_offset,
16575 depth
16576 )?;
16577 } else {
16578 unreachable!()
16579 }
16580 }
16581 11 => {
16582 #[allow(irrefutable_let_patterns)]
16583 if let AllTypesXunion::Float64Member(_) = self {
16584 } else {
16586 *self = AllTypesXunion::Float64Member(fidl::new_empty!(
16588 f64,
16589 fidl::encoding::DefaultFuchsiaResourceDialect
16590 ));
16591 }
16592 #[allow(irrefutable_let_patterns)]
16593 if let AllTypesXunion::Float64Member(ref mut val) = self {
16594 fidl::decode!(
16595 f64,
16596 fidl::encoding::DefaultFuchsiaResourceDialect,
16597 val,
16598 decoder,
16599 _inner_offset,
16600 depth
16601 )?;
16602 } else {
16603 unreachable!()
16604 }
16605 }
16606 12 => {
16607 #[allow(irrefutable_let_patterns)]
16608 if let AllTypesXunion::EnumMember(_) = self {
16609 } else {
16611 *self = AllTypesXunion::EnumMember(fidl::new_empty!(
16613 DefaultEnum,
16614 fidl::encoding::DefaultFuchsiaResourceDialect
16615 ));
16616 }
16617 #[allow(irrefutable_let_patterns)]
16618 if let AllTypesXunion::EnumMember(ref mut val) = self {
16619 fidl::decode!(
16620 DefaultEnum,
16621 fidl::encoding::DefaultFuchsiaResourceDialect,
16622 val,
16623 decoder,
16624 _inner_offset,
16625 depth
16626 )?;
16627 } else {
16628 unreachable!()
16629 }
16630 }
16631 13 => {
16632 #[allow(irrefutable_let_patterns)]
16633 if let AllTypesXunion::BitsMember(_) = self {
16634 } else {
16636 *self = AllTypesXunion::BitsMember(fidl::new_empty!(
16638 DefaultBits,
16639 fidl::encoding::DefaultFuchsiaResourceDialect
16640 ));
16641 }
16642 #[allow(irrefutable_let_patterns)]
16643 if let AllTypesXunion::BitsMember(ref mut val) = self {
16644 fidl::decode!(
16645 DefaultBits,
16646 fidl::encoding::DefaultFuchsiaResourceDialect,
16647 val,
16648 decoder,
16649 _inner_offset,
16650 depth
16651 )?;
16652 } else {
16653 unreachable!()
16654 }
16655 }
16656 14 => {
16657 #[allow(irrefutable_let_patterns)]
16658 if let AllTypesXunion::HandleMember(_) = self {
16659 } else {
16661 *self = AllTypesXunion::HandleMember(
16663 fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
16664 );
16665 }
16666 #[allow(irrefutable_let_patterns)]
16667 if let AllTypesXunion::HandleMember(ref mut val) = self {
16668 fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16669 } else {
16670 unreachable!()
16671 }
16672 }
16673 15 => {
16674 #[allow(irrefutable_let_patterns)]
16675 if let AllTypesXunion::StringMember(_) = self {
16676 } else {
16678 *self = AllTypesXunion::StringMember(fidl::new_empty!(
16680 fidl::encoding::UnboundedString,
16681 fidl::encoding::DefaultFuchsiaResourceDialect
16682 ));
16683 }
16684 #[allow(irrefutable_let_patterns)]
16685 if let AllTypesXunion::StringMember(ref mut val) = self {
16686 fidl::decode!(
16687 fidl::encoding::UnboundedString,
16688 fidl::encoding::DefaultFuchsiaResourceDialect,
16689 val,
16690 decoder,
16691 _inner_offset,
16692 depth
16693 )?;
16694 } else {
16695 unreachable!()
16696 }
16697 }
16698 16 => {
16699 #[allow(irrefutable_let_patterns)]
16700 if let AllTypesXunion::StructMember(_) = self {
16701 } else {
16703 *self = AllTypesXunion::StructMember(fidl::new_empty!(
16705 ThisIsAStruct,
16706 fidl::encoding::DefaultFuchsiaResourceDialect
16707 ));
16708 }
16709 #[allow(irrefutable_let_patterns)]
16710 if let AllTypesXunion::StructMember(ref mut val) = self {
16711 fidl::decode!(
16712 ThisIsAStruct,
16713 fidl::encoding::DefaultFuchsiaResourceDialect,
16714 val,
16715 decoder,
16716 _inner_offset,
16717 depth
16718 )?;
16719 } else {
16720 unreachable!()
16721 }
16722 }
16723 17 => {
16724 #[allow(irrefutable_let_patterns)]
16725 if let AllTypesXunion::UnionMember(_) = self {
16726 } else {
16728 *self = AllTypesXunion::UnionMember(fidl::new_empty!(
16730 ThisIsAUnion,
16731 fidl::encoding::DefaultFuchsiaResourceDialect
16732 ));
16733 }
16734 #[allow(irrefutable_let_patterns)]
16735 if let AllTypesXunion::UnionMember(ref mut val) = self {
16736 fidl::decode!(
16737 ThisIsAUnion,
16738 fidl::encoding::DefaultFuchsiaResourceDialect,
16739 val,
16740 decoder,
16741 _inner_offset,
16742 depth
16743 )?;
16744 } else {
16745 unreachable!()
16746 }
16747 }
16748 18 => {
16749 #[allow(irrefutable_let_patterns)]
16750 if let AllTypesXunion::ArrayMember(_) = self {
16751 } else {
16753 *self = AllTypesXunion::ArrayMember(
16755 fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
16756 );
16757 }
16758 #[allow(irrefutable_let_patterns)]
16759 if let AllTypesXunion::ArrayMember(ref mut val) = self {
16760 fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16761 } else {
16762 unreachable!()
16763 }
16764 }
16765 19 => {
16766 #[allow(irrefutable_let_patterns)]
16767 if let AllTypesXunion::VectorMember(_) = self {
16768 } else {
16770 *self = AllTypesXunion::VectorMember(fidl::new_empty!(
16772 fidl::encoding::UnboundedVector<u32>,
16773 fidl::encoding::DefaultFuchsiaResourceDialect
16774 ));
16775 }
16776 #[allow(irrefutable_let_patterns)]
16777 if let AllTypesXunion::VectorMember(ref mut val) = self {
16778 fidl::decode!(
16779 fidl::encoding::UnboundedVector<u32>,
16780 fidl::encoding::DefaultFuchsiaResourceDialect,
16781 val,
16782 decoder,
16783 _inner_offset,
16784 depth
16785 )?;
16786 } else {
16787 unreachable!()
16788 }
16789 }
16790 20 => {
16791 #[allow(irrefutable_let_patterns)]
16792 if let AllTypesXunion::TableMember(_) = self {
16793 } else {
16795 *self = AllTypesXunion::TableMember(fidl::new_empty!(
16797 ThisIsATable,
16798 fidl::encoding::DefaultFuchsiaResourceDialect
16799 ));
16800 }
16801 #[allow(irrefutable_let_patterns)]
16802 if let AllTypesXunion::TableMember(ref mut val) = self {
16803 fidl::decode!(
16804 ThisIsATable,
16805 fidl::encoding::DefaultFuchsiaResourceDialect,
16806 val,
16807 decoder,
16808 _inner_offset,
16809 depth
16810 )?;
16811 } else {
16812 unreachable!()
16813 }
16814 }
16815 21 => {
16816 #[allow(irrefutable_let_patterns)]
16817 if let AllTypesXunion::XunionMember(_) = self {
16818 } else {
16820 *self = AllTypesXunion::XunionMember(fidl::new_empty!(
16822 ThisIsAXunion,
16823 fidl::encoding::DefaultFuchsiaResourceDialect
16824 ));
16825 }
16826 #[allow(irrefutable_let_patterns)]
16827 if let AllTypesXunion::XunionMember(ref mut val) = self {
16828 fidl::decode!(
16829 ThisIsAXunion,
16830 fidl::encoding::DefaultFuchsiaResourceDialect,
16831 val,
16832 decoder,
16833 _inner_offset,
16834 depth
16835 )?;
16836 } else {
16837 unreachable!()
16838 }
16839 }
16840 #[allow(deprecated)]
16841 ordinal => {
16842 for _ in 0..num_handles {
16843 decoder.drop_next_handle()?;
16844 }
16845 *self = AllTypesXunion::__SourceBreaking { unknown_ordinal: ordinal };
16846 }
16847 }
16848 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16850 }
16851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16853 }
16854 Ok(())
16855 }
16856 }
16857}