fidl_fuchsia_cobalt__common/
fidl_fuchsia_cobalt__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, PartialEq)]
12pub struct ControllerGenerateAggregatedObservationsRequest {
13    pub day_index: u32,
14    pub report_specs: Vec<ReportSpec>,
15}
16
17impl fidl::Persistable for ControllerGenerateAggregatedObservationsRequest {}
18
19#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
20pub struct ControllerGenerateAggregatedObservationsResponse {
21    pub num_obs: Vec<u64>,
22}
23
24impl fidl::Persistable for ControllerGenerateAggregatedObservationsResponse {}
25
26#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
27pub struct ControllerRequestSendSoonResponse {
28    pub success: bool,
29}
30
31impl fidl::Persistable for ControllerRequestSendSoonResponse {}
32
33/// A specification to identify a single Cobalt report.
34#[derive(Clone, Debug, Default, PartialEq)]
35pub struct ReportSpec {
36    /// The customer ID, as specified in Cobalt's metrics registry.
37    pub customer_id: Option<u32>,
38    /// The ID of the project, as specified in Cobalt's metrics registry.
39    pub project_id: Option<u32>,
40    /// The ID of the metric, as specified in Cobalt's metrics registry.
41    pub metric_id: Option<u32>,
42    /// The ID of the report, as specified in Cobalt's metrics registry.
43    pub report_id: Option<u32>,
44    #[doc(hidden)]
45    pub __source_breaking: fidl::marker::SourceBreaking,
46}
47
48impl fidl::Persistable for ReportSpec {}
49
50pub mod aggregate_and_upload_ordinals {
51    pub const AGGREGATE_AND_UPLOAD_METRIC_EVENTS: u64 = 0x48db82fb20a16550;
52}
53
54pub mod controller_ordinals {
55    pub const REQUEST_SEND_SOON: u64 = 0x554e66bab8f72e3d;
56    pub const GENERATE_AGGREGATED_OBSERVATIONS: u64 = 0x79e058c9497f1ab1;
57    pub const LISTEN_FOR_INITIALIZED: u64 = 0x3454fbf05fcf10ef;
58}
59
60mod internal {
61    use super::*;
62
63    impl fidl::encoding::ValueTypeMarker for ControllerGenerateAggregatedObservationsRequest {
64        type Borrowed<'a> = &'a Self;
65        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
66            value
67        }
68    }
69
70    unsafe impl fidl::encoding::TypeMarker for ControllerGenerateAggregatedObservationsRequest {
71        type Owned = Self;
72
73        #[inline(always)]
74        fn inline_align(_context: fidl::encoding::Context) -> usize {
75            8
76        }
77
78        #[inline(always)]
79        fn inline_size(_context: fidl::encoding::Context) -> usize {
80            24
81        }
82    }
83
84    unsafe impl<D: fidl::encoding::ResourceDialect>
85        fidl::encoding::Encode<ControllerGenerateAggregatedObservationsRequest, D>
86        for &ControllerGenerateAggregatedObservationsRequest
87    {
88        #[inline]
89        unsafe fn encode(
90            self,
91            encoder: &mut fidl::encoding::Encoder<'_, D>,
92            offset: usize,
93            _depth: fidl::encoding::Depth,
94        ) -> fidl::Result<()> {
95            encoder.debug_check_bounds::<ControllerGenerateAggregatedObservationsRequest>(offset);
96            // Delegate to tuple encoding.
97            fidl::encoding::Encode::<ControllerGenerateAggregatedObservationsRequest, D>::encode(
98                (
99                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.day_index),
100                    <fidl::encoding::UnboundedVector<ReportSpec> as fidl::encoding::ValueTypeMarker>::borrow(&self.report_specs),
101                ),
102                encoder, offset, _depth
103            )
104        }
105    }
106    unsafe impl<
107            D: fidl::encoding::ResourceDialect,
108            T0: fidl::encoding::Encode<u32, D>,
109            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<ReportSpec>, D>,
110        > fidl::encoding::Encode<ControllerGenerateAggregatedObservationsRequest, D> for (T0, T1)
111    {
112        #[inline]
113        unsafe fn encode(
114            self,
115            encoder: &mut fidl::encoding::Encoder<'_, D>,
116            offset: usize,
117            depth: fidl::encoding::Depth,
118        ) -> fidl::Result<()> {
119            encoder.debug_check_bounds::<ControllerGenerateAggregatedObservationsRequest>(offset);
120            // Zero out padding regions. There's no need to apply masks
121            // because the unmasked parts will be overwritten by fields.
122            unsafe {
123                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
124                (ptr as *mut u64).write_unaligned(0);
125            }
126            // Write the fields.
127            self.0.encode(encoder, offset + 0, depth)?;
128            self.1.encode(encoder, offset + 8, depth)?;
129            Ok(())
130        }
131    }
132
133    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
134        for ControllerGenerateAggregatedObservationsRequest
135    {
136        #[inline(always)]
137        fn new_empty() -> Self {
138            Self {
139                day_index: fidl::new_empty!(u32, D),
140                report_specs: fidl::new_empty!(fidl::encoding::UnboundedVector<ReportSpec>, D),
141            }
142        }
143
144        #[inline]
145        unsafe fn decode(
146            &mut self,
147            decoder: &mut fidl::encoding::Decoder<'_, D>,
148            offset: usize,
149            _depth: fidl::encoding::Depth,
150        ) -> fidl::Result<()> {
151            decoder.debug_check_bounds::<Self>(offset);
152            // Verify that padding bytes are zero.
153            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
154            let padval = unsafe { (ptr as *const u64).read_unaligned() };
155            let mask = 0xffffffff00000000u64;
156            let maskedval = padval & mask;
157            if maskedval != 0 {
158                return Err(fidl::Error::NonZeroPadding {
159                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
160                });
161            }
162            fidl::decode!(u32, D, &mut self.day_index, decoder, offset + 0, _depth)?;
163            fidl::decode!(
164                fidl::encoding::UnboundedVector<ReportSpec>,
165                D,
166                &mut self.report_specs,
167                decoder,
168                offset + 8,
169                _depth
170            )?;
171            Ok(())
172        }
173    }
174
175    impl fidl::encoding::ValueTypeMarker for ControllerGenerateAggregatedObservationsResponse {
176        type Borrowed<'a> = &'a Self;
177        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
178            value
179        }
180    }
181
182    unsafe impl fidl::encoding::TypeMarker for ControllerGenerateAggregatedObservationsResponse {
183        type Owned = Self;
184
185        #[inline(always)]
186        fn inline_align(_context: fidl::encoding::Context) -> usize {
187            8
188        }
189
190        #[inline(always)]
191        fn inline_size(_context: fidl::encoding::Context) -> usize {
192            16
193        }
194    }
195
196    unsafe impl<D: fidl::encoding::ResourceDialect>
197        fidl::encoding::Encode<ControllerGenerateAggregatedObservationsResponse, D>
198        for &ControllerGenerateAggregatedObservationsResponse
199    {
200        #[inline]
201        unsafe fn encode(
202            self,
203            encoder: &mut fidl::encoding::Encoder<'_, D>,
204            offset: usize,
205            _depth: fidl::encoding::Depth,
206        ) -> fidl::Result<()> {
207            encoder.debug_check_bounds::<ControllerGenerateAggregatedObservationsResponse>(offset);
208            // Delegate to tuple encoding.
209            fidl::encoding::Encode::<ControllerGenerateAggregatedObservationsResponse, D>::encode(
210                (
211                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.num_obs),
212                ),
213                encoder, offset, _depth
214            )
215        }
216    }
217    unsafe impl<
218            D: fidl::encoding::ResourceDialect,
219            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>, D>,
220        > fidl::encoding::Encode<ControllerGenerateAggregatedObservationsResponse, D> for (T0,)
221    {
222        #[inline]
223        unsafe fn encode(
224            self,
225            encoder: &mut fidl::encoding::Encoder<'_, D>,
226            offset: usize,
227            depth: fidl::encoding::Depth,
228        ) -> fidl::Result<()> {
229            encoder.debug_check_bounds::<ControllerGenerateAggregatedObservationsResponse>(offset);
230            // Zero out padding regions. There's no need to apply masks
231            // because the unmasked parts will be overwritten by fields.
232            // Write the fields.
233            self.0.encode(encoder, offset + 0, depth)?;
234            Ok(())
235        }
236    }
237
238    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
239        for ControllerGenerateAggregatedObservationsResponse
240    {
241        #[inline(always)]
242        fn new_empty() -> Self {
243            Self { num_obs: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D) }
244        }
245
246        #[inline]
247        unsafe fn decode(
248            &mut self,
249            decoder: &mut fidl::encoding::Decoder<'_, D>,
250            offset: usize,
251            _depth: fidl::encoding::Depth,
252        ) -> fidl::Result<()> {
253            decoder.debug_check_bounds::<Self>(offset);
254            // Verify that padding bytes are zero.
255            fidl::decode!(
256                fidl::encoding::UnboundedVector<u64>,
257                D,
258                &mut self.num_obs,
259                decoder,
260                offset + 0,
261                _depth
262            )?;
263            Ok(())
264        }
265    }
266
267    impl fidl::encoding::ValueTypeMarker for ControllerRequestSendSoonResponse {
268        type Borrowed<'a> = &'a Self;
269        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
270            value
271        }
272    }
273
274    unsafe impl fidl::encoding::TypeMarker for ControllerRequestSendSoonResponse {
275        type Owned = Self;
276
277        #[inline(always)]
278        fn inline_align(_context: fidl::encoding::Context) -> usize {
279            1
280        }
281
282        #[inline(always)]
283        fn inline_size(_context: fidl::encoding::Context) -> usize {
284            1
285        }
286    }
287
288    unsafe impl<D: fidl::encoding::ResourceDialect>
289        fidl::encoding::Encode<ControllerRequestSendSoonResponse, D>
290        for &ControllerRequestSendSoonResponse
291    {
292        #[inline]
293        unsafe fn encode(
294            self,
295            encoder: &mut fidl::encoding::Encoder<'_, D>,
296            offset: usize,
297            _depth: fidl::encoding::Depth,
298        ) -> fidl::Result<()> {
299            encoder.debug_check_bounds::<ControllerRequestSendSoonResponse>(offset);
300            // Delegate to tuple encoding.
301            fidl::encoding::Encode::<ControllerRequestSendSoonResponse, D>::encode(
302                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.success),),
303                encoder,
304                offset,
305                _depth,
306            )
307        }
308    }
309    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
310        fidl::encoding::Encode<ControllerRequestSendSoonResponse, D> for (T0,)
311    {
312        #[inline]
313        unsafe fn encode(
314            self,
315            encoder: &mut fidl::encoding::Encoder<'_, D>,
316            offset: usize,
317            depth: fidl::encoding::Depth,
318        ) -> fidl::Result<()> {
319            encoder.debug_check_bounds::<ControllerRequestSendSoonResponse>(offset);
320            // Zero out padding regions. There's no need to apply masks
321            // because the unmasked parts will be overwritten by fields.
322            // Write the fields.
323            self.0.encode(encoder, offset + 0, depth)?;
324            Ok(())
325        }
326    }
327
328    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
329        for ControllerRequestSendSoonResponse
330    {
331        #[inline(always)]
332        fn new_empty() -> Self {
333            Self { success: fidl::new_empty!(bool, D) }
334        }
335
336        #[inline]
337        unsafe fn decode(
338            &mut self,
339            decoder: &mut fidl::encoding::Decoder<'_, D>,
340            offset: usize,
341            _depth: fidl::encoding::Depth,
342        ) -> fidl::Result<()> {
343            decoder.debug_check_bounds::<Self>(offset);
344            // Verify that padding bytes are zero.
345            fidl::decode!(bool, D, &mut self.success, decoder, offset + 0, _depth)?;
346            Ok(())
347        }
348    }
349
350    impl ReportSpec {
351        #[inline(always)]
352        fn max_ordinal_present(&self) -> u64 {
353            if let Some(_) = self.report_id {
354                return 4;
355            }
356            if let Some(_) = self.metric_id {
357                return 3;
358            }
359            if let Some(_) = self.project_id {
360                return 2;
361            }
362            if let Some(_) = self.customer_id {
363                return 1;
364            }
365            0
366        }
367    }
368
369    impl fidl::encoding::ValueTypeMarker for ReportSpec {
370        type Borrowed<'a> = &'a Self;
371        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
372            value
373        }
374    }
375
376    unsafe impl fidl::encoding::TypeMarker for ReportSpec {
377        type Owned = Self;
378
379        #[inline(always)]
380        fn inline_align(_context: fidl::encoding::Context) -> usize {
381            8
382        }
383
384        #[inline(always)]
385        fn inline_size(_context: fidl::encoding::Context) -> usize {
386            16
387        }
388    }
389
390    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ReportSpec, D>
391        for &ReportSpec
392    {
393        unsafe fn encode(
394            self,
395            encoder: &mut fidl::encoding::Encoder<'_, D>,
396            offset: usize,
397            mut depth: fidl::encoding::Depth,
398        ) -> fidl::Result<()> {
399            encoder.debug_check_bounds::<ReportSpec>(offset);
400            // Vector header
401            let max_ordinal: u64 = self.max_ordinal_present();
402            encoder.write_num(max_ordinal, offset);
403            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
404            // Calling encoder.out_of_line_offset(0) is not allowed.
405            if max_ordinal == 0 {
406                return Ok(());
407            }
408            depth.increment()?;
409            let envelope_size = 8;
410            let bytes_len = max_ordinal as usize * envelope_size;
411            #[allow(unused_variables)]
412            let offset = encoder.out_of_line_offset(bytes_len);
413            let mut _prev_end_offset: usize = 0;
414            if 1 > max_ordinal {
415                return Ok(());
416            }
417
418            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
419            // are envelope_size bytes.
420            let cur_offset: usize = (1 - 1) * envelope_size;
421
422            // Zero reserved fields.
423            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
424
425            // Safety:
426            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
427            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
428            //   envelope_size bytes, there is always sufficient room.
429            fidl::encoding::encode_in_envelope_optional::<u32, D>(
430                self.customer_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
431                encoder,
432                offset + cur_offset,
433                depth,
434            )?;
435
436            _prev_end_offset = cur_offset + envelope_size;
437            if 2 > max_ordinal {
438                return Ok(());
439            }
440
441            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
442            // are envelope_size bytes.
443            let cur_offset: usize = (2 - 1) * envelope_size;
444
445            // Zero reserved fields.
446            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
447
448            // Safety:
449            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
450            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
451            //   envelope_size bytes, there is always sufficient room.
452            fidl::encoding::encode_in_envelope_optional::<u32, D>(
453                self.project_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
454                encoder,
455                offset + cur_offset,
456                depth,
457            )?;
458
459            _prev_end_offset = cur_offset + envelope_size;
460            if 3 > max_ordinal {
461                return Ok(());
462            }
463
464            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
465            // are envelope_size bytes.
466            let cur_offset: usize = (3 - 1) * envelope_size;
467
468            // Zero reserved fields.
469            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
470
471            // Safety:
472            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
473            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
474            //   envelope_size bytes, there is always sufficient room.
475            fidl::encoding::encode_in_envelope_optional::<u32, D>(
476                self.metric_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
477                encoder,
478                offset + cur_offset,
479                depth,
480            )?;
481
482            _prev_end_offset = cur_offset + envelope_size;
483            if 4 > max_ordinal {
484                return Ok(());
485            }
486
487            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
488            // are envelope_size bytes.
489            let cur_offset: usize = (4 - 1) * envelope_size;
490
491            // Zero reserved fields.
492            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
493
494            // Safety:
495            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
496            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
497            //   envelope_size bytes, there is always sufficient room.
498            fidl::encoding::encode_in_envelope_optional::<u32, D>(
499                self.report_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
500                encoder,
501                offset + cur_offset,
502                depth,
503            )?;
504
505            _prev_end_offset = cur_offset + envelope_size;
506
507            Ok(())
508        }
509    }
510
511    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReportSpec {
512        #[inline(always)]
513        fn new_empty() -> Self {
514            Self::default()
515        }
516
517        unsafe fn decode(
518            &mut self,
519            decoder: &mut fidl::encoding::Decoder<'_, D>,
520            offset: usize,
521            mut depth: fidl::encoding::Depth,
522        ) -> fidl::Result<()> {
523            decoder.debug_check_bounds::<Self>(offset);
524            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
525                None => return Err(fidl::Error::NotNullable),
526                Some(len) => len,
527            };
528            // Calling decoder.out_of_line_offset(0) is not allowed.
529            if len == 0 {
530                return Ok(());
531            };
532            depth.increment()?;
533            let envelope_size = 8;
534            let bytes_len = len * envelope_size;
535            let offset = decoder.out_of_line_offset(bytes_len)?;
536            // Decode the envelope for each type.
537            let mut _next_ordinal_to_read = 0;
538            let mut next_offset = offset;
539            let end_offset = offset + bytes_len;
540            _next_ordinal_to_read += 1;
541            if next_offset >= end_offset {
542                return Ok(());
543            }
544
545            // Decode unknown envelopes for gaps in ordinals.
546            while _next_ordinal_to_read < 1 {
547                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
548                _next_ordinal_to_read += 1;
549                next_offset += envelope_size;
550            }
551
552            let next_out_of_line = decoder.next_out_of_line();
553            let handles_before = decoder.remaining_handles();
554            if let Some((inlined, num_bytes, num_handles)) =
555                fidl::encoding::decode_envelope_header(decoder, next_offset)?
556            {
557                let member_inline_size =
558                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
559                if inlined != (member_inline_size <= 4) {
560                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
561                }
562                let inner_offset;
563                let mut inner_depth = depth.clone();
564                if inlined {
565                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
566                    inner_offset = next_offset;
567                } else {
568                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
569                    inner_depth.increment()?;
570                }
571                let val_ref = self.customer_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
572                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
573                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
574                {
575                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
576                }
577                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
578                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
579                }
580            }
581
582            next_offset += envelope_size;
583            _next_ordinal_to_read += 1;
584            if next_offset >= end_offset {
585                return Ok(());
586            }
587
588            // Decode unknown envelopes for gaps in ordinals.
589            while _next_ordinal_to_read < 2 {
590                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591                _next_ordinal_to_read += 1;
592                next_offset += envelope_size;
593            }
594
595            let next_out_of_line = decoder.next_out_of_line();
596            let handles_before = decoder.remaining_handles();
597            if let Some((inlined, num_bytes, num_handles)) =
598                fidl::encoding::decode_envelope_header(decoder, next_offset)?
599            {
600                let member_inline_size =
601                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
602                if inlined != (member_inline_size <= 4) {
603                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
604                }
605                let inner_offset;
606                let mut inner_depth = depth.clone();
607                if inlined {
608                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
609                    inner_offset = next_offset;
610                } else {
611                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
612                    inner_depth.increment()?;
613                }
614                let val_ref = self.project_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
615                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
617                {
618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
619                }
620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
622                }
623            }
624
625            next_offset += envelope_size;
626            _next_ordinal_to_read += 1;
627            if next_offset >= end_offset {
628                return Ok(());
629            }
630
631            // Decode unknown envelopes for gaps in ordinals.
632            while _next_ordinal_to_read < 3 {
633                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
634                _next_ordinal_to_read += 1;
635                next_offset += envelope_size;
636            }
637
638            let next_out_of_line = decoder.next_out_of_line();
639            let handles_before = decoder.remaining_handles();
640            if let Some((inlined, num_bytes, num_handles)) =
641                fidl::encoding::decode_envelope_header(decoder, next_offset)?
642            {
643                let member_inline_size =
644                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
645                if inlined != (member_inline_size <= 4) {
646                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
647                }
648                let inner_offset;
649                let mut inner_depth = depth.clone();
650                if inlined {
651                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
652                    inner_offset = next_offset;
653                } else {
654                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
655                    inner_depth.increment()?;
656                }
657                let val_ref = self.metric_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
658                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
659                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
660                {
661                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
662                }
663                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
664                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
665                }
666            }
667
668            next_offset += envelope_size;
669            _next_ordinal_to_read += 1;
670            if next_offset >= end_offset {
671                return Ok(());
672            }
673
674            // Decode unknown envelopes for gaps in ordinals.
675            while _next_ordinal_to_read < 4 {
676                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
677                _next_ordinal_to_read += 1;
678                next_offset += envelope_size;
679            }
680
681            let next_out_of_line = decoder.next_out_of_line();
682            let handles_before = decoder.remaining_handles();
683            if let Some((inlined, num_bytes, num_handles)) =
684                fidl::encoding::decode_envelope_header(decoder, next_offset)?
685            {
686                let member_inline_size =
687                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
688                if inlined != (member_inline_size <= 4) {
689                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
690                }
691                let inner_offset;
692                let mut inner_depth = depth.clone();
693                if inlined {
694                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
695                    inner_offset = next_offset;
696                } else {
697                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
698                    inner_depth.increment()?;
699                }
700                let val_ref = self.report_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
701                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
702                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
703                {
704                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
705                }
706                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
707                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
708                }
709            }
710
711            next_offset += envelope_size;
712
713            // Decode the remaining unknown envelopes.
714            while next_offset < end_offset {
715                _next_ordinal_to_read += 1;
716                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
717                next_offset += envelope_size;
718            }
719
720            Ok(())
721        }
722    }
723}
fidl_fuchsia_cobalt__common/fidl_fuchsia_cobalt__common.rs

fidl_fuchsia_cobalt__common/
fidl_fuchsia_cobalt__common.rs
