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