1#![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
11pub type EventVector = Vec<u32>;
15
16pub type IntegerHistogram = Vec<HistogramBucket>;
21
22pub const MAX_BATCHED_EVENTS: u32 = 500;
24
25pub const MAX_BYTES_PER_EVENT: i64 = 102400;
27
28pub const MAX_EXPERIMENT_IDS: u32 = 100;
30
31pub const MAX_HISTOGRAM_BUCKETS: u32 = 500;
34
35pub const MAX_METRIC_DIMENSIONS: u32 = 10;
37
38pub const MAX_STRING_EVENT_SIZE: u32 = 256;
40
41#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
43#[repr(i32)]
44pub enum Error {
45 InvalidArguments = 1,
47 EventTooBig = 2,
50 BufferFull = 3,
53 ShutDown = 4,
54 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#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
79#[repr(C)]
80pub struct HistogramBucket {
81 pub index: u32,
85 pub count: u64,
88}
89
90impl fidl::Persistable for HistogramBucket {}
91
92#[derive(Clone, Debug, PartialEq)]
94pub struct MetricEvent {
95 pub metric_id: u32,
97 pub event_codes: Vec<u32>,
100 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#[derive(Clone, Debug, Default, PartialEq)]
151pub struct ProjectSpec {
152 pub customer_id: Option<u32>,
155 pub project_id: Option<u32>,
157 #[doc(hidden)]
158 pub __source_breaking: fidl::marker::SourceBreaking,
159}
160
161impl fidl::Persistable for ProjectSpec {}
162
163#[derive(Clone, Debug)]
165pub enum MetricEventPayload {
166 Count(u64),
168 IntegerValue(i64),
170 Histogram(Vec<HistogramBucket>),
173 StringValue(String),
175 #[doc(hidden)]
176 __SourceBreaking { unknown_ordinal: u64 },
177}
178
179#[macro_export]
181macro_rules! MetricEventPayloadUnknown {
182 () => {
183 _
184 };
185}
186
187impl 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 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 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 unsafe {
360 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
361 (ptr as *mut u64).write_unaligned(0);
362 }
363 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 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 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 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 unsafe {
468 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
469 (ptr as *mut u64).write_unaligned(0);
470 }
471 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 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 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 unsafe {
576 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
577 (ptr as *mut u64).write_unaligned(0);
578 }
579 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 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 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 unsafe {
690 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
691 (ptr as *mut u64).write_unaligned(0);
692 }
693 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 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 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 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 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 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 unsafe {
889 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
890 (ptr as *mut u64).write_unaligned(0);
891 }
892 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 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 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 unsafe {
1005 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1006 (ptr as *mut u64).write_unaligned(0);
1007 }
1008 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1125
1126 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1128
1129 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 let cur_offset: usize = (2 - 1) * envelope_size;
1148
1149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1151
1152 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 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 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 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 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 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 } else {
1405 *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 } else {
1420 *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 } else {
1435 *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 } else {
1452 *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}