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

fidl_fuchsia_inspect_deprecated__common/
fidl_fuchsia_inspect_deprecated__common.rs
