fidl_fuchsia_metrics__common/
fidl_fuchsia_metrics__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/// A vector of event codes. When used in one of the Log*() calls below,
12/// there must be one event code for each dimension of the metric whose
13/// metric_id is supplied, or else the call will return INVALID_ARGUMENTS.
14pub type EventVector = Vec<u32>;
15
16/// A histogram that assigns a count to each of several integer ranges.
17/// To save space/memory/bandwidth, each bucket index should only be included
18/// once, and empty buckets should not be included. The order of the vector
19/// is immaterial.
20pub type IntegerHistogram = Vec<HistogramBucket>;
21
22/// Maximum number of events that may be logged in a single FIDL call.
23pub const MAX_BATCHED_EVENTS: u32 = 500;
24
25/// The maximum size of a single Event is 100 KB.
26pub const MAX_BYTES_PER_EVENT: i64 = 102400;
27
28/// Maximum number of experiment ids that can be provided to a single logger.
29pub const MAX_EXPERIMENT_IDS: u32 = 100;
30
31/// This is intended as a reasonable maximum number of histogram buckets per
32/// event.
33pub const MAX_HISTOGRAM_BUCKETS: u32 = 500;
34
35/// Maximum number of event codes that can be associated with a single event.
36pub const MAX_METRIC_DIMENSIONS: u32 = 10;
37
38/// String events should not be longer than this.
39pub const MAX_STRING_EVENT_SIZE: u32 = 256;
40
41/// Error codes for MetricEventLogger operations.
42#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
43#[repr(i32)]
44pub enum Error {
45    /// For example, the supplied metric id is invalid.
46    InvalidArguments = 1,
47    /// An attempt was made to log an Event whose serialized size exceeds
48    /// MAX_BYTES_PER_EVENT.
49    EventTooBig = 2,
50    /// The logger's local buffer is temporarily full and cannot handle any more
51    /// Events at this time. Try again later. This condition should be rare.
52    BufferFull = 3,
53    ShutDown = 4,
54    /// Catch-all for unexpected errors.
55    InternalError = -1,
56}
57
58impl Error {
59    #[inline]
60    pub fn from_primitive(prim: i32) -> Option<Self> {
61        match prim {
62            1 => Some(Self::InvalidArguments),
63            2 => Some(Self::EventTooBig),
64            3 => Some(Self::BufferFull),
65            4 => Some(Self::ShutDown),
66            -1 => Some(Self::InternalError),
67            _ => None,
68        }
69    }
70
71    #[inline]
72    pub const fn into_primitive(self) -> i32 {
73        self as i32
74    }
75}
76
77/// One bucket of a histogram, used by the method LogIntegerHistogram.
78#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
79#[repr(C)]
80pub struct HistogramBucket {
81    /// The index of the bucket. The metric includes a specification
82    /// of a sequence of N+1 integer-range buckets that are indexed from
83    /// 0, the underflow bucket, to N, the overflow bucket.
84    pub index: u32,
85    /// The number of values in that bucket.
86    /// To save space/memory/bandwidth, empty buckets should not be included.
87    pub count: u64,
88}
89
90impl fidl::Persistable for HistogramBucket {}
91
92/// A specification of an event that occurred to be passed to LogMetricEvents().
93#[derive(Clone, Debug, PartialEq)]
94pub struct MetricEvent {
95    /// ID of the metric being logged.
96    pub metric_id: u32,
97    /// `event_codes` Ordered list of parameters, one for each of the metric's
98    /// dimensions.
99    pub event_codes: Vec<u32>,
100    /// The metric-type-specific data for the event being logged.
101    pub payload: MetricEventPayload,
102}
103
104impl fidl::Persistable for MetricEvent {}
105
106#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
107pub struct MetricEventLoggerLogIntegerHistogramRequest {
108    pub metric_id: u32,
109    pub histogram: Vec<HistogramBucket>,
110    pub event_codes: Vec<u32>,
111}
112
113impl fidl::Persistable for MetricEventLoggerLogIntegerHistogramRequest {}
114
115#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
116pub struct MetricEventLoggerLogIntegerRequest {
117    pub metric_id: u32,
118    pub value: i64,
119    pub event_codes: Vec<u32>,
120}
121
122impl fidl::Persistable for MetricEventLoggerLogIntegerRequest {}
123
124#[derive(Clone, Debug, PartialEq)]
125pub struct MetricEventLoggerLogMetricEventsRequest {
126    pub events: Vec<MetricEvent>,
127}
128
129impl fidl::Persistable for MetricEventLoggerLogMetricEventsRequest {}
130
131#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
132pub struct MetricEventLoggerLogOccurrenceRequest {
133    pub metric_id: u32,
134    pub count: u64,
135    pub event_codes: Vec<u32>,
136}
137
138impl fidl::Persistable for MetricEventLoggerLogOccurrenceRequest {}
139
140#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
141pub struct MetricEventLoggerLogStringRequest {
142    pub metric_id: u32,
143    pub string_value: String,
144    pub event_codes: Vec<u32>,
145}
146
147impl fidl::Persistable for MetricEventLoggerLogStringRequest {}
148
149/// A specification identifying a project to log events for.
150#[derive(Clone, Debug, Default, PartialEq)]
151pub struct ProjectSpec {
152    /// The customer ID. If omitted (i.e. set to 0) then it defaults to the
153    /// customer ID for the default "fuchsia" customer.
154    pub customer_id: Option<u32>,
155    /// The ID of the project.
156    pub project_id: Option<u32>,
157    #[doc(hidden)]
158    pub __source_breaking: fidl::marker::SourceBreaking,
159}
160
161impl fidl::Persistable for ProjectSpec {}
162
163/// The variadic part of a MetricEvent.
164#[derive(Clone, Debug)]
165pub enum MetricEventPayload {
166    /// The number of times the event has occurred, see LogOccurrence().
167    Count(u64),
168    /// The integer measured, see LogInteger().
169    IntegerValue(i64),
170    /// The collection of approximate integer measurements, see
171    /// LogIntegerHistogram().
172    Histogram(Vec<HistogramBucket>),
173    /// The string to log, see LogString().
174    StringValue(String),
175    #[doc(hidden)]
176    __SourceBreaking { unknown_ordinal: u64 },
177}
178
179/// Pattern that matches an unknown `MetricEventPayload` member.
180#[macro_export]
181macro_rules! MetricEventPayloadUnknown {
182    () => {
183        _
184    };
185}
186
187// Custom PartialEq so that unknown variants are not equal to themselves.
188impl PartialEq for MetricEventPayload {
189    fn eq(&self, other: &Self) -> bool {
190        match (self, other) {
191            (Self::Count(x), Self::Count(y)) => *x == *y,
192            (Self::IntegerValue(x), Self::IntegerValue(y)) => *x == *y,
193            (Self::Histogram(x), Self::Histogram(y)) => *x == *y,
194            (Self::StringValue(x), Self::StringValue(y)) => *x == *y,
195            _ => false,
196        }
197    }
198}
199
200impl MetricEventPayload {
201    #[inline]
202    pub fn ordinal(&self) -> u64 {
203        match *self {
204            Self::Count(_) => 1,
205            Self::IntegerValue(_) => 2,
206            Self::Histogram(_) => 3,
207            Self::StringValue(_) => 4,
208            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
209        }
210    }
211
212    #[inline]
213    pub fn unknown_variant_for_testing() -> Self {
214        Self::__SourceBreaking { unknown_ordinal: 0 }
215    }
216
217    #[inline]
218    pub fn is_unknown(&self) -> bool {
219        match self {
220            Self::__SourceBreaking { .. } => true,
221            _ => false,
222        }
223    }
224}
225
226impl fidl::Persistable for MetricEventPayload {}
227
228pub mod metric_event_logger_ordinals {
229    pub const LOG_OCCURRENCE: u64 = 0x26308985ae2bb3ac;
230    pub const LOG_INTEGER: u64 = 0x5d453303a88bd552;
231    pub const LOG_INTEGER_HISTOGRAM: u64 = 0x79ac8a6bc06a01c0;
232    pub const LOG_STRING: u64 = 0x1611efbdf6ac8300;
233    pub const LOG_METRIC_EVENTS: u64 = 0x4d8c26bb74820c6b;
234}
235
236pub mod metric_event_logger_factory_ordinals {
237    pub const CREATE_METRIC_EVENT_LOGGER: u64 = 0xd6cf51cee5039fe;
238    pub const CREATE_METRIC_EVENT_LOGGER_WITH_EXPERIMENTS: u64 = 0x7f1f745ef7bf48fa;
239}
240
241mod internal {
242    use super::*;
243    unsafe impl fidl::encoding::TypeMarker for Error {
244        type Owned = Self;
245
246        #[inline(always)]
247        fn inline_align(_context: fidl::encoding::Context) -> usize {
248            std::mem::align_of::<i32>()
249        }
250
251        #[inline(always)]
252        fn inline_size(_context: fidl::encoding::Context) -> usize {
253            std::mem::size_of::<i32>()
254        }
255
256        #[inline(always)]
257        fn encode_is_copy() -> bool {
258            true
259        }
260
261        #[inline(always)]
262        fn decode_is_copy() -> bool {
263            false
264        }
265    }
266
267    impl fidl::encoding::ValueTypeMarker for Error {
268        type Borrowed<'a> = Self;
269        #[inline(always)]
270        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
271            *value
272        }
273    }
274
275    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
276        #[inline]
277        unsafe fn encode(
278            self,
279            encoder: &mut fidl::encoding::Encoder<'_, D>,
280            offset: usize,
281            _depth: fidl::encoding::Depth,
282        ) -> fidl::Result<()> {
283            encoder.debug_check_bounds::<Self>(offset);
284            encoder.write_num(self.into_primitive(), offset);
285            Ok(())
286        }
287    }
288
289    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
290        #[inline(always)]
291        fn new_empty() -> Self {
292            Self::InternalError
293        }
294
295        #[inline]
296        unsafe fn decode(
297            &mut self,
298            decoder: &mut fidl::encoding::Decoder<'_, D>,
299            offset: usize,
300            _depth: fidl::encoding::Depth,
301        ) -> fidl::Result<()> {
302            decoder.debug_check_bounds::<Self>(offset);
303            let prim = decoder.read_num::<i32>(offset);
304
305            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
306            Ok(())
307        }
308    }
309
310    impl fidl::encoding::ValueTypeMarker for HistogramBucket {
311        type Borrowed<'a> = &'a Self;
312        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
313            value
314        }
315    }
316
317    unsafe impl fidl::encoding::TypeMarker for HistogramBucket {
318        type Owned = Self;
319
320        #[inline(always)]
321        fn inline_align(_context: fidl::encoding::Context) -> usize {
322            8
323        }
324
325        #[inline(always)]
326        fn inline_size(_context: fidl::encoding::Context) -> usize {
327            16
328        }
329    }
330
331    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HistogramBucket, D>
332        for &HistogramBucket
333    {
334        #[inline]
335        unsafe fn encode(
336            self,
337            encoder: &mut fidl::encoding::Encoder<'_, D>,
338            offset: usize,
339            _depth: fidl::encoding::Depth,
340        ) -> fidl::Result<()> {
341            encoder.debug_check_bounds::<HistogramBucket>(offset);
342            unsafe {
343                // Copy the object into the buffer.
344                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
345                (buf_ptr as *mut HistogramBucket)
346                    .write_unaligned((self as *const HistogramBucket).read());
347                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
348                // done second because the memcpy will write garbage to these bytes.
349                let padding_ptr = buf_ptr.offset(0) as *mut u64;
350                let padding_mask = 0xffffffff00000000u64;
351                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
352            }
353            Ok(())
354        }
355    }
356    unsafe impl<
357            D: fidl::encoding::ResourceDialect,
358            T0: fidl::encoding::Encode<u32, D>,
359            T1: fidl::encoding::Encode<u64, D>,
360        > fidl::encoding::Encode<HistogramBucket, D> for (T0, T1)
361    {
362        #[inline]
363        unsafe fn encode(
364            self,
365            encoder: &mut fidl::encoding::Encoder<'_, D>,
366            offset: usize,
367            depth: fidl::encoding::Depth,
368        ) -> fidl::Result<()> {
369            encoder.debug_check_bounds::<HistogramBucket>(offset);
370            // Zero out padding regions. There's no need to apply masks
371            // because the unmasked parts will be overwritten by fields.
372            unsafe {
373                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
374                (ptr as *mut u64).write_unaligned(0);
375            }
376            // Write the fields.
377            self.0.encode(encoder, offset + 0, depth)?;
378            self.1.encode(encoder, offset + 8, depth)?;
379            Ok(())
380        }
381    }
382
383    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HistogramBucket {
384        #[inline(always)]
385        fn new_empty() -> Self {
386            Self { index: fidl::new_empty!(u32, D), count: fidl::new_empty!(u64, D) }
387        }
388
389        #[inline]
390        unsafe fn decode(
391            &mut self,
392            decoder: &mut fidl::encoding::Decoder<'_, D>,
393            offset: usize,
394            _depth: fidl::encoding::Depth,
395        ) -> fidl::Result<()> {
396            decoder.debug_check_bounds::<Self>(offset);
397            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
398            // Verify that padding bytes are zero.
399            let ptr = unsafe { buf_ptr.offset(0) };
400            let padval = unsafe { (ptr as *const u64).read_unaligned() };
401            let mask = 0xffffffff00000000u64;
402            let maskedval = padval & mask;
403            if maskedval != 0 {
404                return Err(fidl::Error::NonZeroPadding {
405                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
406                });
407            }
408            // Copy from the buffer into the object.
409            unsafe {
410                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
411            }
412            Ok(())
413        }
414    }
415
416    impl fidl::encoding::ValueTypeMarker for MetricEvent {
417        type Borrowed<'a> = &'a Self;
418        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
419            value
420        }
421    }
422
423    unsafe impl fidl::encoding::TypeMarker for MetricEvent {
424        type Owned = Self;
425
426        #[inline(always)]
427        fn inline_align(_context: fidl::encoding::Context) -> usize {
428            8
429        }
430
431        #[inline(always)]
432        fn inline_size(_context: fidl::encoding::Context) -> usize {
433            40
434        }
435    }
436
437    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MetricEvent, D>
438        for &MetricEvent
439    {
440        #[inline]
441        unsafe fn encode(
442            self,
443            encoder: &mut fidl::encoding::Encoder<'_, D>,
444            offset: usize,
445            _depth: fidl::encoding::Depth,
446        ) -> fidl::Result<()> {
447            encoder.debug_check_bounds::<MetricEvent>(offset);
448            // Delegate to tuple encoding.
449            fidl::encoding::Encode::<MetricEvent, D>::encode(
450                (
451                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
452                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
453                        &self.event_codes,
454                    ),
455                    <MetricEventPayload as fidl::encoding::ValueTypeMarker>::borrow(&self.payload),
456                ),
457                encoder,
458                offset,
459                _depth,
460            )
461        }
462    }
463    unsafe impl<
464            D: fidl::encoding::ResourceDialect,
465            T0: fidl::encoding::Encode<u32, D>,
466            T1: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
467            T2: fidl::encoding::Encode<MetricEventPayload, D>,
468        > fidl::encoding::Encode<MetricEvent, D> for (T0, T1, T2)
469    {
470        #[inline]
471        unsafe fn encode(
472            self,
473            encoder: &mut fidl::encoding::Encoder<'_, D>,
474            offset: usize,
475            depth: fidl::encoding::Depth,
476        ) -> fidl::Result<()> {
477            encoder.debug_check_bounds::<MetricEvent>(offset);
478            // Zero out padding regions. There's no need to apply masks
479            // because the unmasked parts will be overwritten by fields.
480            unsafe {
481                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
482                (ptr as *mut u64).write_unaligned(0);
483            }
484            // Write the fields.
485            self.0.encode(encoder, offset + 0, depth)?;
486            self.1.encode(encoder, offset + 8, depth)?;
487            self.2.encode(encoder, offset + 24, depth)?;
488            Ok(())
489        }
490    }
491
492    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MetricEvent {
493        #[inline(always)]
494        fn new_empty() -> Self {
495            Self {
496                metric_id: fidl::new_empty!(u32, D),
497                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
498                payload: fidl::new_empty!(MetricEventPayload, D),
499            }
500        }
501
502        #[inline]
503        unsafe fn decode(
504            &mut self,
505            decoder: &mut fidl::encoding::Decoder<'_, D>,
506            offset: usize,
507            _depth: fidl::encoding::Depth,
508        ) -> fidl::Result<()> {
509            decoder.debug_check_bounds::<Self>(offset);
510            // Verify that padding bytes are zero.
511            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
512            let padval = unsafe { (ptr as *const u64).read_unaligned() };
513            let mask = 0xffffffff00000000u64;
514            let maskedval = padval & mask;
515            if maskedval != 0 {
516                return Err(fidl::Error::NonZeroPadding {
517                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
518                });
519            }
520            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
521            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 8, _depth)?;
522            fidl::decode!(MetricEventPayload, D, &mut self.payload, decoder, offset + 24, _depth)?;
523            Ok(())
524        }
525    }
526
527    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogIntegerHistogramRequest {
528        type Borrowed<'a> = &'a Self;
529        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
530            value
531        }
532    }
533
534    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogIntegerHistogramRequest {
535        type Owned = Self;
536
537        #[inline(always)]
538        fn inline_align(_context: fidl::encoding::Context) -> usize {
539            8
540        }
541
542        #[inline(always)]
543        fn inline_size(_context: fidl::encoding::Context) -> usize {
544            40
545        }
546    }
547
548    unsafe impl<D: fidl::encoding::ResourceDialect>
549        fidl::encoding::Encode<MetricEventLoggerLogIntegerHistogramRequest, D>
550        for &MetricEventLoggerLogIntegerHistogramRequest
551    {
552        #[inline]
553        unsafe fn encode(
554            self,
555            encoder: &mut fidl::encoding::Encoder<'_, D>,
556            offset: usize,
557            _depth: fidl::encoding::Depth,
558        ) -> fidl::Result<()> {
559            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerHistogramRequest>(offset);
560            // Delegate to tuple encoding.
561            fidl::encoding::Encode::<MetricEventLoggerLogIntegerHistogramRequest, D>::encode(
562                (
563                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
564                    <fidl::encoding::Vector<HistogramBucket, 500> as fidl::encoding::ValueTypeMarker>::borrow(&self.histogram),
565                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(&self.event_codes),
566                ),
567                encoder, offset, _depth
568            )
569        }
570    }
571    unsafe impl<
572            D: fidl::encoding::ResourceDialect,
573            T0: fidl::encoding::Encode<u32, D>,
574            T1: fidl::encoding::Encode<fidl::encoding::Vector<HistogramBucket, 500>, D>,
575            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
576        > fidl::encoding::Encode<MetricEventLoggerLogIntegerHistogramRequest, D> for (T0, T1, T2)
577    {
578        #[inline]
579        unsafe fn encode(
580            self,
581            encoder: &mut fidl::encoding::Encoder<'_, D>,
582            offset: usize,
583            depth: fidl::encoding::Depth,
584        ) -> fidl::Result<()> {
585            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerHistogramRequest>(offset);
586            // Zero out padding regions. There's no need to apply masks
587            // because the unmasked parts will be overwritten by fields.
588            unsafe {
589                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
590                (ptr as *mut u64).write_unaligned(0);
591            }
592            // Write the fields.
593            self.0.encode(encoder, offset + 0, depth)?;
594            self.1.encode(encoder, offset + 8, depth)?;
595            self.2.encode(encoder, offset + 24, depth)?;
596            Ok(())
597        }
598    }
599
600    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
601        for MetricEventLoggerLogIntegerHistogramRequest
602    {
603        #[inline(always)]
604        fn new_empty() -> Self {
605            Self {
606                metric_id: fidl::new_empty!(u32, D),
607                histogram: fidl::new_empty!(fidl::encoding::Vector<HistogramBucket, 500>, D),
608                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
609            }
610        }
611
612        #[inline]
613        unsafe fn decode(
614            &mut self,
615            decoder: &mut fidl::encoding::Decoder<'_, D>,
616            offset: usize,
617            _depth: fidl::encoding::Depth,
618        ) -> fidl::Result<()> {
619            decoder.debug_check_bounds::<Self>(offset);
620            // Verify that padding bytes are zero.
621            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
622            let padval = unsafe { (ptr as *const u64).read_unaligned() };
623            let mask = 0xffffffff00000000u64;
624            let maskedval = padval & mask;
625            if maskedval != 0 {
626                return Err(fidl::Error::NonZeroPadding {
627                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
628                });
629            }
630            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
631            fidl::decode!(fidl::encoding::Vector<HistogramBucket, 500>, D, &mut self.histogram, decoder, offset + 8, _depth)?;
632            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 24, _depth)?;
633            Ok(())
634        }
635    }
636
637    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogIntegerRequest {
638        type Borrowed<'a> = &'a Self;
639        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
640            value
641        }
642    }
643
644    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogIntegerRequest {
645        type Owned = Self;
646
647        #[inline(always)]
648        fn inline_align(_context: fidl::encoding::Context) -> usize {
649            8
650        }
651
652        #[inline(always)]
653        fn inline_size(_context: fidl::encoding::Context) -> usize {
654            32
655        }
656    }
657
658    unsafe impl<D: fidl::encoding::ResourceDialect>
659        fidl::encoding::Encode<MetricEventLoggerLogIntegerRequest, D>
660        for &MetricEventLoggerLogIntegerRequest
661    {
662        #[inline]
663        unsafe fn encode(
664            self,
665            encoder: &mut fidl::encoding::Encoder<'_, D>,
666            offset: usize,
667            _depth: fidl::encoding::Depth,
668        ) -> fidl::Result<()> {
669            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerRequest>(offset);
670            // Delegate to tuple encoding.
671            fidl::encoding::Encode::<MetricEventLoggerLogIntegerRequest, D>::encode(
672                (
673                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
674                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
675                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
676                        &self.event_codes,
677                    ),
678                ),
679                encoder,
680                offset,
681                _depth,
682            )
683        }
684    }
685    unsafe impl<
686            D: fidl::encoding::ResourceDialect,
687            T0: fidl::encoding::Encode<u32, D>,
688            T1: fidl::encoding::Encode<i64, D>,
689            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
690        > fidl::encoding::Encode<MetricEventLoggerLogIntegerRequest, D> for (T0, T1, T2)
691    {
692        #[inline]
693        unsafe fn encode(
694            self,
695            encoder: &mut fidl::encoding::Encoder<'_, D>,
696            offset: usize,
697            depth: fidl::encoding::Depth,
698        ) -> fidl::Result<()> {
699            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerRequest>(offset);
700            // Zero out padding regions. There's no need to apply masks
701            // because the unmasked parts will be overwritten by fields.
702            unsafe {
703                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
704                (ptr as *mut u64).write_unaligned(0);
705            }
706            // Write the fields.
707            self.0.encode(encoder, offset + 0, depth)?;
708            self.1.encode(encoder, offset + 8, depth)?;
709            self.2.encode(encoder, offset + 16, depth)?;
710            Ok(())
711        }
712    }
713
714    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
715        for MetricEventLoggerLogIntegerRequest
716    {
717        #[inline(always)]
718        fn new_empty() -> Self {
719            Self {
720                metric_id: fidl::new_empty!(u32, D),
721                value: fidl::new_empty!(i64, D),
722                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
723            }
724        }
725
726        #[inline]
727        unsafe fn decode(
728            &mut self,
729            decoder: &mut fidl::encoding::Decoder<'_, D>,
730            offset: usize,
731            _depth: fidl::encoding::Depth,
732        ) -> fidl::Result<()> {
733            decoder.debug_check_bounds::<Self>(offset);
734            // Verify that padding bytes are zero.
735            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
736            let padval = unsafe { (ptr as *const u64).read_unaligned() };
737            let mask = 0xffffffff00000000u64;
738            let maskedval = padval & mask;
739            if maskedval != 0 {
740                return Err(fidl::Error::NonZeroPadding {
741                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
742                });
743            }
744            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
745            fidl::decode!(i64, D, &mut self.value, decoder, offset + 8, _depth)?;
746            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 16, _depth)?;
747            Ok(())
748        }
749    }
750
751    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogMetricEventsRequest {
752        type Borrowed<'a> = &'a Self;
753        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
754            value
755        }
756    }
757
758    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogMetricEventsRequest {
759        type Owned = Self;
760
761        #[inline(always)]
762        fn inline_align(_context: fidl::encoding::Context) -> usize {
763            8
764        }
765
766        #[inline(always)]
767        fn inline_size(_context: fidl::encoding::Context) -> usize {
768            16
769        }
770    }
771
772    unsafe impl<D: fidl::encoding::ResourceDialect>
773        fidl::encoding::Encode<MetricEventLoggerLogMetricEventsRequest, D>
774        for &MetricEventLoggerLogMetricEventsRequest
775    {
776        #[inline]
777        unsafe fn encode(
778            self,
779            encoder: &mut fidl::encoding::Encoder<'_, D>,
780            offset: usize,
781            _depth: fidl::encoding::Depth,
782        ) -> fidl::Result<()> {
783            encoder.debug_check_bounds::<MetricEventLoggerLogMetricEventsRequest>(offset);
784            // Delegate to tuple encoding.
785            fidl::encoding::Encode::<MetricEventLoggerLogMetricEventsRequest, D>::encode(
786                (
787                    <fidl::encoding::Vector<MetricEvent, 500> as fidl::encoding::ValueTypeMarker>::borrow(&self.events),
788                ),
789                encoder, offset, _depth
790            )
791        }
792    }
793    unsafe impl<
794            D: fidl::encoding::ResourceDialect,
795            T0: fidl::encoding::Encode<fidl::encoding::Vector<MetricEvent, 500>, D>,
796        > fidl::encoding::Encode<MetricEventLoggerLogMetricEventsRequest, D> for (T0,)
797    {
798        #[inline]
799        unsafe fn encode(
800            self,
801            encoder: &mut fidl::encoding::Encoder<'_, D>,
802            offset: usize,
803            depth: fidl::encoding::Depth,
804        ) -> fidl::Result<()> {
805            encoder.debug_check_bounds::<MetricEventLoggerLogMetricEventsRequest>(offset);
806            // Zero out padding regions. There's no need to apply masks
807            // because the unmasked parts will be overwritten by fields.
808            // Write the fields.
809            self.0.encode(encoder, offset + 0, depth)?;
810            Ok(())
811        }
812    }
813
814    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
815        for MetricEventLoggerLogMetricEventsRequest
816    {
817        #[inline(always)]
818        fn new_empty() -> Self {
819            Self { events: fidl::new_empty!(fidl::encoding::Vector<MetricEvent, 500>, D) }
820        }
821
822        #[inline]
823        unsafe fn decode(
824            &mut self,
825            decoder: &mut fidl::encoding::Decoder<'_, D>,
826            offset: usize,
827            _depth: fidl::encoding::Depth,
828        ) -> fidl::Result<()> {
829            decoder.debug_check_bounds::<Self>(offset);
830            // Verify that padding bytes are zero.
831            fidl::decode!(fidl::encoding::Vector<MetricEvent, 500>, D, &mut self.events, decoder, offset + 0, _depth)?;
832            Ok(())
833        }
834    }
835
836    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogOccurrenceRequest {
837        type Borrowed<'a> = &'a Self;
838        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
839            value
840        }
841    }
842
843    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogOccurrenceRequest {
844        type Owned = Self;
845
846        #[inline(always)]
847        fn inline_align(_context: fidl::encoding::Context) -> usize {
848            8
849        }
850
851        #[inline(always)]
852        fn inline_size(_context: fidl::encoding::Context) -> usize {
853            32
854        }
855    }
856
857    unsafe impl<D: fidl::encoding::ResourceDialect>
858        fidl::encoding::Encode<MetricEventLoggerLogOccurrenceRequest, D>
859        for &MetricEventLoggerLogOccurrenceRequest
860    {
861        #[inline]
862        unsafe fn encode(
863            self,
864            encoder: &mut fidl::encoding::Encoder<'_, D>,
865            offset: usize,
866            _depth: fidl::encoding::Depth,
867        ) -> fidl::Result<()> {
868            encoder.debug_check_bounds::<MetricEventLoggerLogOccurrenceRequest>(offset);
869            // Delegate to tuple encoding.
870            fidl::encoding::Encode::<MetricEventLoggerLogOccurrenceRequest, D>::encode(
871                (
872                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
873                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.count),
874                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
875                        &self.event_codes,
876                    ),
877                ),
878                encoder,
879                offset,
880                _depth,
881            )
882        }
883    }
884    unsafe impl<
885            D: fidl::encoding::ResourceDialect,
886            T0: fidl::encoding::Encode<u32, D>,
887            T1: fidl::encoding::Encode<u64, D>,
888            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
889        > fidl::encoding::Encode<MetricEventLoggerLogOccurrenceRequest, D> for (T0, T1, T2)
890    {
891        #[inline]
892        unsafe fn encode(
893            self,
894            encoder: &mut fidl::encoding::Encoder<'_, D>,
895            offset: usize,
896            depth: fidl::encoding::Depth,
897        ) -> fidl::Result<()> {
898            encoder.debug_check_bounds::<MetricEventLoggerLogOccurrenceRequest>(offset);
899            // Zero out padding regions. There's no need to apply masks
900            // because the unmasked parts will be overwritten by fields.
901            unsafe {
902                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
903                (ptr as *mut u64).write_unaligned(0);
904            }
905            // Write the fields.
906            self.0.encode(encoder, offset + 0, depth)?;
907            self.1.encode(encoder, offset + 8, depth)?;
908            self.2.encode(encoder, offset + 16, depth)?;
909            Ok(())
910        }
911    }
912
913    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
914        for MetricEventLoggerLogOccurrenceRequest
915    {
916        #[inline(always)]
917        fn new_empty() -> Self {
918            Self {
919                metric_id: fidl::new_empty!(u32, D),
920                count: fidl::new_empty!(u64, D),
921                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
922            }
923        }
924
925        #[inline]
926        unsafe fn decode(
927            &mut self,
928            decoder: &mut fidl::encoding::Decoder<'_, D>,
929            offset: usize,
930            _depth: fidl::encoding::Depth,
931        ) -> fidl::Result<()> {
932            decoder.debug_check_bounds::<Self>(offset);
933            // Verify that padding bytes are zero.
934            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
935            let padval = unsafe { (ptr as *const u64).read_unaligned() };
936            let mask = 0xffffffff00000000u64;
937            let maskedval = padval & mask;
938            if maskedval != 0 {
939                return Err(fidl::Error::NonZeroPadding {
940                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
941                });
942            }
943            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
944            fidl::decode!(u64, D, &mut self.count, decoder, offset + 8, _depth)?;
945            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 16, _depth)?;
946            Ok(())
947        }
948    }
949
950    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogStringRequest {
951        type Borrowed<'a> = &'a Self;
952        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
953            value
954        }
955    }
956
957    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogStringRequest {
958        type Owned = Self;
959
960        #[inline(always)]
961        fn inline_align(_context: fidl::encoding::Context) -> usize {
962            8
963        }
964
965        #[inline(always)]
966        fn inline_size(_context: fidl::encoding::Context) -> usize {
967            40
968        }
969    }
970
971    unsafe impl<D: fidl::encoding::ResourceDialect>
972        fidl::encoding::Encode<MetricEventLoggerLogStringRequest, D>
973        for &MetricEventLoggerLogStringRequest
974    {
975        #[inline]
976        unsafe fn encode(
977            self,
978            encoder: &mut fidl::encoding::Encoder<'_, D>,
979            offset: usize,
980            _depth: fidl::encoding::Depth,
981        ) -> fidl::Result<()> {
982            encoder.debug_check_bounds::<MetricEventLoggerLogStringRequest>(offset);
983            // Delegate to tuple encoding.
984            fidl::encoding::Encode::<MetricEventLoggerLogStringRequest, D>::encode(
985                (
986                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
987                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
988                        &self.string_value,
989                    ),
990                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
991                        &self.event_codes,
992                    ),
993                ),
994                encoder,
995                offset,
996                _depth,
997            )
998        }
999    }
1000    unsafe impl<
1001            D: fidl::encoding::ResourceDialect,
1002            T0: fidl::encoding::Encode<u32, D>,
1003            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1004            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
1005        > fidl::encoding::Encode<MetricEventLoggerLogStringRequest, D> for (T0, T1, T2)
1006    {
1007        #[inline]
1008        unsafe fn encode(
1009            self,
1010            encoder: &mut fidl::encoding::Encoder<'_, D>,
1011            offset: usize,
1012            depth: fidl::encoding::Depth,
1013        ) -> fidl::Result<()> {
1014            encoder.debug_check_bounds::<MetricEventLoggerLogStringRequest>(offset);
1015            // Zero out padding regions. There's no need to apply masks
1016            // because the unmasked parts will be overwritten by fields.
1017            unsafe {
1018                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1019                (ptr as *mut u64).write_unaligned(0);
1020            }
1021            // Write the fields.
1022            self.0.encode(encoder, offset + 0, depth)?;
1023            self.1.encode(encoder, offset + 8, depth)?;
1024            self.2.encode(encoder, offset + 24, depth)?;
1025            Ok(())
1026        }
1027    }
1028
1029    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1030        for MetricEventLoggerLogStringRequest
1031    {
1032        #[inline(always)]
1033        fn new_empty() -> Self {
1034            Self {
1035                metric_id: fidl::new_empty!(u32, D),
1036                string_value: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1037                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
1038            }
1039        }
1040
1041        #[inline]
1042        unsafe fn decode(
1043            &mut self,
1044            decoder: &mut fidl::encoding::Decoder<'_, D>,
1045            offset: usize,
1046            _depth: fidl::encoding::Depth,
1047        ) -> fidl::Result<()> {
1048            decoder.debug_check_bounds::<Self>(offset);
1049            // Verify that padding bytes are zero.
1050            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1051            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1052            let mask = 0xffffffff00000000u64;
1053            let maskedval = padval & mask;
1054            if maskedval != 0 {
1055                return Err(fidl::Error::NonZeroPadding {
1056                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1057                });
1058            }
1059            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
1060            fidl::decode!(
1061                fidl::encoding::BoundedString<256>,
1062                D,
1063                &mut self.string_value,
1064                decoder,
1065                offset + 8,
1066                _depth
1067            )?;
1068            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 24, _depth)?;
1069            Ok(())
1070        }
1071    }
1072
1073    impl ProjectSpec {
1074        #[inline(always)]
1075        fn max_ordinal_present(&self) -> u64 {
1076            if let Some(_) = self.project_id {
1077                return 2;
1078            }
1079            if let Some(_) = self.customer_id {
1080                return 1;
1081            }
1082            0
1083        }
1084    }
1085
1086    impl fidl::encoding::ValueTypeMarker for ProjectSpec {
1087        type Borrowed<'a> = &'a Self;
1088        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1089            value
1090        }
1091    }
1092
1093    unsafe impl fidl::encoding::TypeMarker for ProjectSpec {
1094        type Owned = Self;
1095
1096        #[inline(always)]
1097        fn inline_align(_context: fidl::encoding::Context) -> usize {
1098            8
1099        }
1100
1101        #[inline(always)]
1102        fn inline_size(_context: fidl::encoding::Context) -> usize {
1103            16
1104        }
1105    }
1106
1107    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProjectSpec, D>
1108        for &ProjectSpec
1109    {
1110        unsafe fn encode(
1111            self,
1112            encoder: &mut fidl::encoding::Encoder<'_, D>,
1113            offset: usize,
1114            mut depth: fidl::encoding::Depth,
1115        ) -> fidl::Result<()> {
1116            encoder.debug_check_bounds::<ProjectSpec>(offset);
1117            // Vector header
1118            let max_ordinal: u64 = self.max_ordinal_present();
1119            encoder.write_num(max_ordinal, offset);
1120            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1121            // Calling encoder.out_of_line_offset(0) is not allowed.
1122            if max_ordinal == 0 {
1123                return Ok(());
1124            }
1125            depth.increment()?;
1126            let envelope_size = 8;
1127            let bytes_len = max_ordinal as usize * envelope_size;
1128            #[allow(unused_variables)]
1129            let offset = encoder.out_of_line_offset(bytes_len);
1130            let mut _prev_end_offset: usize = 0;
1131            if 1 > max_ordinal {
1132                return Ok(());
1133            }
1134
1135            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1136            // are envelope_size bytes.
1137            let cur_offset: usize = (1 - 1) * envelope_size;
1138
1139            // Zero reserved fields.
1140            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1141
1142            // Safety:
1143            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1144            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1145            //   envelope_size bytes, there is always sufficient room.
1146            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1147                self.customer_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1148                encoder,
1149                offset + cur_offset,
1150                depth,
1151            )?;
1152
1153            _prev_end_offset = cur_offset + envelope_size;
1154            if 2 > max_ordinal {
1155                return Ok(());
1156            }
1157
1158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1159            // are envelope_size bytes.
1160            let cur_offset: usize = (2 - 1) * envelope_size;
1161
1162            // Zero reserved fields.
1163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1164
1165            // Safety:
1166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1168            //   envelope_size bytes, there is always sufficient room.
1169            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1170                self.project_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1171                encoder,
1172                offset + cur_offset,
1173                depth,
1174            )?;
1175
1176            _prev_end_offset = cur_offset + envelope_size;
1177
1178            Ok(())
1179        }
1180    }
1181
1182    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProjectSpec {
1183        #[inline(always)]
1184        fn new_empty() -> Self {
1185            Self::default()
1186        }
1187
1188        unsafe fn decode(
1189            &mut self,
1190            decoder: &mut fidl::encoding::Decoder<'_, D>,
1191            offset: usize,
1192            mut depth: fidl::encoding::Depth,
1193        ) -> fidl::Result<()> {
1194            decoder.debug_check_bounds::<Self>(offset);
1195            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1196                None => return Err(fidl::Error::NotNullable),
1197                Some(len) => len,
1198            };
1199            // Calling decoder.out_of_line_offset(0) is not allowed.
1200            if len == 0 {
1201                return Ok(());
1202            };
1203            depth.increment()?;
1204            let envelope_size = 8;
1205            let bytes_len = len * envelope_size;
1206            let offset = decoder.out_of_line_offset(bytes_len)?;
1207            // Decode the envelope for each type.
1208            let mut _next_ordinal_to_read = 0;
1209            let mut next_offset = offset;
1210            let end_offset = offset + bytes_len;
1211            _next_ordinal_to_read += 1;
1212            if next_offset >= end_offset {
1213                return Ok(());
1214            }
1215
1216            // Decode unknown envelopes for gaps in ordinals.
1217            while _next_ordinal_to_read < 1 {
1218                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1219                _next_ordinal_to_read += 1;
1220                next_offset += envelope_size;
1221            }
1222
1223            let next_out_of_line = decoder.next_out_of_line();
1224            let handles_before = decoder.remaining_handles();
1225            if let Some((inlined, num_bytes, num_handles)) =
1226                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1227            {
1228                let member_inline_size =
1229                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1230                if inlined != (member_inline_size <= 4) {
1231                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1232                }
1233                let inner_offset;
1234                let mut inner_depth = depth.clone();
1235                if inlined {
1236                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1237                    inner_offset = next_offset;
1238                } else {
1239                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1240                    inner_depth.increment()?;
1241                }
1242                let val_ref = self.customer_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1243                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1244                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1245                {
1246                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1247                }
1248                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1249                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1250                }
1251            }
1252
1253            next_offset += envelope_size;
1254            _next_ordinal_to_read += 1;
1255            if next_offset >= end_offset {
1256                return Ok(());
1257            }
1258
1259            // Decode unknown envelopes for gaps in ordinals.
1260            while _next_ordinal_to_read < 2 {
1261                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1262                _next_ordinal_to_read += 1;
1263                next_offset += envelope_size;
1264            }
1265
1266            let next_out_of_line = decoder.next_out_of_line();
1267            let handles_before = decoder.remaining_handles();
1268            if let Some((inlined, num_bytes, num_handles)) =
1269                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1270            {
1271                let member_inline_size =
1272                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1273                if inlined != (member_inline_size <= 4) {
1274                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1275                }
1276                let inner_offset;
1277                let mut inner_depth = depth.clone();
1278                if inlined {
1279                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1280                    inner_offset = next_offset;
1281                } else {
1282                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1283                    inner_depth.increment()?;
1284                }
1285                let val_ref = self.project_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1286                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1287                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1288                {
1289                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1290                }
1291                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1292                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1293                }
1294            }
1295
1296            next_offset += envelope_size;
1297
1298            // Decode the remaining unknown envelopes.
1299            while next_offset < end_offset {
1300                _next_ordinal_to_read += 1;
1301                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1302                next_offset += envelope_size;
1303            }
1304
1305            Ok(())
1306        }
1307    }
1308
1309    impl fidl::encoding::ValueTypeMarker for MetricEventPayload {
1310        type Borrowed<'a> = &'a Self;
1311        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1312            value
1313        }
1314    }
1315
1316    unsafe impl fidl::encoding::TypeMarker for MetricEventPayload {
1317        type Owned = Self;
1318
1319        #[inline(always)]
1320        fn inline_align(_context: fidl::encoding::Context) -> usize {
1321            8
1322        }
1323
1324        #[inline(always)]
1325        fn inline_size(_context: fidl::encoding::Context) -> usize {
1326            16
1327        }
1328    }
1329
1330    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MetricEventPayload, D>
1331        for &MetricEventPayload
1332    {
1333        #[inline]
1334        unsafe fn encode(
1335            self,
1336            encoder: &mut fidl::encoding::Encoder<'_, D>,
1337            offset: usize,
1338            _depth: fidl::encoding::Depth,
1339        ) -> fidl::Result<()> {
1340            encoder.debug_check_bounds::<MetricEventPayload>(offset);
1341            encoder.write_num::<u64>(self.ordinal(), offset);
1342            match self {
1343            MetricEventPayload::Count(ref val) => {
1344                fidl::encoding::encode_in_envelope::<u64, D>(
1345                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
1346                    encoder, offset + 8, _depth
1347                )
1348            }
1349            MetricEventPayload::IntegerValue(ref val) => {
1350                fidl::encoding::encode_in_envelope::<i64, D>(
1351                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
1352                    encoder, offset + 8, _depth
1353                )
1354            }
1355            MetricEventPayload::Histogram(ref val) => {
1356                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<HistogramBucket, 500>, D>(
1357                    <fidl::encoding::Vector<HistogramBucket, 500> as fidl::encoding::ValueTypeMarker>::borrow(val),
1358                    encoder, offset + 8, _depth
1359                )
1360            }
1361            MetricEventPayload::StringValue(ref val) => {
1362                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<256>, D>(
1363                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(val),
1364                    encoder, offset + 8, _depth
1365                )
1366            }
1367            MetricEventPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
1368        }
1369        }
1370    }
1371
1372    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MetricEventPayload {
1373        #[inline(always)]
1374        fn new_empty() -> Self {
1375            Self::__SourceBreaking { unknown_ordinal: 0 }
1376        }
1377
1378        #[inline]
1379        unsafe fn decode(
1380            &mut self,
1381            decoder: &mut fidl::encoding::Decoder<'_, D>,
1382            offset: usize,
1383            mut depth: fidl::encoding::Depth,
1384        ) -> fidl::Result<()> {
1385            decoder.debug_check_bounds::<Self>(offset);
1386            #[allow(unused_variables)]
1387            let next_out_of_line = decoder.next_out_of_line();
1388            let handles_before = decoder.remaining_handles();
1389            let (ordinal, inlined, num_bytes, num_handles) =
1390                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1391
1392            let member_inline_size = match ordinal {
1393            1 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1394            2 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1395            3 => <fidl::encoding::Vector<HistogramBucket, 500> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1396            4 => <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1397            0 => return Err(fidl::Error::UnknownUnionTag),
1398            _ => num_bytes as usize,
1399        };
1400
1401            if inlined != (member_inline_size <= 4) {
1402                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1403            }
1404            let _inner_offset;
1405            if inlined {
1406                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1407                _inner_offset = offset + 8;
1408            } else {
1409                depth.increment()?;
1410                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1411            }
1412            match ordinal {
1413                1 => {
1414                    #[allow(irrefutable_let_patterns)]
1415                    if let MetricEventPayload::Count(_) = self {
1416                        // Do nothing, read the value into the object
1417                    } else {
1418                        // Initialize `self` to the right variant
1419                        *self = MetricEventPayload::Count(fidl::new_empty!(u64, D));
1420                    }
1421                    #[allow(irrefutable_let_patterns)]
1422                    if let MetricEventPayload::Count(ref mut val) = self {
1423                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
1424                    } else {
1425                        unreachable!()
1426                    }
1427                }
1428                2 => {
1429                    #[allow(irrefutable_let_patterns)]
1430                    if let MetricEventPayload::IntegerValue(_) = self {
1431                        // Do nothing, read the value into the object
1432                    } else {
1433                        // Initialize `self` to the right variant
1434                        *self = MetricEventPayload::IntegerValue(fidl::new_empty!(i64, D));
1435                    }
1436                    #[allow(irrefutable_let_patterns)]
1437                    if let MetricEventPayload::IntegerValue(ref mut val) = self {
1438                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
1439                    } else {
1440                        unreachable!()
1441                    }
1442                }
1443                3 => {
1444                    #[allow(irrefutable_let_patterns)]
1445                    if let MetricEventPayload::Histogram(_) = self {
1446                        // Do nothing, read the value into the object
1447                    } else {
1448                        // Initialize `self` to the right variant
1449                        *self = MetricEventPayload::Histogram(
1450                            fidl::new_empty!(fidl::encoding::Vector<HistogramBucket, 500>, D),
1451                        );
1452                    }
1453                    #[allow(irrefutable_let_patterns)]
1454                    if let MetricEventPayload::Histogram(ref mut val) = self {
1455                        fidl::decode!(fidl::encoding::Vector<HistogramBucket, 500>, D, val, decoder, _inner_offset, depth)?;
1456                    } else {
1457                        unreachable!()
1458                    }
1459                }
1460                4 => {
1461                    #[allow(irrefutable_let_patterns)]
1462                    if let MetricEventPayload::StringValue(_) = self {
1463                        // Do nothing, read the value into the object
1464                    } else {
1465                        // Initialize `self` to the right variant
1466                        *self = MetricEventPayload::StringValue(fidl::new_empty!(
1467                            fidl::encoding::BoundedString<256>,
1468                            D
1469                        ));
1470                    }
1471                    #[allow(irrefutable_let_patterns)]
1472                    if let MetricEventPayload::StringValue(ref mut val) = self {
1473                        fidl::decode!(
1474                            fidl::encoding::BoundedString<256>,
1475                            D,
1476                            val,
1477                            decoder,
1478                            _inner_offset,
1479                            depth
1480                        )?;
1481                    } else {
1482                        unreachable!()
1483                    }
1484                }
1485                #[allow(deprecated)]
1486                ordinal => {
1487                    for _ in 0..num_handles {
1488                        decoder.drop_next_handle()?;
1489                    }
1490                    *self = MetricEventPayload::__SourceBreaking { unknown_ordinal: ordinal };
1491                }
1492            }
1493            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1494                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1495            }
1496            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1497                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1498            }
1499            Ok(())
1500        }
1501    }
1502}