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
228mod internal {
229    use super::*;
230    unsafe impl fidl::encoding::TypeMarker for Error {
231        type Owned = Self;
232
233        #[inline(always)]
234        fn inline_align(_context: fidl::encoding::Context) -> usize {
235            std::mem::align_of::<i32>()
236        }
237
238        #[inline(always)]
239        fn inline_size(_context: fidl::encoding::Context) -> usize {
240            std::mem::size_of::<i32>()
241        }
242
243        #[inline(always)]
244        fn encode_is_copy() -> bool {
245            true
246        }
247
248        #[inline(always)]
249        fn decode_is_copy() -> bool {
250            false
251        }
252    }
253
254    impl fidl::encoding::ValueTypeMarker for Error {
255        type Borrowed<'a> = Self;
256        #[inline(always)]
257        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
258            *value
259        }
260    }
261
262    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
263        #[inline]
264        unsafe fn encode(
265            self,
266            encoder: &mut fidl::encoding::Encoder<'_, D>,
267            offset: usize,
268            _depth: fidl::encoding::Depth,
269        ) -> fidl::Result<()> {
270            encoder.debug_check_bounds::<Self>(offset);
271            encoder.write_num(self.into_primitive(), offset);
272            Ok(())
273        }
274    }
275
276    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
277        #[inline(always)]
278        fn new_empty() -> Self {
279            Self::InternalError
280        }
281
282        #[inline]
283        unsafe fn decode(
284            &mut self,
285            decoder: &mut fidl::encoding::Decoder<'_, D>,
286            offset: usize,
287            _depth: fidl::encoding::Depth,
288        ) -> fidl::Result<()> {
289            decoder.debug_check_bounds::<Self>(offset);
290            let prim = decoder.read_num::<i32>(offset);
291
292            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
293            Ok(())
294        }
295    }
296
297    impl fidl::encoding::ValueTypeMarker for HistogramBucket {
298        type Borrowed<'a> = &'a Self;
299        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
300            value
301        }
302    }
303
304    unsafe impl fidl::encoding::TypeMarker for HistogramBucket {
305        type Owned = Self;
306
307        #[inline(always)]
308        fn inline_align(_context: fidl::encoding::Context) -> usize {
309            8
310        }
311
312        #[inline(always)]
313        fn inline_size(_context: fidl::encoding::Context) -> usize {
314            16
315        }
316    }
317
318    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HistogramBucket, D>
319        for &HistogramBucket
320    {
321        #[inline]
322        unsafe fn encode(
323            self,
324            encoder: &mut fidl::encoding::Encoder<'_, D>,
325            offset: usize,
326            _depth: fidl::encoding::Depth,
327        ) -> fidl::Result<()> {
328            encoder.debug_check_bounds::<HistogramBucket>(offset);
329            unsafe {
330                // Copy the object into the buffer.
331                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
332                (buf_ptr as *mut HistogramBucket)
333                    .write_unaligned((self as *const HistogramBucket).read());
334                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
335                // done second because the memcpy will write garbage to these bytes.
336                let padding_ptr = buf_ptr.offset(0) as *mut u64;
337                let padding_mask = 0xffffffff00000000u64;
338                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
339            }
340            Ok(())
341        }
342    }
343    unsafe impl<
344            D: fidl::encoding::ResourceDialect,
345            T0: fidl::encoding::Encode<u32, D>,
346            T1: fidl::encoding::Encode<u64, D>,
347        > fidl::encoding::Encode<HistogramBucket, D> for (T0, T1)
348    {
349        #[inline]
350        unsafe fn encode(
351            self,
352            encoder: &mut fidl::encoding::Encoder<'_, D>,
353            offset: usize,
354            depth: fidl::encoding::Depth,
355        ) -> fidl::Result<()> {
356            encoder.debug_check_bounds::<HistogramBucket>(offset);
357            // Zero out padding regions. There's no need to apply masks
358            // because the unmasked parts will be overwritten by fields.
359            unsafe {
360                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
361                (ptr as *mut u64).write_unaligned(0);
362            }
363            // Write the fields.
364            self.0.encode(encoder, offset + 0, depth)?;
365            self.1.encode(encoder, offset + 8, depth)?;
366            Ok(())
367        }
368    }
369
370    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HistogramBucket {
371        #[inline(always)]
372        fn new_empty() -> Self {
373            Self { index: fidl::new_empty!(u32, D), count: fidl::new_empty!(u64, D) }
374        }
375
376        #[inline]
377        unsafe fn decode(
378            &mut self,
379            decoder: &mut fidl::encoding::Decoder<'_, D>,
380            offset: usize,
381            _depth: fidl::encoding::Depth,
382        ) -> fidl::Result<()> {
383            decoder.debug_check_bounds::<Self>(offset);
384            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
385            // Verify that padding bytes are zero.
386            let ptr = unsafe { buf_ptr.offset(0) };
387            let padval = unsafe { (ptr as *const u64).read_unaligned() };
388            let mask = 0xffffffff00000000u64;
389            let maskedval = padval & mask;
390            if maskedval != 0 {
391                return Err(fidl::Error::NonZeroPadding {
392                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
393                });
394            }
395            // Copy from the buffer into the object.
396            unsafe {
397                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
398            }
399            Ok(())
400        }
401    }
402
403    impl fidl::encoding::ValueTypeMarker for MetricEvent {
404        type Borrowed<'a> = &'a Self;
405        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
406            value
407        }
408    }
409
410    unsafe impl fidl::encoding::TypeMarker for MetricEvent {
411        type Owned = Self;
412
413        #[inline(always)]
414        fn inline_align(_context: fidl::encoding::Context) -> usize {
415            8
416        }
417
418        #[inline(always)]
419        fn inline_size(_context: fidl::encoding::Context) -> usize {
420            40
421        }
422    }
423
424    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MetricEvent, D>
425        for &MetricEvent
426    {
427        #[inline]
428        unsafe fn encode(
429            self,
430            encoder: &mut fidl::encoding::Encoder<'_, D>,
431            offset: usize,
432            _depth: fidl::encoding::Depth,
433        ) -> fidl::Result<()> {
434            encoder.debug_check_bounds::<MetricEvent>(offset);
435            // Delegate to tuple encoding.
436            fidl::encoding::Encode::<MetricEvent, D>::encode(
437                (
438                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
439                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
440                        &self.event_codes,
441                    ),
442                    <MetricEventPayload as fidl::encoding::ValueTypeMarker>::borrow(&self.payload),
443                ),
444                encoder,
445                offset,
446                _depth,
447            )
448        }
449    }
450    unsafe impl<
451            D: fidl::encoding::ResourceDialect,
452            T0: fidl::encoding::Encode<u32, D>,
453            T1: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
454            T2: fidl::encoding::Encode<MetricEventPayload, D>,
455        > fidl::encoding::Encode<MetricEvent, D> for (T0, T1, T2)
456    {
457        #[inline]
458        unsafe fn encode(
459            self,
460            encoder: &mut fidl::encoding::Encoder<'_, D>,
461            offset: usize,
462            depth: fidl::encoding::Depth,
463        ) -> fidl::Result<()> {
464            encoder.debug_check_bounds::<MetricEvent>(offset);
465            // Zero out padding regions. There's no need to apply masks
466            // because the unmasked parts will be overwritten by fields.
467            unsafe {
468                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
469                (ptr as *mut u64).write_unaligned(0);
470            }
471            // Write the fields.
472            self.0.encode(encoder, offset + 0, depth)?;
473            self.1.encode(encoder, offset + 8, depth)?;
474            self.2.encode(encoder, offset + 24, depth)?;
475            Ok(())
476        }
477    }
478
479    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MetricEvent {
480        #[inline(always)]
481        fn new_empty() -> Self {
482            Self {
483                metric_id: fidl::new_empty!(u32, D),
484                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
485                payload: fidl::new_empty!(MetricEventPayload, D),
486            }
487        }
488
489        #[inline]
490        unsafe fn decode(
491            &mut self,
492            decoder: &mut fidl::encoding::Decoder<'_, D>,
493            offset: usize,
494            _depth: fidl::encoding::Depth,
495        ) -> fidl::Result<()> {
496            decoder.debug_check_bounds::<Self>(offset);
497            // Verify that padding bytes are zero.
498            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
499            let padval = unsafe { (ptr as *const u64).read_unaligned() };
500            let mask = 0xffffffff00000000u64;
501            let maskedval = padval & mask;
502            if maskedval != 0 {
503                return Err(fidl::Error::NonZeroPadding {
504                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
505                });
506            }
507            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
508            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 8, _depth)?;
509            fidl::decode!(MetricEventPayload, D, &mut self.payload, decoder, offset + 24, _depth)?;
510            Ok(())
511        }
512    }
513
514    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogIntegerHistogramRequest {
515        type Borrowed<'a> = &'a Self;
516        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
517            value
518        }
519    }
520
521    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogIntegerHistogramRequest {
522        type Owned = Self;
523
524        #[inline(always)]
525        fn inline_align(_context: fidl::encoding::Context) -> usize {
526            8
527        }
528
529        #[inline(always)]
530        fn inline_size(_context: fidl::encoding::Context) -> usize {
531            40
532        }
533    }
534
535    unsafe impl<D: fidl::encoding::ResourceDialect>
536        fidl::encoding::Encode<MetricEventLoggerLogIntegerHistogramRequest, D>
537        for &MetricEventLoggerLogIntegerHistogramRequest
538    {
539        #[inline]
540        unsafe fn encode(
541            self,
542            encoder: &mut fidl::encoding::Encoder<'_, D>,
543            offset: usize,
544            _depth: fidl::encoding::Depth,
545        ) -> fidl::Result<()> {
546            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerHistogramRequest>(offset);
547            // Delegate to tuple encoding.
548            fidl::encoding::Encode::<MetricEventLoggerLogIntegerHistogramRequest, D>::encode(
549                (
550                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
551                    <fidl::encoding::Vector<HistogramBucket, 500> as fidl::encoding::ValueTypeMarker>::borrow(&self.histogram),
552                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(&self.event_codes),
553                ),
554                encoder, offset, _depth
555            )
556        }
557    }
558    unsafe impl<
559            D: fidl::encoding::ResourceDialect,
560            T0: fidl::encoding::Encode<u32, D>,
561            T1: fidl::encoding::Encode<fidl::encoding::Vector<HistogramBucket, 500>, D>,
562            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
563        > fidl::encoding::Encode<MetricEventLoggerLogIntegerHistogramRequest, D> for (T0, T1, T2)
564    {
565        #[inline]
566        unsafe fn encode(
567            self,
568            encoder: &mut fidl::encoding::Encoder<'_, D>,
569            offset: usize,
570            depth: fidl::encoding::Depth,
571        ) -> fidl::Result<()> {
572            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerHistogramRequest>(offset);
573            // Zero out padding regions. There's no need to apply masks
574            // because the unmasked parts will be overwritten by fields.
575            unsafe {
576                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
577                (ptr as *mut u64).write_unaligned(0);
578            }
579            // Write the fields.
580            self.0.encode(encoder, offset + 0, depth)?;
581            self.1.encode(encoder, offset + 8, depth)?;
582            self.2.encode(encoder, offset + 24, depth)?;
583            Ok(())
584        }
585    }
586
587    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
588        for MetricEventLoggerLogIntegerHistogramRequest
589    {
590        #[inline(always)]
591        fn new_empty() -> Self {
592            Self {
593                metric_id: fidl::new_empty!(u32, D),
594                histogram: fidl::new_empty!(fidl::encoding::Vector<HistogramBucket, 500>, D),
595                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
596            }
597        }
598
599        #[inline]
600        unsafe fn decode(
601            &mut self,
602            decoder: &mut fidl::encoding::Decoder<'_, D>,
603            offset: usize,
604            _depth: fidl::encoding::Depth,
605        ) -> fidl::Result<()> {
606            decoder.debug_check_bounds::<Self>(offset);
607            // Verify that padding bytes are zero.
608            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
609            let padval = unsafe { (ptr as *const u64).read_unaligned() };
610            let mask = 0xffffffff00000000u64;
611            let maskedval = padval & mask;
612            if maskedval != 0 {
613                return Err(fidl::Error::NonZeroPadding {
614                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
615                });
616            }
617            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
618            fidl::decode!(fidl::encoding::Vector<HistogramBucket, 500>, D, &mut self.histogram, decoder, offset + 8, _depth)?;
619            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 24, _depth)?;
620            Ok(())
621        }
622    }
623
624    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogIntegerRequest {
625        type Borrowed<'a> = &'a Self;
626        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
627            value
628        }
629    }
630
631    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogIntegerRequest {
632        type Owned = Self;
633
634        #[inline(always)]
635        fn inline_align(_context: fidl::encoding::Context) -> usize {
636            8
637        }
638
639        #[inline(always)]
640        fn inline_size(_context: fidl::encoding::Context) -> usize {
641            32
642        }
643    }
644
645    unsafe impl<D: fidl::encoding::ResourceDialect>
646        fidl::encoding::Encode<MetricEventLoggerLogIntegerRequest, D>
647        for &MetricEventLoggerLogIntegerRequest
648    {
649        #[inline]
650        unsafe fn encode(
651            self,
652            encoder: &mut fidl::encoding::Encoder<'_, D>,
653            offset: usize,
654            _depth: fidl::encoding::Depth,
655        ) -> fidl::Result<()> {
656            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerRequest>(offset);
657            // Delegate to tuple encoding.
658            fidl::encoding::Encode::<MetricEventLoggerLogIntegerRequest, D>::encode(
659                (
660                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
661                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
662                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
663                        &self.event_codes,
664                    ),
665                ),
666                encoder,
667                offset,
668                _depth,
669            )
670        }
671    }
672    unsafe impl<
673            D: fidl::encoding::ResourceDialect,
674            T0: fidl::encoding::Encode<u32, D>,
675            T1: fidl::encoding::Encode<i64, D>,
676            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
677        > fidl::encoding::Encode<MetricEventLoggerLogIntegerRequest, D> for (T0, T1, T2)
678    {
679        #[inline]
680        unsafe fn encode(
681            self,
682            encoder: &mut fidl::encoding::Encoder<'_, D>,
683            offset: usize,
684            depth: fidl::encoding::Depth,
685        ) -> fidl::Result<()> {
686            encoder.debug_check_bounds::<MetricEventLoggerLogIntegerRequest>(offset);
687            // Zero out padding regions. There's no need to apply masks
688            // because the unmasked parts will be overwritten by fields.
689            unsafe {
690                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
691                (ptr as *mut u64).write_unaligned(0);
692            }
693            // Write the fields.
694            self.0.encode(encoder, offset + 0, depth)?;
695            self.1.encode(encoder, offset + 8, depth)?;
696            self.2.encode(encoder, offset + 16, depth)?;
697            Ok(())
698        }
699    }
700
701    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
702        for MetricEventLoggerLogIntegerRequest
703    {
704        #[inline(always)]
705        fn new_empty() -> Self {
706            Self {
707                metric_id: fidl::new_empty!(u32, D),
708                value: fidl::new_empty!(i64, D),
709                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
710            }
711        }
712
713        #[inline]
714        unsafe fn decode(
715            &mut self,
716            decoder: &mut fidl::encoding::Decoder<'_, D>,
717            offset: usize,
718            _depth: fidl::encoding::Depth,
719        ) -> fidl::Result<()> {
720            decoder.debug_check_bounds::<Self>(offset);
721            // Verify that padding bytes are zero.
722            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
723            let padval = unsafe { (ptr as *const u64).read_unaligned() };
724            let mask = 0xffffffff00000000u64;
725            let maskedval = padval & mask;
726            if maskedval != 0 {
727                return Err(fidl::Error::NonZeroPadding {
728                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
729                });
730            }
731            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
732            fidl::decode!(i64, D, &mut self.value, decoder, offset + 8, _depth)?;
733            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 16, _depth)?;
734            Ok(())
735        }
736    }
737
738    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogMetricEventsRequest {
739        type Borrowed<'a> = &'a Self;
740        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
741            value
742        }
743    }
744
745    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogMetricEventsRequest {
746        type Owned = Self;
747
748        #[inline(always)]
749        fn inline_align(_context: fidl::encoding::Context) -> usize {
750            8
751        }
752
753        #[inline(always)]
754        fn inline_size(_context: fidl::encoding::Context) -> usize {
755            16
756        }
757    }
758
759    unsafe impl<D: fidl::encoding::ResourceDialect>
760        fidl::encoding::Encode<MetricEventLoggerLogMetricEventsRequest, D>
761        for &MetricEventLoggerLogMetricEventsRequest
762    {
763        #[inline]
764        unsafe fn encode(
765            self,
766            encoder: &mut fidl::encoding::Encoder<'_, D>,
767            offset: usize,
768            _depth: fidl::encoding::Depth,
769        ) -> fidl::Result<()> {
770            encoder.debug_check_bounds::<MetricEventLoggerLogMetricEventsRequest>(offset);
771            // Delegate to tuple encoding.
772            fidl::encoding::Encode::<MetricEventLoggerLogMetricEventsRequest, D>::encode(
773                (
774                    <fidl::encoding::Vector<MetricEvent, 500> as fidl::encoding::ValueTypeMarker>::borrow(&self.events),
775                ),
776                encoder, offset, _depth
777            )
778        }
779    }
780    unsafe impl<
781            D: fidl::encoding::ResourceDialect,
782            T0: fidl::encoding::Encode<fidl::encoding::Vector<MetricEvent, 500>, D>,
783        > fidl::encoding::Encode<MetricEventLoggerLogMetricEventsRequest, D> for (T0,)
784    {
785        #[inline]
786        unsafe fn encode(
787            self,
788            encoder: &mut fidl::encoding::Encoder<'_, D>,
789            offset: usize,
790            depth: fidl::encoding::Depth,
791        ) -> fidl::Result<()> {
792            encoder.debug_check_bounds::<MetricEventLoggerLogMetricEventsRequest>(offset);
793            // Zero out padding regions. There's no need to apply masks
794            // because the unmasked parts will be overwritten by fields.
795            // Write the fields.
796            self.0.encode(encoder, offset + 0, depth)?;
797            Ok(())
798        }
799    }
800
801    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
802        for MetricEventLoggerLogMetricEventsRequest
803    {
804        #[inline(always)]
805        fn new_empty() -> Self {
806            Self { events: fidl::new_empty!(fidl::encoding::Vector<MetricEvent, 500>, D) }
807        }
808
809        #[inline]
810        unsafe fn decode(
811            &mut self,
812            decoder: &mut fidl::encoding::Decoder<'_, D>,
813            offset: usize,
814            _depth: fidl::encoding::Depth,
815        ) -> fidl::Result<()> {
816            decoder.debug_check_bounds::<Self>(offset);
817            // Verify that padding bytes are zero.
818            fidl::decode!(fidl::encoding::Vector<MetricEvent, 500>, D, &mut self.events, decoder, offset + 0, _depth)?;
819            Ok(())
820        }
821    }
822
823    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogOccurrenceRequest {
824        type Borrowed<'a> = &'a Self;
825        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
826            value
827        }
828    }
829
830    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogOccurrenceRequest {
831        type Owned = Self;
832
833        #[inline(always)]
834        fn inline_align(_context: fidl::encoding::Context) -> usize {
835            8
836        }
837
838        #[inline(always)]
839        fn inline_size(_context: fidl::encoding::Context) -> usize {
840            32
841        }
842    }
843
844    unsafe impl<D: fidl::encoding::ResourceDialect>
845        fidl::encoding::Encode<MetricEventLoggerLogOccurrenceRequest, D>
846        for &MetricEventLoggerLogOccurrenceRequest
847    {
848        #[inline]
849        unsafe fn encode(
850            self,
851            encoder: &mut fidl::encoding::Encoder<'_, D>,
852            offset: usize,
853            _depth: fidl::encoding::Depth,
854        ) -> fidl::Result<()> {
855            encoder.debug_check_bounds::<MetricEventLoggerLogOccurrenceRequest>(offset);
856            // Delegate to tuple encoding.
857            fidl::encoding::Encode::<MetricEventLoggerLogOccurrenceRequest, D>::encode(
858                (
859                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
860                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.count),
861                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
862                        &self.event_codes,
863                    ),
864                ),
865                encoder,
866                offset,
867                _depth,
868            )
869        }
870    }
871    unsafe impl<
872            D: fidl::encoding::ResourceDialect,
873            T0: fidl::encoding::Encode<u32, D>,
874            T1: fidl::encoding::Encode<u64, D>,
875            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
876        > fidl::encoding::Encode<MetricEventLoggerLogOccurrenceRequest, D> for (T0, T1, T2)
877    {
878        #[inline]
879        unsafe fn encode(
880            self,
881            encoder: &mut fidl::encoding::Encoder<'_, D>,
882            offset: usize,
883            depth: fidl::encoding::Depth,
884        ) -> fidl::Result<()> {
885            encoder.debug_check_bounds::<MetricEventLoggerLogOccurrenceRequest>(offset);
886            // Zero out padding regions. There's no need to apply masks
887            // because the unmasked parts will be overwritten by fields.
888            unsafe {
889                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
890                (ptr as *mut u64).write_unaligned(0);
891            }
892            // Write the fields.
893            self.0.encode(encoder, offset + 0, depth)?;
894            self.1.encode(encoder, offset + 8, depth)?;
895            self.2.encode(encoder, offset + 16, depth)?;
896            Ok(())
897        }
898    }
899
900    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
901        for MetricEventLoggerLogOccurrenceRequest
902    {
903        #[inline(always)]
904        fn new_empty() -> Self {
905            Self {
906                metric_id: fidl::new_empty!(u32, D),
907                count: fidl::new_empty!(u64, D),
908                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
909            }
910        }
911
912        #[inline]
913        unsafe fn decode(
914            &mut self,
915            decoder: &mut fidl::encoding::Decoder<'_, D>,
916            offset: usize,
917            _depth: fidl::encoding::Depth,
918        ) -> fidl::Result<()> {
919            decoder.debug_check_bounds::<Self>(offset);
920            // Verify that padding bytes are zero.
921            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
922            let padval = unsafe { (ptr as *const u64).read_unaligned() };
923            let mask = 0xffffffff00000000u64;
924            let maskedval = padval & mask;
925            if maskedval != 0 {
926                return Err(fidl::Error::NonZeroPadding {
927                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
928                });
929            }
930            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
931            fidl::decode!(u64, D, &mut self.count, decoder, offset + 8, _depth)?;
932            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 16, _depth)?;
933            Ok(())
934        }
935    }
936
937    impl fidl::encoding::ValueTypeMarker for MetricEventLoggerLogStringRequest {
938        type Borrowed<'a> = &'a Self;
939        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
940            value
941        }
942    }
943
944    unsafe impl fidl::encoding::TypeMarker for MetricEventLoggerLogStringRequest {
945        type Owned = Self;
946
947        #[inline(always)]
948        fn inline_align(_context: fidl::encoding::Context) -> usize {
949            8
950        }
951
952        #[inline(always)]
953        fn inline_size(_context: fidl::encoding::Context) -> usize {
954            40
955        }
956    }
957
958    unsafe impl<D: fidl::encoding::ResourceDialect>
959        fidl::encoding::Encode<MetricEventLoggerLogStringRequest, D>
960        for &MetricEventLoggerLogStringRequest
961    {
962        #[inline]
963        unsafe fn encode(
964            self,
965            encoder: &mut fidl::encoding::Encoder<'_, D>,
966            offset: usize,
967            _depth: fidl::encoding::Depth,
968        ) -> fidl::Result<()> {
969            encoder.debug_check_bounds::<MetricEventLoggerLogStringRequest>(offset);
970            // Delegate to tuple encoding.
971            fidl::encoding::Encode::<MetricEventLoggerLogStringRequest, D>::encode(
972                (
973                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.metric_id),
974                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
975                        &self.string_value,
976                    ),
977                    <fidl::encoding::Vector<u32, 10> as fidl::encoding::ValueTypeMarker>::borrow(
978                        &self.event_codes,
979                    ),
980                ),
981                encoder,
982                offset,
983                _depth,
984            )
985        }
986    }
987    unsafe impl<
988            D: fidl::encoding::ResourceDialect,
989            T0: fidl::encoding::Encode<u32, D>,
990            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
991            T2: fidl::encoding::Encode<fidl::encoding::Vector<u32, 10>, D>,
992        > fidl::encoding::Encode<MetricEventLoggerLogStringRequest, D> for (T0, T1, T2)
993    {
994        #[inline]
995        unsafe fn encode(
996            self,
997            encoder: &mut fidl::encoding::Encoder<'_, D>,
998            offset: usize,
999            depth: fidl::encoding::Depth,
1000        ) -> fidl::Result<()> {
1001            encoder.debug_check_bounds::<MetricEventLoggerLogStringRequest>(offset);
1002            // Zero out padding regions. There's no need to apply masks
1003            // because the unmasked parts will be overwritten by fields.
1004            unsafe {
1005                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1006                (ptr as *mut u64).write_unaligned(0);
1007            }
1008            // Write the fields.
1009            self.0.encode(encoder, offset + 0, depth)?;
1010            self.1.encode(encoder, offset + 8, depth)?;
1011            self.2.encode(encoder, offset + 24, depth)?;
1012            Ok(())
1013        }
1014    }
1015
1016    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1017        for MetricEventLoggerLogStringRequest
1018    {
1019        #[inline(always)]
1020        fn new_empty() -> Self {
1021            Self {
1022                metric_id: fidl::new_empty!(u32, D),
1023                string_value: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1024                event_codes: fidl::new_empty!(fidl::encoding::Vector<u32, 10>, D),
1025            }
1026        }
1027
1028        #[inline]
1029        unsafe fn decode(
1030            &mut self,
1031            decoder: &mut fidl::encoding::Decoder<'_, D>,
1032            offset: usize,
1033            _depth: fidl::encoding::Depth,
1034        ) -> fidl::Result<()> {
1035            decoder.debug_check_bounds::<Self>(offset);
1036            // Verify that padding bytes are zero.
1037            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1038            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1039            let mask = 0xffffffff00000000u64;
1040            let maskedval = padval & mask;
1041            if maskedval != 0 {
1042                return Err(fidl::Error::NonZeroPadding {
1043                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1044                });
1045            }
1046            fidl::decode!(u32, D, &mut self.metric_id, decoder, offset + 0, _depth)?;
1047            fidl::decode!(
1048                fidl::encoding::BoundedString<256>,
1049                D,
1050                &mut self.string_value,
1051                decoder,
1052                offset + 8,
1053                _depth
1054            )?;
1055            fidl::decode!(fidl::encoding::Vector<u32, 10>, D, &mut self.event_codes, decoder, offset + 24, _depth)?;
1056            Ok(())
1057        }
1058    }
1059
1060    impl ProjectSpec {
1061        #[inline(always)]
1062        fn max_ordinal_present(&self) -> u64 {
1063            if let Some(_) = self.project_id {
1064                return 2;
1065            }
1066            if let Some(_) = self.customer_id {
1067                return 1;
1068            }
1069            0
1070        }
1071    }
1072
1073    impl fidl::encoding::ValueTypeMarker for ProjectSpec {
1074        type Borrowed<'a> = &'a Self;
1075        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1076            value
1077        }
1078    }
1079
1080    unsafe impl fidl::encoding::TypeMarker for ProjectSpec {
1081        type Owned = Self;
1082
1083        #[inline(always)]
1084        fn inline_align(_context: fidl::encoding::Context) -> usize {
1085            8
1086        }
1087
1088        #[inline(always)]
1089        fn inline_size(_context: fidl::encoding::Context) -> usize {
1090            16
1091        }
1092    }
1093
1094    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProjectSpec, D>
1095        for &ProjectSpec
1096    {
1097        unsafe fn encode(
1098            self,
1099            encoder: &mut fidl::encoding::Encoder<'_, D>,
1100            offset: usize,
1101            mut depth: fidl::encoding::Depth,
1102        ) -> fidl::Result<()> {
1103            encoder.debug_check_bounds::<ProjectSpec>(offset);
1104            // Vector header
1105            let max_ordinal: u64 = self.max_ordinal_present();
1106            encoder.write_num(max_ordinal, offset);
1107            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1108            // Calling encoder.out_of_line_offset(0) is not allowed.
1109            if max_ordinal == 0 {
1110                return Ok(());
1111            }
1112            depth.increment()?;
1113            let envelope_size = 8;
1114            let bytes_len = max_ordinal as usize * envelope_size;
1115            #[allow(unused_variables)]
1116            let offset = encoder.out_of_line_offset(bytes_len);
1117            let mut _prev_end_offset: usize = 0;
1118            if 1 > max_ordinal {
1119                return Ok(());
1120            }
1121
1122            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1123            // are envelope_size bytes.
1124            let cur_offset: usize = (1 - 1) * envelope_size;
1125
1126            // Zero reserved fields.
1127            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1128
1129            // Safety:
1130            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1131            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1132            //   envelope_size bytes, there is always sufficient room.
1133            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1134                self.customer_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1135                encoder,
1136                offset + cur_offset,
1137                depth,
1138            )?;
1139
1140            _prev_end_offset = cur_offset + envelope_size;
1141            if 2 > max_ordinal {
1142                return Ok(());
1143            }
1144
1145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1146            // are envelope_size bytes.
1147            let cur_offset: usize = (2 - 1) * envelope_size;
1148
1149            // Zero reserved fields.
1150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1151
1152            // Safety:
1153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1155            //   envelope_size bytes, there is always sufficient room.
1156            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1157                self.project_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1158                encoder,
1159                offset + cur_offset,
1160                depth,
1161            )?;
1162
1163            _prev_end_offset = cur_offset + envelope_size;
1164
1165            Ok(())
1166        }
1167    }
1168
1169    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProjectSpec {
1170        #[inline(always)]
1171        fn new_empty() -> Self {
1172            Self::default()
1173        }
1174
1175        unsafe fn decode(
1176            &mut self,
1177            decoder: &mut fidl::encoding::Decoder<'_, D>,
1178            offset: usize,
1179            mut depth: fidl::encoding::Depth,
1180        ) -> fidl::Result<()> {
1181            decoder.debug_check_bounds::<Self>(offset);
1182            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1183                None => return Err(fidl::Error::NotNullable),
1184                Some(len) => len,
1185            };
1186            // Calling decoder.out_of_line_offset(0) is not allowed.
1187            if len == 0 {
1188                return Ok(());
1189            };
1190            depth.increment()?;
1191            let envelope_size = 8;
1192            let bytes_len = len * envelope_size;
1193            let offset = decoder.out_of_line_offset(bytes_len)?;
1194            // Decode the envelope for each type.
1195            let mut _next_ordinal_to_read = 0;
1196            let mut next_offset = offset;
1197            let end_offset = offset + bytes_len;
1198            _next_ordinal_to_read += 1;
1199            if next_offset >= end_offset {
1200                return Ok(());
1201            }
1202
1203            // Decode unknown envelopes for gaps in ordinals.
1204            while _next_ordinal_to_read < 1 {
1205                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1206                _next_ordinal_to_read += 1;
1207                next_offset += envelope_size;
1208            }
1209
1210            let next_out_of_line = decoder.next_out_of_line();
1211            let handles_before = decoder.remaining_handles();
1212            if let Some((inlined, num_bytes, num_handles)) =
1213                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1214            {
1215                let member_inline_size =
1216                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1217                if inlined != (member_inline_size <= 4) {
1218                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1219                }
1220                let inner_offset;
1221                let mut inner_depth = depth.clone();
1222                if inlined {
1223                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1224                    inner_offset = next_offset;
1225                } else {
1226                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1227                    inner_depth.increment()?;
1228                }
1229                let val_ref = self.customer_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1230                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1231                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1232                {
1233                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1234                }
1235                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1236                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1237                }
1238            }
1239
1240            next_offset += envelope_size;
1241            _next_ordinal_to_read += 1;
1242            if next_offset >= end_offset {
1243                return Ok(());
1244            }
1245
1246            // Decode unknown envelopes for gaps in ordinals.
1247            while _next_ordinal_to_read < 2 {
1248                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1249                _next_ordinal_to_read += 1;
1250                next_offset += envelope_size;
1251            }
1252
1253            let next_out_of_line = decoder.next_out_of_line();
1254            let handles_before = decoder.remaining_handles();
1255            if let Some((inlined, num_bytes, num_handles)) =
1256                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1257            {
1258                let member_inline_size =
1259                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1260                if inlined != (member_inline_size <= 4) {
1261                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1262                }
1263                let inner_offset;
1264                let mut inner_depth = depth.clone();
1265                if inlined {
1266                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1267                    inner_offset = next_offset;
1268                } else {
1269                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1270                    inner_depth.increment()?;
1271                }
1272                let val_ref = self.project_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1273                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1274                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1275                {
1276                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1277                }
1278                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1279                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1280                }
1281            }
1282
1283            next_offset += envelope_size;
1284
1285            // Decode the remaining unknown envelopes.
1286            while next_offset < end_offset {
1287                _next_ordinal_to_read += 1;
1288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1289                next_offset += envelope_size;
1290            }
1291
1292            Ok(())
1293        }
1294    }
1295
1296    impl fidl::encoding::ValueTypeMarker for MetricEventPayload {
1297        type Borrowed<'a> = &'a Self;
1298        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1299            value
1300        }
1301    }
1302
1303    unsafe impl fidl::encoding::TypeMarker for MetricEventPayload {
1304        type Owned = Self;
1305
1306        #[inline(always)]
1307        fn inline_align(_context: fidl::encoding::Context) -> usize {
1308            8
1309        }
1310
1311        #[inline(always)]
1312        fn inline_size(_context: fidl::encoding::Context) -> usize {
1313            16
1314        }
1315    }
1316
1317    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MetricEventPayload, D>
1318        for &MetricEventPayload
1319    {
1320        #[inline]
1321        unsafe fn encode(
1322            self,
1323            encoder: &mut fidl::encoding::Encoder<'_, D>,
1324            offset: usize,
1325            _depth: fidl::encoding::Depth,
1326        ) -> fidl::Result<()> {
1327            encoder.debug_check_bounds::<MetricEventPayload>(offset);
1328            encoder.write_num::<u64>(self.ordinal(), offset);
1329            match self {
1330            MetricEventPayload::Count(ref val) => {
1331                fidl::encoding::encode_in_envelope::<u64, D>(
1332                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
1333                    encoder, offset + 8, _depth
1334                )
1335            }
1336            MetricEventPayload::IntegerValue(ref val) => {
1337                fidl::encoding::encode_in_envelope::<i64, D>(
1338                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
1339                    encoder, offset + 8, _depth
1340                )
1341            }
1342            MetricEventPayload::Histogram(ref val) => {
1343                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<HistogramBucket, 500>, D>(
1344                    <fidl::encoding::Vector<HistogramBucket, 500> as fidl::encoding::ValueTypeMarker>::borrow(val),
1345                    encoder, offset + 8, _depth
1346                )
1347            }
1348            MetricEventPayload::StringValue(ref val) => {
1349                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<256>, D>(
1350                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(val),
1351                    encoder, offset + 8, _depth
1352                )
1353            }
1354            MetricEventPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
1355        }
1356        }
1357    }
1358
1359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MetricEventPayload {
1360        #[inline(always)]
1361        fn new_empty() -> Self {
1362            Self::__SourceBreaking { unknown_ordinal: 0 }
1363        }
1364
1365        #[inline]
1366        unsafe fn decode(
1367            &mut self,
1368            decoder: &mut fidl::encoding::Decoder<'_, D>,
1369            offset: usize,
1370            mut depth: fidl::encoding::Depth,
1371        ) -> fidl::Result<()> {
1372            decoder.debug_check_bounds::<Self>(offset);
1373            #[allow(unused_variables)]
1374            let next_out_of_line = decoder.next_out_of_line();
1375            let handles_before = decoder.remaining_handles();
1376            let (ordinal, inlined, num_bytes, num_handles) =
1377                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1378
1379            let member_inline_size = match ordinal {
1380            1 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1381            2 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1382            3 => <fidl::encoding::Vector<HistogramBucket, 500> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1383            4 => <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1384            0 => return Err(fidl::Error::UnknownUnionTag),
1385            _ => num_bytes as usize,
1386        };
1387
1388            if inlined != (member_inline_size <= 4) {
1389                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1390            }
1391            let _inner_offset;
1392            if inlined {
1393                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1394                _inner_offset = offset + 8;
1395            } else {
1396                depth.increment()?;
1397                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1398            }
1399            match ordinal {
1400                1 => {
1401                    #[allow(irrefutable_let_patterns)]
1402                    if let MetricEventPayload::Count(_) = self {
1403                        // Do nothing, read the value into the object
1404                    } else {
1405                        // Initialize `self` to the right variant
1406                        *self = MetricEventPayload::Count(fidl::new_empty!(u64, D));
1407                    }
1408                    #[allow(irrefutable_let_patterns)]
1409                    if let MetricEventPayload::Count(ref mut val) = self {
1410                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
1411                    } else {
1412                        unreachable!()
1413                    }
1414                }
1415                2 => {
1416                    #[allow(irrefutable_let_patterns)]
1417                    if let MetricEventPayload::IntegerValue(_) = self {
1418                        // Do nothing, read the value into the object
1419                    } else {
1420                        // Initialize `self` to the right variant
1421                        *self = MetricEventPayload::IntegerValue(fidl::new_empty!(i64, D));
1422                    }
1423                    #[allow(irrefutable_let_patterns)]
1424                    if let MetricEventPayload::IntegerValue(ref mut val) = self {
1425                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
1426                    } else {
1427                        unreachable!()
1428                    }
1429                }
1430                3 => {
1431                    #[allow(irrefutable_let_patterns)]
1432                    if let MetricEventPayload::Histogram(_) = self {
1433                        // Do nothing, read the value into the object
1434                    } else {
1435                        // Initialize `self` to the right variant
1436                        *self = MetricEventPayload::Histogram(
1437                            fidl::new_empty!(fidl::encoding::Vector<HistogramBucket, 500>, D),
1438                        );
1439                    }
1440                    #[allow(irrefutable_let_patterns)]
1441                    if let MetricEventPayload::Histogram(ref mut val) = self {
1442                        fidl::decode!(fidl::encoding::Vector<HistogramBucket, 500>, D, val, decoder, _inner_offset, depth)?;
1443                    } else {
1444                        unreachable!()
1445                    }
1446                }
1447                4 => {
1448                    #[allow(irrefutable_let_patterns)]
1449                    if let MetricEventPayload::StringValue(_) = self {
1450                        // Do nothing, read the value into the object
1451                    } else {
1452                        // Initialize `self` to the right variant
1453                        *self = MetricEventPayload::StringValue(fidl::new_empty!(
1454                            fidl::encoding::BoundedString<256>,
1455                            D
1456                        ));
1457                    }
1458                    #[allow(irrefutable_let_patterns)]
1459                    if let MetricEventPayload::StringValue(ref mut val) = self {
1460                        fidl::decode!(
1461                            fidl::encoding::BoundedString<256>,
1462                            D,
1463                            val,
1464                            decoder,
1465                            _inner_offset,
1466                            depth
1467                        )?;
1468                    } else {
1469                        unreachable!()
1470                    }
1471                }
1472                #[allow(deprecated)]
1473                ordinal => {
1474                    for _ in 0..num_handles {
1475                        decoder.drop_next_handle()?;
1476                    }
1477                    *self = MetricEventPayload::__SourceBreaking { unknown_ordinal: ordinal };
1478                }
1479            }
1480            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1481                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1482            }
1483            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1484                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1485            }
1486            Ok(())
1487        }
1488    }
1489}