fidl_fuchsia_diagnostics_types/
fidl_fuchsia_diagnostics_types.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_diagnostics_types__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct ComponentDiagnostics {
16    pub tasks: Option<ComponentTasks>,
17    #[doc(hidden)]
18    pub __source_breaking: fidl::marker::SourceBreaking,
19}
20
21impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentDiagnostics {}
22
23#[derive(Debug, Default, PartialEq)]
24pub struct ComponentTasks {
25    pub component_task: Option<Task>,
26    pub parent_task: Option<Task>,
27    #[doc(hidden)]
28    pub __source_breaking: fidl::marker::SourceBreaking,
29}
30
31impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ComponentTasks {}
32
33#[derive(Debug)]
34pub enum Task {
35    Job(fidl::Job),
36    Process(fidl::Process),
37    Thread(fidl::Thread),
38    #[doc(hidden)]
39    __SourceBreaking {
40        unknown_ordinal: u64,
41    },
42}
43
44/// Pattern that matches an unknown `Task` member.
45#[macro_export]
46macro_rules! TaskUnknown {
47    () => {
48        _
49    };
50}
51
52// Custom PartialEq so that unknown variants are not equal to themselves.
53impl PartialEq for Task {
54    fn eq(&self, other: &Self) -> bool {
55        match (self, other) {
56            (Self::Job(x), Self::Job(y)) => *x == *y,
57            (Self::Process(x), Self::Process(y)) => *x == *y,
58            (Self::Thread(x), Self::Thread(y)) => *x == *y,
59            _ => false,
60        }
61    }
62}
63
64impl Task {
65    #[inline]
66    pub fn ordinal(&self) -> u64 {
67        match *self {
68            Self::Job(_) => 1,
69            Self::Process(_) => 2,
70            Self::Thread(_) => 3,
71            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
72        }
73    }
74
75    #[inline]
76    pub fn unknown_variant_for_testing() -> Self {
77        Self::__SourceBreaking { unknown_ordinal: 0 }
78    }
79
80    #[inline]
81    pub fn is_unknown(&self) -> bool {
82        match self {
83            Self::__SourceBreaking { .. } => true,
84            _ => false,
85        }
86    }
87}
88
89impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Task {}
90
91mod internal {
92    use super::*;
93
94    impl ComponentDiagnostics {
95        #[inline(always)]
96        fn max_ordinal_present(&self) -> u64 {
97            if let Some(_) = self.tasks {
98                return 1;
99            }
100            0
101        }
102    }
103
104    impl fidl::encoding::ResourceTypeMarker for ComponentDiagnostics {
105        type Borrowed<'a> = &'a mut Self;
106        fn take_or_borrow<'a>(
107            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
108        ) -> Self::Borrowed<'a> {
109            value
110        }
111    }
112
113    unsafe impl fidl::encoding::TypeMarker for ComponentDiagnostics {
114        type Owned = Self;
115
116        #[inline(always)]
117        fn inline_align(_context: fidl::encoding::Context) -> usize {
118            8
119        }
120
121        #[inline(always)]
122        fn inline_size(_context: fidl::encoding::Context) -> usize {
123            16
124        }
125    }
126
127    unsafe impl
128        fidl::encoding::Encode<ComponentDiagnostics, fidl::encoding::DefaultFuchsiaResourceDialect>
129        for &mut ComponentDiagnostics
130    {
131        unsafe fn encode(
132            self,
133            encoder: &mut fidl::encoding::Encoder<
134                '_,
135                fidl::encoding::DefaultFuchsiaResourceDialect,
136            >,
137            offset: usize,
138            mut depth: fidl::encoding::Depth,
139        ) -> fidl::Result<()> {
140            encoder.debug_check_bounds::<ComponentDiagnostics>(offset);
141            // Vector header
142            let max_ordinal: u64 = self.max_ordinal_present();
143            encoder.write_num(max_ordinal, offset);
144            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
145            // Calling encoder.out_of_line_offset(0) is not allowed.
146            if max_ordinal == 0 {
147                return Ok(());
148            }
149            depth.increment()?;
150            let envelope_size = 8;
151            let bytes_len = max_ordinal as usize * envelope_size;
152            #[allow(unused_variables)]
153            let offset = encoder.out_of_line_offset(bytes_len);
154            let mut _prev_end_offset: usize = 0;
155            if 1 > max_ordinal {
156                return Ok(());
157            }
158
159            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
160            // are envelope_size bytes.
161            let cur_offset: usize = (1 - 1) * envelope_size;
162
163            // Zero reserved fields.
164            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
165
166            // Safety:
167            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
168            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
169            //   envelope_size bytes, there is always sufficient room.
170            fidl::encoding::encode_in_envelope_optional::<
171                ComponentTasks,
172                fidl::encoding::DefaultFuchsiaResourceDialect,
173            >(
174                self.tasks
175                    .as_mut()
176                    .map(<ComponentTasks as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
177                encoder,
178                offset + cur_offset,
179                depth,
180            )?;
181
182            _prev_end_offset = cur_offset + envelope_size;
183
184            Ok(())
185        }
186    }
187
188    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
189        for ComponentDiagnostics
190    {
191        #[inline(always)]
192        fn new_empty() -> Self {
193            Self::default()
194        }
195
196        unsafe fn decode(
197            &mut self,
198            decoder: &mut fidl::encoding::Decoder<
199                '_,
200                fidl::encoding::DefaultFuchsiaResourceDialect,
201            >,
202            offset: usize,
203            mut depth: fidl::encoding::Depth,
204        ) -> fidl::Result<()> {
205            decoder.debug_check_bounds::<Self>(offset);
206            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
207                None => return Err(fidl::Error::NotNullable),
208                Some(len) => len,
209            };
210            // Calling decoder.out_of_line_offset(0) is not allowed.
211            if len == 0 {
212                return Ok(());
213            };
214            depth.increment()?;
215            let envelope_size = 8;
216            let bytes_len = len * envelope_size;
217            let offset = decoder.out_of_line_offset(bytes_len)?;
218            // Decode the envelope for each type.
219            let mut _next_ordinal_to_read = 0;
220            let mut next_offset = offset;
221            let end_offset = offset + bytes_len;
222            _next_ordinal_to_read += 1;
223            if next_offset >= end_offset {
224                return Ok(());
225            }
226
227            // Decode unknown envelopes for gaps in ordinals.
228            while _next_ordinal_to_read < 1 {
229                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
230                _next_ordinal_to_read += 1;
231                next_offset += envelope_size;
232            }
233
234            let next_out_of_line = decoder.next_out_of_line();
235            let handles_before = decoder.remaining_handles();
236            if let Some((inlined, num_bytes, num_handles)) =
237                fidl::encoding::decode_envelope_header(decoder, next_offset)?
238            {
239                let member_inline_size =
240                    <ComponentTasks as fidl::encoding::TypeMarker>::inline_size(decoder.context);
241                if inlined != (member_inline_size <= 4) {
242                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
243                }
244                let inner_offset;
245                let mut inner_depth = depth.clone();
246                if inlined {
247                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
248                    inner_offset = next_offset;
249                } else {
250                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
251                    inner_depth.increment()?;
252                }
253                let val_ref = self.tasks.get_or_insert_with(|| {
254                    fidl::new_empty!(ComponentTasks, fidl::encoding::DefaultFuchsiaResourceDialect)
255                });
256                fidl::decode!(
257                    ComponentTasks,
258                    fidl::encoding::DefaultFuchsiaResourceDialect,
259                    val_ref,
260                    decoder,
261                    inner_offset,
262                    inner_depth
263                )?;
264                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
265                {
266                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
267                }
268                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
269                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
270                }
271            }
272
273            next_offset += envelope_size;
274
275            // Decode the remaining unknown envelopes.
276            while next_offset < end_offset {
277                _next_ordinal_to_read += 1;
278                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
279                next_offset += envelope_size;
280            }
281
282            Ok(())
283        }
284    }
285
286    impl ComponentTasks {
287        #[inline(always)]
288        fn max_ordinal_present(&self) -> u64 {
289            if let Some(_) = self.parent_task {
290                return 2;
291            }
292            if let Some(_) = self.component_task {
293                return 1;
294            }
295            0
296        }
297    }
298
299    impl fidl::encoding::ResourceTypeMarker for ComponentTasks {
300        type Borrowed<'a> = &'a mut Self;
301        fn take_or_borrow<'a>(
302            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
303        ) -> Self::Borrowed<'a> {
304            value
305        }
306    }
307
308    unsafe impl fidl::encoding::TypeMarker for ComponentTasks {
309        type Owned = Self;
310
311        #[inline(always)]
312        fn inline_align(_context: fidl::encoding::Context) -> usize {
313            8
314        }
315
316        #[inline(always)]
317        fn inline_size(_context: fidl::encoding::Context) -> usize {
318            16
319        }
320    }
321
322    unsafe impl
323        fidl::encoding::Encode<ComponentTasks, fidl::encoding::DefaultFuchsiaResourceDialect>
324        for &mut ComponentTasks
325    {
326        unsafe fn encode(
327            self,
328            encoder: &mut fidl::encoding::Encoder<
329                '_,
330                fidl::encoding::DefaultFuchsiaResourceDialect,
331            >,
332            offset: usize,
333            mut depth: fidl::encoding::Depth,
334        ) -> fidl::Result<()> {
335            encoder.debug_check_bounds::<ComponentTasks>(offset);
336            // Vector header
337            let max_ordinal: u64 = self.max_ordinal_present();
338            encoder.write_num(max_ordinal, offset);
339            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
340            // Calling encoder.out_of_line_offset(0) is not allowed.
341            if max_ordinal == 0 {
342                return Ok(());
343            }
344            depth.increment()?;
345            let envelope_size = 8;
346            let bytes_len = max_ordinal as usize * envelope_size;
347            #[allow(unused_variables)]
348            let offset = encoder.out_of_line_offset(bytes_len);
349            let mut _prev_end_offset: usize = 0;
350            if 1 > max_ordinal {
351                return Ok(());
352            }
353
354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
355            // are envelope_size bytes.
356            let cur_offset: usize = (1 - 1) * envelope_size;
357
358            // Zero reserved fields.
359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
360
361            // Safety:
362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
364            //   envelope_size bytes, there is always sufficient room.
365            fidl::encoding::encode_in_envelope_optional::<
366                Task,
367                fidl::encoding::DefaultFuchsiaResourceDialect,
368            >(
369                self.component_task
370                    .as_mut()
371                    .map(<Task as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
372                encoder,
373                offset + cur_offset,
374                depth,
375            )?;
376
377            _prev_end_offset = cur_offset + envelope_size;
378            if 2 > max_ordinal {
379                return Ok(());
380            }
381
382            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
383            // are envelope_size bytes.
384            let cur_offset: usize = (2 - 1) * envelope_size;
385
386            // Zero reserved fields.
387            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
388
389            // Safety:
390            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
391            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
392            //   envelope_size bytes, there is always sufficient room.
393            fidl::encoding::encode_in_envelope_optional::<
394                Task,
395                fidl::encoding::DefaultFuchsiaResourceDialect,
396            >(
397                self.parent_task
398                    .as_mut()
399                    .map(<Task as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
400                encoder,
401                offset + cur_offset,
402                depth,
403            )?;
404
405            _prev_end_offset = cur_offset + envelope_size;
406
407            Ok(())
408        }
409    }
410
411    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
412        for ComponentTasks
413    {
414        #[inline(always)]
415        fn new_empty() -> Self {
416            Self::default()
417        }
418
419        unsafe fn decode(
420            &mut self,
421            decoder: &mut fidl::encoding::Decoder<
422                '_,
423                fidl::encoding::DefaultFuchsiaResourceDialect,
424            >,
425            offset: usize,
426            mut depth: fidl::encoding::Depth,
427        ) -> fidl::Result<()> {
428            decoder.debug_check_bounds::<Self>(offset);
429            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
430                None => return Err(fidl::Error::NotNullable),
431                Some(len) => len,
432            };
433            // Calling decoder.out_of_line_offset(0) is not allowed.
434            if len == 0 {
435                return Ok(());
436            };
437            depth.increment()?;
438            let envelope_size = 8;
439            let bytes_len = len * envelope_size;
440            let offset = decoder.out_of_line_offset(bytes_len)?;
441            // Decode the envelope for each type.
442            let mut _next_ordinal_to_read = 0;
443            let mut next_offset = offset;
444            let end_offset = offset + bytes_len;
445            _next_ordinal_to_read += 1;
446            if next_offset >= end_offset {
447                return Ok(());
448            }
449
450            // Decode unknown envelopes for gaps in ordinals.
451            while _next_ordinal_to_read < 1 {
452                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
453                _next_ordinal_to_read += 1;
454                next_offset += envelope_size;
455            }
456
457            let next_out_of_line = decoder.next_out_of_line();
458            let handles_before = decoder.remaining_handles();
459            if let Some((inlined, num_bytes, num_handles)) =
460                fidl::encoding::decode_envelope_header(decoder, next_offset)?
461            {
462                let member_inline_size =
463                    <Task as fidl::encoding::TypeMarker>::inline_size(decoder.context);
464                if inlined != (member_inline_size <= 4) {
465                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
466                }
467                let inner_offset;
468                let mut inner_depth = depth.clone();
469                if inlined {
470                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
471                    inner_offset = next_offset;
472                } else {
473                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
474                    inner_depth.increment()?;
475                }
476                let val_ref = self.component_task.get_or_insert_with(|| {
477                    fidl::new_empty!(Task, fidl::encoding::DefaultFuchsiaResourceDialect)
478                });
479                fidl::decode!(
480                    Task,
481                    fidl::encoding::DefaultFuchsiaResourceDialect,
482                    val_ref,
483                    decoder,
484                    inner_offset,
485                    inner_depth
486                )?;
487                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
488                {
489                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
490                }
491                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
492                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
493                }
494            }
495
496            next_offset += envelope_size;
497            _next_ordinal_to_read += 1;
498            if next_offset >= end_offset {
499                return Ok(());
500            }
501
502            // Decode unknown envelopes for gaps in ordinals.
503            while _next_ordinal_to_read < 2 {
504                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
505                _next_ordinal_to_read += 1;
506                next_offset += envelope_size;
507            }
508
509            let next_out_of_line = decoder.next_out_of_line();
510            let handles_before = decoder.remaining_handles();
511            if let Some((inlined, num_bytes, num_handles)) =
512                fidl::encoding::decode_envelope_header(decoder, next_offset)?
513            {
514                let member_inline_size =
515                    <Task as fidl::encoding::TypeMarker>::inline_size(decoder.context);
516                if inlined != (member_inline_size <= 4) {
517                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
518                }
519                let inner_offset;
520                let mut inner_depth = depth.clone();
521                if inlined {
522                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
523                    inner_offset = next_offset;
524                } else {
525                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
526                    inner_depth.increment()?;
527                }
528                let val_ref = self.parent_task.get_or_insert_with(|| {
529                    fidl::new_empty!(Task, fidl::encoding::DefaultFuchsiaResourceDialect)
530                });
531                fidl::decode!(
532                    Task,
533                    fidl::encoding::DefaultFuchsiaResourceDialect,
534                    val_ref,
535                    decoder,
536                    inner_offset,
537                    inner_depth
538                )?;
539                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
540                {
541                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
542                }
543                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
544                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
545                }
546            }
547
548            next_offset += envelope_size;
549
550            // Decode the remaining unknown envelopes.
551            while next_offset < end_offset {
552                _next_ordinal_to_read += 1;
553                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
554                next_offset += envelope_size;
555            }
556
557            Ok(())
558        }
559    }
560
561    impl fidl::encoding::ResourceTypeMarker for Task {
562        type Borrowed<'a> = &'a mut Self;
563        fn take_or_borrow<'a>(
564            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
565        ) -> Self::Borrowed<'a> {
566            value
567        }
568    }
569
570    unsafe impl fidl::encoding::TypeMarker for Task {
571        type Owned = Self;
572
573        #[inline(always)]
574        fn inline_align(_context: fidl::encoding::Context) -> usize {
575            8
576        }
577
578        #[inline(always)]
579        fn inline_size(_context: fidl::encoding::Context) -> usize {
580            16
581        }
582    }
583
584    unsafe impl fidl::encoding::Encode<Task, fidl::encoding::DefaultFuchsiaResourceDialect>
585        for &mut Task
586    {
587        #[inline]
588        unsafe fn encode(
589            self,
590            encoder: &mut fidl::encoding::Encoder<
591                '_,
592                fidl::encoding::DefaultFuchsiaResourceDialect,
593            >,
594            offset: usize,
595            _depth: fidl::encoding::Depth,
596        ) -> fidl::Result<()> {
597            encoder.debug_check_bounds::<Task>(offset);
598            encoder.write_num::<u64>(self.ordinal(), offset);
599            match self {
600                Task::Job(ref mut val) => fidl::encoding::encode_in_envelope::<
601                    fidl::encoding::HandleType<
602                        fidl::Job,
603                        { fidl::ObjectType::JOB.into_raw() },
604                        2147483648,
605                    >,
606                    fidl::encoding::DefaultFuchsiaResourceDialect,
607                >(
608                    <fidl::encoding::HandleType<
609                        fidl::Job,
610                        { fidl::ObjectType::JOB.into_raw() },
611                        2147483648,
612                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
613                        val
614                    ),
615                    encoder,
616                    offset + 8,
617                    _depth,
618                ),
619                Task::Process(ref mut val) => fidl::encoding::encode_in_envelope::<
620                    fidl::encoding::HandleType<
621                        fidl::Process,
622                        { fidl::ObjectType::PROCESS.into_raw() },
623                        2147483648,
624                    >,
625                    fidl::encoding::DefaultFuchsiaResourceDialect,
626                >(
627                    <fidl::encoding::HandleType<
628                        fidl::Process,
629                        { fidl::ObjectType::PROCESS.into_raw() },
630                        2147483648,
631                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
632                        val
633                    ),
634                    encoder,
635                    offset + 8,
636                    _depth,
637                ),
638                Task::Thread(ref mut val) => fidl::encoding::encode_in_envelope::<
639                    fidl::encoding::HandleType<
640                        fidl::Thread,
641                        { fidl::ObjectType::THREAD.into_raw() },
642                        2147483648,
643                    >,
644                    fidl::encoding::DefaultFuchsiaResourceDialect,
645                >(
646                    <fidl::encoding::HandleType<
647                        fidl::Thread,
648                        { fidl::ObjectType::THREAD.into_raw() },
649                        2147483648,
650                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
651                        val
652                    ),
653                    encoder,
654                    offset + 8,
655                    _depth,
656                ),
657                Task::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
658            }
659        }
660    }
661
662    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Task {
663        #[inline(always)]
664        fn new_empty() -> Self {
665            Self::__SourceBreaking { unknown_ordinal: 0 }
666        }
667
668        #[inline]
669        unsafe fn decode(
670            &mut self,
671            decoder: &mut fidl::encoding::Decoder<
672                '_,
673                fidl::encoding::DefaultFuchsiaResourceDialect,
674            >,
675            offset: usize,
676            mut depth: fidl::encoding::Depth,
677        ) -> fidl::Result<()> {
678            decoder.debug_check_bounds::<Self>(offset);
679            #[allow(unused_variables)]
680            let next_out_of_line = decoder.next_out_of_line();
681            let handles_before = decoder.remaining_handles();
682            let (ordinal, inlined, num_bytes, num_handles) =
683                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
684
685            let member_inline_size = match ordinal {
686                1 => <fidl::encoding::HandleType<
687                    fidl::Job,
688                    { fidl::ObjectType::JOB.into_raw() },
689                    2147483648,
690                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
691                2 => <fidl::encoding::HandleType<
692                    fidl::Process,
693                    { fidl::ObjectType::PROCESS.into_raw() },
694                    2147483648,
695                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
696                3 => <fidl::encoding::HandleType<
697                    fidl::Thread,
698                    { fidl::ObjectType::THREAD.into_raw() },
699                    2147483648,
700                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
701                0 => return Err(fidl::Error::UnknownUnionTag),
702                _ => num_bytes as usize,
703            };
704
705            if inlined != (member_inline_size <= 4) {
706                return Err(fidl::Error::InvalidInlineBitInEnvelope);
707            }
708            let _inner_offset;
709            if inlined {
710                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
711                _inner_offset = offset + 8;
712            } else {
713                depth.increment()?;
714                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
715            }
716            match ordinal {
717                1 => {
718                    #[allow(irrefutable_let_patterns)]
719                    if let Task::Job(_) = self {
720                        // Do nothing, read the value into the object
721                    } else {
722                        // Initialize `self` to the right variant
723                        *self = Task::Job(
724                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
725                        );
726                    }
727                    #[allow(irrefutable_let_patterns)]
728                    if let Task::Job(ref mut val) = self {
729                        fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
730                    } else {
731                        unreachable!()
732                    }
733                }
734                2 => {
735                    #[allow(irrefutable_let_patterns)]
736                    if let Task::Process(_) = self {
737                        // Do nothing, read the value into the object
738                    } else {
739                        // Initialize `self` to the right variant
740                        *self = Task::Process(
741                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
742                        );
743                    }
744                    #[allow(irrefutable_let_patterns)]
745                    if let Task::Process(ref mut val) = self {
746                        fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
747                    } else {
748                        unreachable!()
749                    }
750                }
751                3 => {
752                    #[allow(irrefutable_let_patterns)]
753                    if let Task::Thread(_) = self {
754                        // Do nothing, read the value into the object
755                    } else {
756                        // Initialize `self` to the right variant
757                        *self = Task::Thread(
758                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
759                        );
760                    }
761                    #[allow(irrefutable_let_patterns)]
762                    if let Task::Thread(ref mut val) = self {
763                        fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
764                    } else {
765                        unreachable!()
766                    }
767                }
768                #[allow(deprecated)]
769                ordinal => {
770                    for _ in 0..num_handles {
771                        decoder.drop_next_handle()?;
772                    }
773                    *self = Task::__SourceBreaking { unknown_ordinal: ordinal };
774                }
775            }
776            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
777                return Err(fidl::Error::InvalidNumBytesInEnvelope);
778            }
779            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
780                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
781            }
782            Ok(())
783        }
784    }
785}
fidl_fuchsia_diagnostics_types/fidl_fuchsia_diagnostics_types.rs

fidl_fuchsia_diagnostics_types/
fidl_fuchsia_diagnostics_types.rs
