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

fidl_fuchsia_inspect_deprecated__common/
fidl_fuchsia_inspect_deprecated__common.rs
