fidl_fuchsia_inspect_deprecated__common/
fidl_fuchsia_inspect_deprecated__common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
12pub struct InspectListChildrenResponse {
13    pub children_names: Vec<String>,
14}
15
16impl fidl::Persistable for InspectListChildrenResponse {}
17
18#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
19pub struct InspectOpenChildResponse {
20    pub success: bool,
21}
22
23impl fidl::Persistable for InspectOpenChildResponse {}
24
25#[derive(Clone, Debug, PartialEq, PartialOrd)]
26pub struct InspectReadDataResponse {
27    pub object: Object,
28}
29
30impl fidl::Persistable for InspectReadDataResponse {}
31
32#[derive(Clone, Debug, PartialEq, PartialOrd)]
33pub struct Metric {
34    pub key: String,
35    pub value: MetricValue,
36}
37
38impl fidl::Persistable for Metric {}
39
40#[derive(Clone, Debug, PartialEq, PartialOrd)]
41pub struct Object {
42    pub name: String,
43    pub properties: Vec<Property>,
44    pub metrics: Vec<Metric>,
45}
46
47impl fidl::Persistable for Object {}
48
49#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
50pub struct Property {
51    pub key: String,
52    pub value: PropertyValue,
53}
54
55impl fidl::Persistable for Property {}
56
57#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
58pub enum MetricValue {
59    IntValue(i64),
60    UintValue(u64),
61    DoubleValue(f64),
62}
63
64impl MetricValue {
65    #[inline]
66    pub fn ordinal(&self) -> u64 {
67        match *self {
68            Self::IntValue(_) => 1,
69            Self::UintValue(_) => 2,
70            Self::DoubleValue(_) => 3,
71        }
72    }
73}
74
75impl fidl::Persistable for MetricValue {}
76
77#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
78pub enum PropertyValue {
79    Str(String),
80    Bytes(Vec<u8>),
81}
82
83impl PropertyValue {
84    #[inline]
85    pub fn ordinal(&self) -> u64 {
86        match *self {
87            Self::Str(_) => 1,
88            Self::Bytes(_) => 2,
89        }
90    }
91}
92
93impl fidl::Persistable for PropertyValue {}
94
95pub mod inspect_ordinals {
96    pub const READ_DATA: u64 = 0x1c6778e57fcfa9e1;
97    pub const LIST_CHILDREN: u64 = 0x463fdc024dc40611;
98    pub const OPEN_CHILD: u64 = 0x30513125b65c866a;
99}
100
101mod internal {
102    use super::*;
103
104    impl fidl::encoding::ValueTypeMarker for InspectListChildrenResponse {
105        type Borrowed<'a> = &'a Self;
106        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
107            value
108        }
109    }
110
111    unsafe impl fidl::encoding::TypeMarker for InspectListChildrenResponse {
112        type Owned = Self;
113
114        #[inline(always)]
115        fn inline_align(_context: fidl::encoding::Context) -> usize {
116            8
117        }
118
119        #[inline(always)]
120        fn inline_size(_context: fidl::encoding::Context) -> usize {
121            16
122        }
123    }
124
125    unsafe impl<D: fidl::encoding::ResourceDialect>
126        fidl::encoding::Encode<InspectListChildrenResponse, D> for &InspectListChildrenResponse
127    {
128        #[inline]
129        unsafe fn encode(
130            self,
131            encoder: &mut fidl::encoding::Encoder<'_, D>,
132            offset: usize,
133            _depth: fidl::encoding::Depth,
134        ) -> fidl::Result<()> {
135            encoder.debug_check_bounds::<InspectListChildrenResponse>(offset);
136            // Delegate to tuple encoding.
137            fidl::encoding::Encode::<InspectListChildrenResponse, D>::encode(
138                (
139                    <fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.children_names),
140                ),
141                encoder, offset, _depth
142            )
143        }
144    }
145    unsafe impl<
146            D: fidl::encoding::ResourceDialect,
147            T0: fidl::encoding::Encode<
148                fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
149                D,
150            >,
151        > fidl::encoding::Encode<InspectListChildrenResponse, D> for (T0,)
152    {
153        #[inline]
154        unsafe fn encode(
155            self,
156            encoder: &mut fidl::encoding::Encoder<'_, D>,
157            offset: usize,
158            depth: fidl::encoding::Depth,
159        ) -> fidl::Result<()> {
160            encoder.debug_check_bounds::<InspectListChildrenResponse>(offset);
161            // Zero out padding regions. There's no need to apply masks
162            // because the unmasked parts will be overwritten by fields.
163            // Write the fields.
164            self.0.encode(encoder, offset + 0, depth)?;
165            Ok(())
166        }
167    }
168
169    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
170        for InspectListChildrenResponse
171    {
172        #[inline(always)]
173        fn new_empty() -> Self {
174            Self {
175                children_names: fidl::new_empty!(
176                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
177                    D
178                ),
179            }
180        }
181
182        #[inline]
183        unsafe fn decode(
184            &mut self,
185            decoder: &mut fidl::encoding::Decoder<'_, D>,
186            offset: usize,
187            _depth: fidl::encoding::Depth,
188        ) -> fidl::Result<()> {
189            decoder.debug_check_bounds::<Self>(offset);
190            // Verify that padding bytes are zero.
191            fidl::decode!(
192                fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
193                D,
194                &mut self.children_names,
195                decoder,
196                offset + 0,
197                _depth
198            )?;
199            Ok(())
200        }
201    }
202
203    impl fidl::encoding::ValueTypeMarker for InspectOpenChildResponse {
204        type Borrowed<'a> = &'a Self;
205        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
206            value
207        }
208    }
209
210    unsafe impl fidl::encoding::TypeMarker for InspectOpenChildResponse {
211        type Owned = Self;
212
213        #[inline(always)]
214        fn inline_align(_context: fidl::encoding::Context) -> usize {
215            1
216        }
217
218        #[inline(always)]
219        fn inline_size(_context: fidl::encoding::Context) -> usize {
220            1
221        }
222    }
223
224    unsafe impl<D: fidl::encoding::ResourceDialect>
225        fidl::encoding::Encode<InspectOpenChildResponse, D> for &InspectOpenChildResponse
226    {
227        #[inline]
228        unsafe fn encode(
229            self,
230            encoder: &mut fidl::encoding::Encoder<'_, D>,
231            offset: usize,
232            _depth: fidl::encoding::Depth,
233        ) -> fidl::Result<()> {
234            encoder.debug_check_bounds::<InspectOpenChildResponse>(offset);
235            // Delegate to tuple encoding.
236            fidl::encoding::Encode::<InspectOpenChildResponse, D>::encode(
237                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.success),),
238                encoder,
239                offset,
240                _depth,
241            )
242        }
243    }
244    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
245        fidl::encoding::Encode<InspectOpenChildResponse, D> for (T0,)
246    {
247        #[inline]
248        unsafe fn encode(
249            self,
250            encoder: &mut fidl::encoding::Encoder<'_, D>,
251            offset: usize,
252            depth: fidl::encoding::Depth,
253        ) -> fidl::Result<()> {
254            encoder.debug_check_bounds::<InspectOpenChildResponse>(offset);
255            // Zero out padding regions. There's no need to apply masks
256            // because the unmasked parts will be overwritten by fields.
257            // Write the fields.
258            self.0.encode(encoder, offset + 0, depth)?;
259            Ok(())
260        }
261    }
262
263    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
264        for InspectOpenChildResponse
265    {
266        #[inline(always)]
267        fn new_empty() -> Self {
268            Self { success: fidl::new_empty!(bool, D) }
269        }
270
271        #[inline]
272        unsafe fn decode(
273            &mut self,
274            decoder: &mut fidl::encoding::Decoder<'_, D>,
275            offset: usize,
276            _depth: fidl::encoding::Depth,
277        ) -> fidl::Result<()> {
278            decoder.debug_check_bounds::<Self>(offset);
279            // Verify that padding bytes are zero.
280            fidl::decode!(bool, D, &mut self.success, decoder, offset + 0, _depth)?;
281            Ok(())
282        }
283    }
284
285    impl fidl::encoding::ValueTypeMarker for InspectReadDataResponse {
286        type Borrowed<'a> = &'a Self;
287        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
288            value
289        }
290    }
291
292    unsafe impl fidl::encoding::TypeMarker for InspectReadDataResponse {
293        type Owned = Self;
294
295        #[inline(always)]
296        fn inline_align(_context: fidl::encoding::Context) -> usize {
297            8
298        }
299
300        #[inline(always)]
301        fn inline_size(_context: fidl::encoding::Context) -> usize {
302            48
303        }
304    }
305
306    unsafe impl<D: fidl::encoding::ResourceDialect>
307        fidl::encoding::Encode<InspectReadDataResponse, D> for &InspectReadDataResponse
308    {
309        #[inline]
310        unsafe fn encode(
311            self,
312            encoder: &mut fidl::encoding::Encoder<'_, D>,
313            offset: usize,
314            _depth: fidl::encoding::Depth,
315        ) -> fidl::Result<()> {
316            encoder.debug_check_bounds::<InspectReadDataResponse>(offset);
317            // Delegate to tuple encoding.
318            fidl::encoding::Encode::<InspectReadDataResponse, D>::encode(
319                (<Object as fidl::encoding::ValueTypeMarker>::borrow(&self.object),),
320                encoder,
321                offset,
322                _depth,
323            )
324        }
325    }
326    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Object, D>>
327        fidl::encoding::Encode<InspectReadDataResponse, D> for (T0,)
328    {
329        #[inline]
330        unsafe fn encode(
331            self,
332            encoder: &mut fidl::encoding::Encoder<'_, D>,
333            offset: usize,
334            depth: fidl::encoding::Depth,
335        ) -> fidl::Result<()> {
336            encoder.debug_check_bounds::<InspectReadDataResponse>(offset);
337            // Zero out padding regions. There's no need to apply masks
338            // because the unmasked parts will be overwritten by fields.
339            // Write the fields.
340            self.0.encode(encoder, offset + 0, depth)?;
341            Ok(())
342        }
343    }
344
345    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
346        for InspectReadDataResponse
347    {
348        #[inline(always)]
349        fn new_empty() -> Self {
350            Self { object: fidl::new_empty!(Object, D) }
351        }
352
353        #[inline]
354        unsafe fn decode(
355            &mut self,
356            decoder: &mut fidl::encoding::Decoder<'_, D>,
357            offset: usize,
358            _depth: fidl::encoding::Depth,
359        ) -> fidl::Result<()> {
360            decoder.debug_check_bounds::<Self>(offset);
361            // Verify that padding bytes are zero.
362            fidl::decode!(Object, D, &mut self.object, decoder, offset + 0, _depth)?;
363            Ok(())
364        }
365    }
366
367    impl fidl::encoding::ValueTypeMarker for Metric {
368        type Borrowed<'a> = &'a Self;
369        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
370            value
371        }
372    }
373
374    unsafe impl fidl::encoding::TypeMarker for Metric {
375        type Owned = Self;
376
377        #[inline(always)]
378        fn inline_align(_context: fidl::encoding::Context) -> usize {
379            8
380        }
381
382        #[inline(always)]
383        fn inline_size(_context: fidl::encoding::Context) -> usize {
384            32
385        }
386    }
387
388    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metric, D> for &Metric {
389        #[inline]
390        unsafe fn encode(
391            self,
392            encoder: &mut fidl::encoding::Encoder<'_, D>,
393            offset: usize,
394            _depth: fidl::encoding::Depth,
395        ) -> fidl::Result<()> {
396            encoder.debug_check_bounds::<Metric>(offset);
397            // Delegate to tuple encoding.
398            fidl::encoding::Encode::<Metric, D>::encode(
399                (
400                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
401                        &self.key,
402                    ),
403                    <MetricValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
404                ),
405                encoder,
406                offset,
407                _depth,
408            )
409        }
410    }
411    unsafe impl<
412            D: fidl::encoding::ResourceDialect,
413            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
414            T1: fidl::encoding::Encode<MetricValue, D>,
415        > fidl::encoding::Encode<Metric, D> for (T0, T1)
416    {
417        #[inline]
418        unsafe fn encode(
419            self,
420            encoder: &mut fidl::encoding::Encoder<'_, D>,
421            offset: usize,
422            depth: fidl::encoding::Depth,
423        ) -> fidl::Result<()> {
424            encoder.debug_check_bounds::<Metric>(offset);
425            // Zero out padding regions. There's no need to apply masks
426            // because the unmasked parts will be overwritten by fields.
427            // Write the fields.
428            self.0.encode(encoder, offset + 0, depth)?;
429            self.1.encode(encoder, offset + 16, depth)?;
430            Ok(())
431        }
432    }
433
434    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metric {
435        #[inline(always)]
436        fn new_empty() -> Self {
437            Self {
438                key: fidl::new_empty!(fidl::encoding::UnboundedString, D),
439                value: fidl::new_empty!(MetricValue, D),
440            }
441        }
442
443        #[inline]
444        unsafe fn decode(
445            &mut self,
446            decoder: &mut fidl::encoding::Decoder<'_, D>,
447            offset: usize,
448            _depth: fidl::encoding::Depth,
449        ) -> fidl::Result<()> {
450            decoder.debug_check_bounds::<Self>(offset);
451            // Verify that padding bytes are zero.
452            fidl::decode!(
453                fidl::encoding::UnboundedString,
454                D,
455                &mut self.key,
456                decoder,
457                offset + 0,
458                _depth
459            )?;
460            fidl::decode!(MetricValue, D, &mut self.value, decoder, offset + 16, _depth)?;
461            Ok(())
462        }
463    }
464
465    impl fidl::encoding::ValueTypeMarker for Object {
466        type Borrowed<'a> = &'a Self;
467        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
468            value
469        }
470    }
471
472    unsafe impl fidl::encoding::TypeMarker for Object {
473        type Owned = Self;
474
475        #[inline(always)]
476        fn inline_align(_context: fidl::encoding::Context) -> usize {
477            8
478        }
479
480        #[inline(always)]
481        fn inline_size(_context: fidl::encoding::Context) -> usize {
482            48
483        }
484    }
485
486    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Object, D> for &Object {
487        #[inline]
488        unsafe fn encode(
489            self,
490            encoder: &mut fidl::encoding::Encoder<'_, D>,
491            offset: usize,
492            _depth: fidl::encoding::Depth,
493        ) -> fidl::Result<()> {
494            encoder.debug_check_bounds::<Object>(offset);
495            // Delegate to tuple encoding.
496            fidl::encoding::Encode::<Object, D>::encode(
497                (
498                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
499                    <fidl::encoding::UnboundedVector<Property> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
500                    <fidl::encoding::UnboundedVector<Metric> as fidl::encoding::ValueTypeMarker>::borrow(&self.metrics),
501                ),
502                encoder, offset, _depth
503            )
504        }
505    }
506    unsafe impl<
507            D: fidl::encoding::ResourceDialect,
508            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
509            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Property>, D>,
510            T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Metric>, D>,
511        > fidl::encoding::Encode<Object, D> for (T0, T1, T2)
512    {
513        #[inline]
514        unsafe fn encode(
515            self,
516            encoder: &mut fidl::encoding::Encoder<'_, D>,
517            offset: usize,
518            depth: fidl::encoding::Depth,
519        ) -> fidl::Result<()> {
520            encoder.debug_check_bounds::<Object>(offset);
521            // Zero out padding regions. There's no need to apply masks
522            // because the unmasked parts will be overwritten by fields.
523            // Write the fields.
524            self.0.encode(encoder, offset + 0, depth)?;
525            self.1.encode(encoder, offset + 16, depth)?;
526            self.2.encode(encoder, offset + 32, depth)?;
527            Ok(())
528        }
529    }
530
531    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Object {
532        #[inline(always)]
533        fn new_empty() -> Self {
534            Self {
535                name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
536                properties: fidl::new_empty!(fidl::encoding::UnboundedVector<Property>, D),
537                metrics: fidl::new_empty!(fidl::encoding::UnboundedVector<Metric>, D),
538            }
539        }
540
541        #[inline]
542        unsafe fn decode(
543            &mut self,
544            decoder: &mut fidl::encoding::Decoder<'_, D>,
545            offset: usize,
546            _depth: fidl::encoding::Depth,
547        ) -> fidl::Result<()> {
548            decoder.debug_check_bounds::<Self>(offset);
549            // Verify that padding bytes are zero.
550            fidl::decode!(
551                fidl::encoding::UnboundedString,
552                D,
553                &mut self.name,
554                decoder,
555                offset + 0,
556                _depth
557            )?;
558            fidl::decode!(
559                fidl::encoding::UnboundedVector<Property>,
560                D,
561                &mut self.properties,
562                decoder,
563                offset + 16,
564                _depth
565            )?;
566            fidl::decode!(
567                fidl::encoding::UnboundedVector<Metric>,
568                D,
569                &mut self.metrics,
570                decoder,
571                offset + 32,
572                _depth
573            )?;
574            Ok(())
575        }
576    }
577
578    impl fidl::encoding::ValueTypeMarker for Property {
579        type Borrowed<'a> = &'a Self;
580        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
581            value
582        }
583    }
584
585    unsafe impl fidl::encoding::TypeMarker for Property {
586        type Owned = Self;
587
588        #[inline(always)]
589        fn inline_align(_context: fidl::encoding::Context) -> usize {
590            8
591        }
592
593        #[inline(always)]
594        fn inline_size(_context: fidl::encoding::Context) -> usize {
595            32
596        }
597    }
598
599    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Property, D> for &Property {
600        #[inline]
601        unsafe fn encode(
602            self,
603            encoder: &mut fidl::encoding::Encoder<'_, D>,
604            offset: usize,
605            _depth: fidl::encoding::Depth,
606        ) -> fidl::Result<()> {
607            encoder.debug_check_bounds::<Property>(offset);
608            // Delegate to tuple encoding.
609            fidl::encoding::Encode::<Property, D>::encode(
610                (
611                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
612                        &self.key,
613                    ),
614                    <PropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
615                ),
616                encoder,
617                offset,
618                _depth,
619            )
620        }
621    }
622    unsafe impl<
623            D: fidl::encoding::ResourceDialect,
624            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
625            T1: fidl::encoding::Encode<PropertyValue, D>,
626        > fidl::encoding::Encode<Property, D> for (T0, T1)
627    {
628        #[inline]
629        unsafe fn encode(
630            self,
631            encoder: &mut fidl::encoding::Encoder<'_, D>,
632            offset: usize,
633            depth: fidl::encoding::Depth,
634        ) -> fidl::Result<()> {
635            encoder.debug_check_bounds::<Property>(offset);
636            // Zero out padding regions. There's no need to apply masks
637            // because the unmasked parts will be overwritten by fields.
638            // Write the fields.
639            self.0.encode(encoder, offset + 0, depth)?;
640            self.1.encode(encoder, offset + 16, depth)?;
641            Ok(())
642        }
643    }
644
645    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Property {
646        #[inline(always)]
647        fn new_empty() -> Self {
648            Self {
649                key: fidl::new_empty!(fidl::encoding::UnboundedString, D),
650                value: fidl::new_empty!(PropertyValue, D),
651            }
652        }
653
654        #[inline]
655        unsafe fn decode(
656            &mut self,
657            decoder: &mut fidl::encoding::Decoder<'_, D>,
658            offset: usize,
659            _depth: fidl::encoding::Depth,
660        ) -> fidl::Result<()> {
661            decoder.debug_check_bounds::<Self>(offset);
662            // Verify that padding bytes are zero.
663            fidl::decode!(
664                fidl::encoding::UnboundedString,
665                D,
666                &mut self.key,
667                decoder,
668                offset + 0,
669                _depth
670            )?;
671            fidl::decode!(PropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
672            Ok(())
673        }
674    }
675
676    impl fidl::encoding::ValueTypeMarker for MetricValue {
677        type Borrowed<'a> = &'a Self;
678        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
679            value
680        }
681    }
682
683    unsafe impl fidl::encoding::TypeMarker for MetricValue {
684        type Owned = Self;
685
686        #[inline(always)]
687        fn inline_align(_context: fidl::encoding::Context) -> usize {
688            8
689        }
690
691        #[inline(always)]
692        fn inline_size(_context: fidl::encoding::Context) -> usize {
693            16
694        }
695    }
696
697    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MetricValue, D>
698        for &MetricValue
699    {
700        #[inline]
701        unsafe fn encode(
702            self,
703            encoder: &mut fidl::encoding::Encoder<'_, D>,
704            offset: usize,
705            _depth: fidl::encoding::Depth,
706        ) -> fidl::Result<()> {
707            encoder.debug_check_bounds::<MetricValue>(offset);
708            encoder.write_num::<u64>(self.ordinal(), offset);
709            match self {
710                MetricValue::IntValue(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
711                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
712                    encoder,
713                    offset + 8,
714                    _depth,
715                ),
716                MetricValue::UintValue(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
717                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
718                    encoder,
719                    offset + 8,
720                    _depth,
721                ),
722                MetricValue::DoubleValue(ref val) => fidl::encoding::encode_in_envelope::<f64, D>(
723                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
724                    encoder,
725                    offset + 8,
726                    _depth,
727                ),
728            }
729        }
730    }
731
732    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MetricValue {
733        #[inline(always)]
734        fn new_empty() -> Self {
735            Self::IntValue(fidl::new_empty!(i64, D))
736        }
737
738        #[inline]
739        unsafe fn decode(
740            &mut self,
741            decoder: &mut fidl::encoding::Decoder<'_, D>,
742            offset: usize,
743            mut depth: fidl::encoding::Depth,
744        ) -> fidl::Result<()> {
745            decoder.debug_check_bounds::<Self>(offset);
746            #[allow(unused_variables)]
747            let next_out_of_line = decoder.next_out_of_line();
748            let handles_before = decoder.remaining_handles();
749            let (ordinal, inlined, num_bytes, num_handles) =
750                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
751
752            let member_inline_size = match ordinal {
753                1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
754                2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
755                3 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
756                _ => return Err(fidl::Error::UnknownUnionTag),
757            };
758
759            if inlined != (member_inline_size <= 4) {
760                return Err(fidl::Error::InvalidInlineBitInEnvelope);
761            }
762            let _inner_offset;
763            if inlined {
764                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
765                _inner_offset = offset + 8;
766            } else {
767                depth.increment()?;
768                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
769            }
770            match ordinal {
771                1 => {
772                    #[allow(irrefutable_let_patterns)]
773                    if let MetricValue::IntValue(_) = self {
774                        // Do nothing, read the value into the object
775                    } else {
776                        // Initialize `self` to the right variant
777                        *self = MetricValue::IntValue(fidl::new_empty!(i64, D));
778                    }
779                    #[allow(irrefutable_let_patterns)]
780                    if let MetricValue::IntValue(ref mut val) = self {
781                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
782                    } else {
783                        unreachable!()
784                    }
785                }
786                2 => {
787                    #[allow(irrefutable_let_patterns)]
788                    if let MetricValue::UintValue(_) = self {
789                        // Do nothing, read the value into the object
790                    } else {
791                        // Initialize `self` to the right variant
792                        *self = MetricValue::UintValue(fidl::new_empty!(u64, D));
793                    }
794                    #[allow(irrefutable_let_patterns)]
795                    if let MetricValue::UintValue(ref mut val) = self {
796                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
797                    } else {
798                        unreachable!()
799                    }
800                }
801                3 => {
802                    #[allow(irrefutable_let_patterns)]
803                    if let MetricValue::DoubleValue(_) = self {
804                        // Do nothing, read the value into the object
805                    } else {
806                        // Initialize `self` to the right variant
807                        *self = MetricValue::DoubleValue(fidl::new_empty!(f64, D));
808                    }
809                    #[allow(irrefutable_let_patterns)]
810                    if let MetricValue::DoubleValue(ref mut val) = self {
811                        fidl::decode!(f64, D, val, decoder, _inner_offset, depth)?;
812                    } else {
813                        unreachable!()
814                    }
815                }
816                ordinal => panic!("unexpected ordinal {:?}", ordinal),
817            }
818            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
819                return Err(fidl::Error::InvalidNumBytesInEnvelope);
820            }
821            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
822                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
823            }
824            Ok(())
825        }
826    }
827
828    impl fidl::encoding::ValueTypeMarker for PropertyValue {
829        type Borrowed<'a> = &'a Self;
830        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
831            value
832        }
833    }
834
835    unsafe impl fidl::encoding::TypeMarker for PropertyValue {
836        type Owned = Self;
837
838        #[inline(always)]
839        fn inline_align(_context: fidl::encoding::Context) -> usize {
840            8
841        }
842
843        #[inline(always)]
844        fn inline_size(_context: fidl::encoding::Context) -> usize {
845            16
846        }
847    }
848
849    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PropertyValue, D>
850        for &PropertyValue
851    {
852        #[inline]
853        unsafe fn encode(
854            self,
855            encoder: &mut fidl::encoding::Encoder<'_, D>,
856            offset: usize,
857            _depth: fidl::encoding::Depth,
858        ) -> fidl::Result<()> {
859            encoder.debug_check_bounds::<PropertyValue>(offset);
860            encoder.write_num::<u64>(self.ordinal(), offset);
861            match self {
862            PropertyValue::Str(ref val) => {
863                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, D>(
864                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
865                    encoder, offset + 8, _depth
866                )
867            }
868            PropertyValue::Bytes(ref val) => {
869                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
870                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
871                    encoder, offset + 8, _depth
872                )
873            }
874        }
875        }
876    }
877
878    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PropertyValue {
879        #[inline(always)]
880        fn new_empty() -> Self {
881            Self::Str(fidl::new_empty!(fidl::encoding::UnboundedString, D))
882        }
883
884        #[inline]
885        unsafe fn decode(
886            &mut self,
887            decoder: &mut fidl::encoding::Decoder<'_, D>,
888            offset: usize,
889            mut depth: fidl::encoding::Depth,
890        ) -> fidl::Result<()> {
891            decoder.debug_check_bounds::<Self>(offset);
892            #[allow(unused_variables)]
893            let next_out_of_line = decoder.next_out_of_line();
894            let handles_before = decoder.remaining_handles();
895            let (ordinal, inlined, num_bytes, num_handles) =
896                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
897
898            let member_inline_size = match ordinal {
899                1 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
900                    decoder.context,
901                ),
902                2 => {
903                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(
904                        decoder.context,
905                    )
906                }
907                _ => return Err(fidl::Error::UnknownUnionTag),
908            };
909
910            if inlined != (member_inline_size <= 4) {
911                return Err(fidl::Error::InvalidInlineBitInEnvelope);
912            }
913            let _inner_offset;
914            if inlined {
915                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
916                _inner_offset = offset + 8;
917            } else {
918                depth.increment()?;
919                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
920            }
921            match ordinal {
922                1 => {
923                    #[allow(irrefutable_let_patterns)]
924                    if let PropertyValue::Str(_) = self {
925                        // Do nothing, read the value into the object
926                    } else {
927                        // Initialize `self` to the right variant
928                        *self = PropertyValue::Str(fidl::new_empty!(
929                            fidl::encoding::UnboundedString,
930                            D
931                        ));
932                    }
933                    #[allow(irrefutable_let_patterns)]
934                    if let PropertyValue::Str(ref mut val) = self {
935                        fidl::decode!(
936                            fidl::encoding::UnboundedString,
937                            D,
938                            val,
939                            decoder,
940                            _inner_offset,
941                            depth
942                        )?;
943                    } else {
944                        unreachable!()
945                    }
946                }
947                2 => {
948                    #[allow(irrefutable_let_patterns)]
949                    if let PropertyValue::Bytes(_) = self {
950                        // Do nothing, read the value into the object
951                    } else {
952                        // Initialize `self` to the right variant
953                        *self = PropertyValue::Bytes(fidl::new_empty!(
954                            fidl::encoding::UnboundedVector<u8>,
955                            D
956                        ));
957                    }
958                    #[allow(irrefutable_let_patterns)]
959                    if let PropertyValue::Bytes(ref mut val) = self {
960                        fidl::decode!(
961                            fidl::encoding::UnboundedVector<u8>,
962                            D,
963                            val,
964                            decoder,
965                            _inner_offset,
966                            depth
967                        )?;
968                    } else {
969                        unreachable!()
970                    }
971                }
972                ordinal => panic!("unexpected ordinal {:?}", ordinal),
973            }
974            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
975                return Err(fidl::Error::InvalidNumBytesInEnvelope);
976            }
977            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
978                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
979            }
980            Ok(())
981        }
982    }
983}
fidl_fuchsia_inspect_deprecated__common/fidl_fuchsia_inspect_deprecated__common.rs

fidl_fuchsia_inspect_deprecated__common/
fidl_fuchsia_inspect_deprecated__common.rs
