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 const CONVERSATION_ID_LENGTH: u8 = 16;
12
13pub const MAX_FOLDER_LENGTH: u16 = 512;
14
15pub const MAX_NUM_MAS_INSTANCE_LENGTH: u16 = 256;
16
17pub const MAX_SENDER_ADDR_LENGTH: u16 = 256;
18
19pub const MAX_SENDER_NAME_LENGTH: u16 = 256;
20
21pub const MAX_SUBJECT_LENGTH: u16 = 256;
22
23bitflags! {
24 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
28 pub struct MessageType: u8 {
29 const EMAIL = 1;
30 const SMS_GSM = 2;
31 const SMS_CDMA = 4;
32 const MMS = 8;
33 const IM = 16;
34 }
35}
36
37impl MessageType {
38 #[inline(always)]
39 pub fn from_bits_allow_unknown(bits: u8) -> Self {
40 Self::from_bits_retain(bits)
41 }
42
43 #[inline(always)]
44 pub fn has_unknown_bits(&self) -> bool {
45 self.get_unknown_bits() != 0
46 }
47
48 #[inline(always)]
49 pub fn get_unknown_bits(&self) -> u8 {
50 self.bits() & !Self::all().bits()
51 }
52}
53
54#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57#[repr(u32)]
58pub enum Error {
59 Unknown = 1,
61 PeerDisconnected = 2,
63 NotFound = 3,
65 BadRequest = 4,
68 NotImplemented = 5,
70 Unauthorized = 6,
72 Unavailable = 7,
74 NotSupported = 8,
76}
77
78impl Error {
79 #[inline]
80 pub fn from_primitive(prim: u32) -> Option<Self> {
81 match prim {
82 1 => Some(Self::Unknown),
83 2 => Some(Self::PeerDisconnected),
84 3 => Some(Self::NotFound),
85 4 => Some(Self::BadRequest),
86 5 => Some(Self::NotImplemented),
87 6 => Some(Self::Unauthorized),
88 7 => Some(Self::Unavailable),
89 8 => Some(Self::NotSupported),
90 _ => None,
91 }
92 }
93
94 #[inline]
95 pub const fn into_primitive(self) -> u32 {
96 self as u32
97 }
98}
99
100#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
104pub enum NotificationType {
105 NewMessage,
106 DeliverySuccess,
107 SendingSuccess,
108 DeliveryFailure,
109 SendingFailure,
110 MessageDeleted,
111 MessageShift,
112 ReadStatusChanged,
113 #[doc(hidden)]
114 __SourceBreaking {
115 unknown_ordinal: u32,
116 },
117}
118
119#[macro_export]
121macro_rules! NotificationTypeUnknown {
122 () => {
123 _
124 };
125}
126
127impl NotificationType {
128 #[inline]
129 pub fn from_primitive(prim: u32) -> Option<Self> {
130 match prim {
131 1 => Some(Self::NewMessage),
132 2 => Some(Self::DeliverySuccess),
133 3 => Some(Self::SendingSuccess),
134 4 => Some(Self::DeliveryFailure),
135 5 => Some(Self::SendingFailure),
136 6 => Some(Self::MessageDeleted),
137 7 => Some(Self::MessageShift),
138 8 => Some(Self::ReadStatusChanged),
139 _ => None,
140 }
141 }
142
143 #[inline]
144 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
145 match prim {
146 1 => Self::NewMessage,
147 2 => Self::DeliverySuccess,
148 3 => Self::SendingSuccess,
149 4 => Self::DeliveryFailure,
150 5 => Self::SendingFailure,
151 6 => Self::MessageDeleted,
152 7 => Self::MessageShift,
153 8 => Self::ReadStatusChanged,
154 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
155 }
156 }
157
158 #[inline]
159 pub fn unknown() -> Self {
160 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
161 }
162
163 #[inline]
164 pub const fn into_primitive(self) -> u32 {
165 match self {
166 Self::NewMessage => 1,
167 Self::DeliverySuccess => 2,
168 Self::SendingSuccess => 3,
169 Self::DeliveryFailure => 4,
170 Self::SendingFailure => 5,
171 Self::MessageDeleted => 6,
172 Self::MessageShift => 7,
173 Self::ReadStatusChanged => 8,
174 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
175 }
176 }
177
178 #[inline]
179 pub fn is_unknown(&self) -> bool {
180 match self {
181 Self::__SourceBreaking { unknown_ordinal: _ } => true,
182 _ => false,
183 }
184 }
185}
186
187#[derive(Clone, Debug, PartialEq)]
188pub struct AccessorListAllMasInstancesResponse {
189 pub instances: Vec<MasInstance>,
190}
191
192impl fidl::Persistable for AccessorListAllMasInstancesResponse {}
193
194#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
195pub struct MessageControllerGetDetailsRequest {
196 pub handle: u64,
197 pub include_attachment: bool,
198}
199
200impl fidl::Persistable for MessageControllerGetDetailsRequest {}
201
202#[derive(Clone, Debug, Default, PartialEq)]
203pub struct Audience {
204 pub addressing: Option<String>,
209 pub name: Option<String>,
211 #[doc(hidden)]
212 pub __source_breaking: fidl::marker::SourceBreaking,
213}
214
215impl fidl::Persistable for Audience {}
216
217#[derive(Clone, Debug, Default, PartialEq)]
220pub struct MasInstance {
221 pub id: Option<u8>,
222 pub supported_message_types: Option<MessageType>,
223 pub supports_notification: Option<bool>,
224 #[doc(hidden)]
225 pub __source_breaking: fidl::marker::SourceBreaking,
226}
227
228impl fidl::Persistable for MasInstance {}
229
230#[derive(Clone, Debug, Default, PartialEq)]
235pub struct Message {
236 pub handle: Option<u64>,
240 pub subject: Option<String>,
242 pub timestamp: Option<i64>,
245 pub sender: Option<Audience>,
247 pub recipient: Option<Audience>,
249 pub type_: Option<MessageType>,
252 pub content: Option<String>,
254 pub folder: Option<String>,
256 pub priority: Option<bool>,
259 pub read: Option<bool>,
262 pub sent: Option<bool>,
265 pub protected: Option<bool>,
267 pub conversation_id: Option<[u8; 16]>,
269 #[doc(hidden)]
270 pub __source_breaking: fidl::marker::SourceBreaking,
271}
272
273impl fidl::Persistable for Message {}
274
275#[derive(Clone, Debug, Default, PartialEq)]
279pub struct Notification {
280 pub type_: Option<NotificationType>,
281 pub mas_instance_id: Option<u8>,
282 pub message_handle: Option<u64>,
283 pub folder: Option<String>,
284 pub message_type: Option<MessageType>,
285 pub timestamp: Option<i64>,
286 pub subject: Option<String>,
287 pub sender: Option<Audience>,
288 pub priority: Option<bool>,
289 #[doc(hidden)]
290 pub __source_breaking: fidl::marker::SourceBreaking,
291}
292
293impl fidl::Persistable for Notification {}
294
295#[derive(Clone, Debug, Default, PartialEq)]
296pub struct NotificationRegistrationNewEventReportRequest {
297 pub notification: Option<Notification>,
298 pub received: Option<i64>,
299 #[doc(hidden)]
300 pub __source_breaking: fidl::marker::SourceBreaking,
301}
302
303impl fidl::Persistable for NotificationRegistrationNewEventReportRequest {}
304
305pub mod accessor_ordinals {
306 pub const GET_DETAILS: u64 = 0x7c3667b69d66691e;
307 pub const LIST_ALL_MAS_INSTANCES: u64 = 0x6c78ebf9ba9780bd;
308 pub const SET_NOTIFICATION_REGISTRATION: u64 = 0x3d764e196f83bd7c;
309}
310
311pub mod message_controller_ordinals {
312 pub const GET_DETAILS: u64 = 0x7c3667b69d66691e;
313}
314
315pub mod messaging_client_ordinals {
316 pub const WATCH_ACCESSOR: u64 = 0x269e876c67302299;
317}
318
319pub mod notification_registration_ordinals {
320 pub const NEW_EVENT_REPORT: u64 = 0x4c7d185363415f14;
321}
322
323mod internal {
324 use super::*;
325 unsafe impl fidl::encoding::TypeMarker for MessageType {
326 type Owned = Self;
327
328 #[inline(always)]
329 fn inline_align(_context: fidl::encoding::Context) -> usize {
330 1
331 }
332
333 #[inline(always)]
334 fn inline_size(_context: fidl::encoding::Context) -> usize {
335 1
336 }
337 }
338
339 impl fidl::encoding::ValueTypeMarker for MessageType {
340 type Borrowed<'a> = Self;
341 #[inline(always)]
342 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
343 *value
344 }
345 }
346
347 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MessageType {
348 #[inline]
349 unsafe fn encode(
350 self,
351 encoder: &mut fidl::encoding::Encoder<'_, D>,
352 offset: usize,
353 _depth: fidl::encoding::Depth,
354 ) -> fidl::Result<()> {
355 encoder.debug_check_bounds::<Self>(offset);
356 encoder.write_num(self.bits(), offset);
357 Ok(())
358 }
359 }
360
361 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MessageType {
362 #[inline(always)]
363 fn new_empty() -> Self {
364 Self::empty()
365 }
366
367 #[inline]
368 unsafe fn decode(
369 &mut self,
370 decoder: &mut fidl::encoding::Decoder<'_, D>,
371 offset: usize,
372 _depth: fidl::encoding::Depth,
373 ) -> fidl::Result<()> {
374 decoder.debug_check_bounds::<Self>(offset);
375 let prim = decoder.read_num::<u8>(offset);
376 *self = Self::from_bits_allow_unknown(prim);
377 Ok(())
378 }
379 }
380 unsafe impl fidl::encoding::TypeMarker for Error {
381 type Owned = Self;
382
383 #[inline(always)]
384 fn inline_align(_context: fidl::encoding::Context) -> usize {
385 std::mem::align_of::<u32>()
386 }
387
388 #[inline(always)]
389 fn inline_size(_context: fidl::encoding::Context) -> usize {
390 std::mem::size_of::<u32>()
391 }
392
393 #[inline(always)]
394 fn encode_is_copy() -> bool {
395 true
396 }
397
398 #[inline(always)]
399 fn decode_is_copy() -> bool {
400 false
401 }
402 }
403
404 impl fidl::encoding::ValueTypeMarker for Error {
405 type Borrowed<'a> = Self;
406 #[inline(always)]
407 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
408 *value
409 }
410 }
411
412 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
413 #[inline]
414 unsafe fn encode(
415 self,
416 encoder: &mut fidl::encoding::Encoder<'_, D>,
417 offset: usize,
418 _depth: fidl::encoding::Depth,
419 ) -> fidl::Result<()> {
420 encoder.debug_check_bounds::<Self>(offset);
421 encoder.write_num(self.into_primitive(), offset);
422 Ok(())
423 }
424 }
425
426 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
427 #[inline(always)]
428 fn new_empty() -> Self {
429 Self::Unknown
430 }
431
432 #[inline]
433 unsafe fn decode(
434 &mut self,
435 decoder: &mut fidl::encoding::Decoder<'_, D>,
436 offset: usize,
437 _depth: fidl::encoding::Depth,
438 ) -> fidl::Result<()> {
439 decoder.debug_check_bounds::<Self>(offset);
440 let prim = decoder.read_num::<u32>(offset);
441
442 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
443 Ok(())
444 }
445 }
446 unsafe impl fidl::encoding::TypeMarker for NotificationType {
447 type Owned = Self;
448
449 #[inline(always)]
450 fn inline_align(_context: fidl::encoding::Context) -> usize {
451 std::mem::align_of::<u32>()
452 }
453
454 #[inline(always)]
455 fn inline_size(_context: fidl::encoding::Context) -> usize {
456 std::mem::size_of::<u32>()
457 }
458
459 #[inline(always)]
460 fn encode_is_copy() -> bool {
461 false
462 }
463
464 #[inline(always)]
465 fn decode_is_copy() -> bool {
466 false
467 }
468 }
469
470 impl fidl::encoding::ValueTypeMarker for NotificationType {
471 type Borrowed<'a> = Self;
472 #[inline(always)]
473 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
474 *value
475 }
476 }
477
478 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
479 for NotificationType
480 {
481 #[inline]
482 unsafe fn encode(
483 self,
484 encoder: &mut fidl::encoding::Encoder<'_, D>,
485 offset: usize,
486 _depth: fidl::encoding::Depth,
487 ) -> fidl::Result<()> {
488 encoder.debug_check_bounds::<Self>(offset);
489 encoder.write_num(self.into_primitive(), offset);
490 Ok(())
491 }
492 }
493
494 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NotificationType {
495 #[inline(always)]
496 fn new_empty() -> Self {
497 Self::unknown()
498 }
499
500 #[inline]
501 unsafe fn decode(
502 &mut self,
503 decoder: &mut fidl::encoding::Decoder<'_, D>,
504 offset: usize,
505 _depth: fidl::encoding::Depth,
506 ) -> fidl::Result<()> {
507 decoder.debug_check_bounds::<Self>(offset);
508 let prim = decoder.read_num::<u32>(offset);
509
510 *self = Self::from_primitive_allow_unknown(prim);
511 Ok(())
512 }
513 }
514
515 impl fidl::encoding::ValueTypeMarker for AccessorListAllMasInstancesResponse {
516 type Borrowed<'a> = &'a Self;
517 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
518 value
519 }
520 }
521
522 unsafe impl fidl::encoding::TypeMarker for AccessorListAllMasInstancesResponse {
523 type Owned = Self;
524
525 #[inline(always)]
526 fn inline_align(_context: fidl::encoding::Context) -> usize {
527 8
528 }
529
530 #[inline(always)]
531 fn inline_size(_context: fidl::encoding::Context) -> usize {
532 16
533 }
534 }
535
536 unsafe impl<D: fidl::encoding::ResourceDialect>
537 fidl::encoding::Encode<AccessorListAllMasInstancesResponse, D>
538 for &AccessorListAllMasInstancesResponse
539 {
540 #[inline]
541 unsafe fn encode(
542 self,
543 encoder: &mut fidl::encoding::Encoder<'_, D>,
544 offset: usize,
545 _depth: fidl::encoding::Depth,
546 ) -> fidl::Result<()> {
547 encoder.debug_check_bounds::<AccessorListAllMasInstancesResponse>(offset);
548 fidl::encoding::Encode::<AccessorListAllMasInstancesResponse, D>::encode(
550 (
551 <fidl::encoding::Vector<MasInstance, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.instances),
552 ),
553 encoder, offset, _depth
554 )
555 }
556 }
557 unsafe impl<
558 D: fidl::encoding::ResourceDialect,
559 T0: fidl::encoding::Encode<fidl::encoding::Vector<MasInstance, 256>, D>,
560 > fidl::encoding::Encode<AccessorListAllMasInstancesResponse, D> for (T0,)
561 {
562 #[inline]
563 unsafe fn encode(
564 self,
565 encoder: &mut fidl::encoding::Encoder<'_, D>,
566 offset: usize,
567 depth: fidl::encoding::Depth,
568 ) -> fidl::Result<()> {
569 encoder.debug_check_bounds::<AccessorListAllMasInstancesResponse>(offset);
570 self.0.encode(encoder, offset + 0, depth)?;
574 Ok(())
575 }
576 }
577
578 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
579 for AccessorListAllMasInstancesResponse
580 {
581 #[inline(always)]
582 fn new_empty() -> Self {
583 Self { instances: fidl::new_empty!(fidl::encoding::Vector<MasInstance, 256>, D) }
584 }
585
586 #[inline]
587 unsafe fn decode(
588 &mut self,
589 decoder: &mut fidl::encoding::Decoder<'_, D>,
590 offset: usize,
591 _depth: fidl::encoding::Depth,
592 ) -> fidl::Result<()> {
593 decoder.debug_check_bounds::<Self>(offset);
594 fidl::decode!(fidl::encoding::Vector<MasInstance, 256>, D, &mut self.instances, decoder, offset + 0, _depth)?;
596 Ok(())
597 }
598 }
599
600 impl fidl::encoding::ValueTypeMarker for MessageControllerGetDetailsRequest {
601 type Borrowed<'a> = &'a Self;
602 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
603 value
604 }
605 }
606
607 unsafe impl fidl::encoding::TypeMarker for MessageControllerGetDetailsRequest {
608 type Owned = Self;
609
610 #[inline(always)]
611 fn inline_align(_context: fidl::encoding::Context) -> usize {
612 8
613 }
614
615 #[inline(always)]
616 fn inline_size(_context: fidl::encoding::Context) -> usize {
617 16
618 }
619 }
620
621 unsafe impl<D: fidl::encoding::ResourceDialect>
622 fidl::encoding::Encode<MessageControllerGetDetailsRequest, D>
623 for &MessageControllerGetDetailsRequest
624 {
625 #[inline]
626 unsafe fn encode(
627 self,
628 encoder: &mut fidl::encoding::Encoder<'_, D>,
629 offset: usize,
630 _depth: fidl::encoding::Depth,
631 ) -> fidl::Result<()> {
632 encoder.debug_check_bounds::<MessageControllerGetDetailsRequest>(offset);
633 fidl::encoding::Encode::<MessageControllerGetDetailsRequest, D>::encode(
635 (
636 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.handle),
637 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_attachment),
638 ),
639 encoder,
640 offset,
641 _depth,
642 )
643 }
644 }
645 unsafe impl<
646 D: fidl::encoding::ResourceDialect,
647 T0: fidl::encoding::Encode<u64, D>,
648 T1: fidl::encoding::Encode<bool, D>,
649 > fidl::encoding::Encode<MessageControllerGetDetailsRequest, D> for (T0, T1)
650 {
651 #[inline]
652 unsafe fn encode(
653 self,
654 encoder: &mut fidl::encoding::Encoder<'_, D>,
655 offset: usize,
656 depth: fidl::encoding::Depth,
657 ) -> fidl::Result<()> {
658 encoder.debug_check_bounds::<MessageControllerGetDetailsRequest>(offset);
659 unsafe {
662 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
663 (ptr as *mut u64).write_unaligned(0);
664 }
665 self.0.encode(encoder, offset + 0, depth)?;
667 self.1.encode(encoder, offset + 8, depth)?;
668 Ok(())
669 }
670 }
671
672 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
673 for MessageControllerGetDetailsRequest
674 {
675 #[inline(always)]
676 fn new_empty() -> Self {
677 Self { handle: fidl::new_empty!(u64, D), include_attachment: fidl::new_empty!(bool, D) }
678 }
679
680 #[inline]
681 unsafe fn decode(
682 &mut self,
683 decoder: &mut fidl::encoding::Decoder<'_, D>,
684 offset: usize,
685 _depth: fidl::encoding::Depth,
686 ) -> fidl::Result<()> {
687 decoder.debug_check_bounds::<Self>(offset);
688 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
690 let padval = unsafe { (ptr as *const u64).read_unaligned() };
691 let mask = 0xffffffffffffff00u64;
692 let maskedval = padval & mask;
693 if maskedval != 0 {
694 return Err(fidl::Error::NonZeroPadding {
695 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
696 });
697 }
698 fidl::decode!(u64, D, &mut self.handle, decoder, offset + 0, _depth)?;
699 fidl::decode!(bool, D, &mut self.include_attachment, decoder, offset + 8, _depth)?;
700 Ok(())
701 }
702 }
703
704 impl Audience {
705 #[inline(always)]
706 fn max_ordinal_present(&self) -> u64 {
707 if let Some(_) = self.name {
708 return 2;
709 }
710 if let Some(_) = self.addressing {
711 return 1;
712 }
713 0
714 }
715 }
716
717 impl fidl::encoding::ValueTypeMarker for Audience {
718 type Borrowed<'a> = &'a Self;
719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
720 value
721 }
722 }
723
724 unsafe impl fidl::encoding::TypeMarker for Audience {
725 type Owned = Self;
726
727 #[inline(always)]
728 fn inline_align(_context: fidl::encoding::Context) -> usize {
729 8
730 }
731
732 #[inline(always)]
733 fn inline_size(_context: fidl::encoding::Context) -> usize {
734 16
735 }
736 }
737
738 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Audience, D> for &Audience {
739 unsafe fn encode(
740 self,
741 encoder: &mut fidl::encoding::Encoder<'_, D>,
742 offset: usize,
743 mut depth: fidl::encoding::Depth,
744 ) -> fidl::Result<()> {
745 encoder.debug_check_bounds::<Audience>(offset);
746 let max_ordinal: u64 = self.max_ordinal_present();
748 encoder.write_num(max_ordinal, offset);
749 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
750 if max_ordinal == 0 {
752 return Ok(());
753 }
754 depth.increment()?;
755 let envelope_size = 8;
756 let bytes_len = max_ordinal as usize * envelope_size;
757 #[allow(unused_variables)]
758 let offset = encoder.out_of_line_offset(bytes_len);
759 let mut _prev_end_offset: usize = 0;
760 if 1 > max_ordinal {
761 return Ok(());
762 }
763
764 let cur_offset: usize = (1 - 1) * envelope_size;
767
768 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
770
771 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
776 self.addressing.as_ref().map(
777 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
778 ),
779 encoder,
780 offset + cur_offset,
781 depth,
782 )?;
783
784 _prev_end_offset = cur_offset + envelope_size;
785 if 2 > max_ordinal {
786 return Ok(());
787 }
788
789 let cur_offset: usize = (2 - 1) * envelope_size;
792
793 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
795
796 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
801 self.name.as_ref().map(
802 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
803 ),
804 encoder,
805 offset + cur_offset,
806 depth,
807 )?;
808
809 _prev_end_offset = cur_offset + envelope_size;
810
811 Ok(())
812 }
813 }
814
815 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Audience {
816 #[inline(always)]
817 fn new_empty() -> Self {
818 Self::default()
819 }
820
821 unsafe fn decode(
822 &mut self,
823 decoder: &mut fidl::encoding::Decoder<'_, D>,
824 offset: usize,
825 mut depth: fidl::encoding::Depth,
826 ) -> fidl::Result<()> {
827 decoder.debug_check_bounds::<Self>(offset);
828 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
829 None => return Err(fidl::Error::NotNullable),
830 Some(len) => len,
831 };
832 if len == 0 {
834 return Ok(());
835 };
836 depth.increment()?;
837 let envelope_size = 8;
838 let bytes_len = len * envelope_size;
839 let offset = decoder.out_of_line_offset(bytes_len)?;
840 let mut _next_ordinal_to_read = 0;
842 let mut next_offset = offset;
843 let end_offset = offset + bytes_len;
844 _next_ordinal_to_read += 1;
845 if next_offset >= end_offset {
846 return Ok(());
847 }
848
849 while _next_ordinal_to_read < 1 {
851 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
852 _next_ordinal_to_read += 1;
853 next_offset += envelope_size;
854 }
855
856 let next_out_of_line = decoder.next_out_of_line();
857 let handles_before = decoder.remaining_handles();
858 if let Some((inlined, num_bytes, num_handles)) =
859 fidl::encoding::decode_envelope_header(decoder, next_offset)?
860 {
861 let member_inline_size =
862 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
863 decoder.context,
864 );
865 if inlined != (member_inline_size <= 4) {
866 return Err(fidl::Error::InvalidInlineBitInEnvelope);
867 }
868 let inner_offset;
869 let mut inner_depth = depth.clone();
870 if inlined {
871 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
872 inner_offset = next_offset;
873 } else {
874 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
875 inner_depth.increment()?;
876 }
877 let val_ref = self
878 .addressing
879 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
880 fidl::decode!(
881 fidl::encoding::BoundedString<256>,
882 D,
883 val_ref,
884 decoder,
885 inner_offset,
886 inner_depth
887 )?;
888 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
889 {
890 return Err(fidl::Error::InvalidNumBytesInEnvelope);
891 }
892 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
893 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
894 }
895 }
896
897 next_offset += envelope_size;
898 _next_ordinal_to_read += 1;
899 if next_offset >= end_offset {
900 return Ok(());
901 }
902
903 while _next_ordinal_to_read < 2 {
905 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
906 _next_ordinal_to_read += 1;
907 next_offset += envelope_size;
908 }
909
910 let next_out_of_line = decoder.next_out_of_line();
911 let handles_before = decoder.remaining_handles();
912 if let Some((inlined, num_bytes, num_handles)) =
913 fidl::encoding::decode_envelope_header(decoder, next_offset)?
914 {
915 let member_inline_size =
916 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
917 decoder.context,
918 );
919 if inlined != (member_inline_size <= 4) {
920 return Err(fidl::Error::InvalidInlineBitInEnvelope);
921 }
922 let inner_offset;
923 let mut inner_depth = depth.clone();
924 if inlined {
925 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
926 inner_offset = next_offset;
927 } else {
928 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
929 inner_depth.increment()?;
930 }
931 let val_ref = self
932 .name
933 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
934 fidl::decode!(
935 fidl::encoding::BoundedString<256>,
936 D,
937 val_ref,
938 decoder,
939 inner_offset,
940 inner_depth
941 )?;
942 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
943 {
944 return Err(fidl::Error::InvalidNumBytesInEnvelope);
945 }
946 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
947 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
948 }
949 }
950
951 next_offset += envelope_size;
952
953 while next_offset < end_offset {
955 _next_ordinal_to_read += 1;
956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
957 next_offset += envelope_size;
958 }
959
960 Ok(())
961 }
962 }
963
964 impl MasInstance {
965 #[inline(always)]
966 fn max_ordinal_present(&self) -> u64 {
967 if let Some(_) = self.supports_notification {
968 return 3;
969 }
970 if let Some(_) = self.supported_message_types {
971 return 2;
972 }
973 if let Some(_) = self.id {
974 return 1;
975 }
976 0
977 }
978 }
979
980 impl fidl::encoding::ValueTypeMarker for MasInstance {
981 type Borrowed<'a> = &'a Self;
982 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
983 value
984 }
985 }
986
987 unsafe impl fidl::encoding::TypeMarker for MasInstance {
988 type Owned = Self;
989
990 #[inline(always)]
991 fn inline_align(_context: fidl::encoding::Context) -> usize {
992 8
993 }
994
995 #[inline(always)]
996 fn inline_size(_context: fidl::encoding::Context) -> usize {
997 16
998 }
999 }
1000
1001 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MasInstance, D>
1002 for &MasInstance
1003 {
1004 unsafe fn encode(
1005 self,
1006 encoder: &mut fidl::encoding::Encoder<'_, D>,
1007 offset: usize,
1008 mut depth: fidl::encoding::Depth,
1009 ) -> fidl::Result<()> {
1010 encoder.debug_check_bounds::<MasInstance>(offset);
1011 let max_ordinal: u64 = self.max_ordinal_present();
1013 encoder.write_num(max_ordinal, offset);
1014 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1015 if max_ordinal == 0 {
1017 return Ok(());
1018 }
1019 depth.increment()?;
1020 let envelope_size = 8;
1021 let bytes_len = max_ordinal as usize * envelope_size;
1022 #[allow(unused_variables)]
1023 let offset = encoder.out_of_line_offset(bytes_len);
1024 let mut _prev_end_offset: usize = 0;
1025 if 1 > max_ordinal {
1026 return Ok(());
1027 }
1028
1029 let cur_offset: usize = (1 - 1) * envelope_size;
1032
1033 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1035
1036 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1041 self.id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1042 encoder,
1043 offset + cur_offset,
1044 depth,
1045 )?;
1046
1047 _prev_end_offset = cur_offset + envelope_size;
1048 if 2 > max_ordinal {
1049 return Ok(());
1050 }
1051
1052 let cur_offset: usize = (2 - 1) * envelope_size;
1055
1056 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1058
1059 fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
1064 self.supported_message_types
1065 .as_ref()
1066 .map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1067 encoder,
1068 offset + cur_offset,
1069 depth,
1070 )?;
1071
1072 _prev_end_offset = cur_offset + envelope_size;
1073 if 3 > max_ordinal {
1074 return Ok(());
1075 }
1076
1077 let cur_offset: usize = (3 - 1) * envelope_size;
1080
1081 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1083
1084 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1089 self.supports_notification
1090 .as_ref()
1091 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1092 encoder,
1093 offset + cur_offset,
1094 depth,
1095 )?;
1096
1097 _prev_end_offset = cur_offset + envelope_size;
1098
1099 Ok(())
1100 }
1101 }
1102
1103 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MasInstance {
1104 #[inline(always)]
1105 fn new_empty() -> Self {
1106 Self::default()
1107 }
1108
1109 unsafe fn decode(
1110 &mut self,
1111 decoder: &mut fidl::encoding::Decoder<'_, D>,
1112 offset: usize,
1113 mut depth: fidl::encoding::Depth,
1114 ) -> fidl::Result<()> {
1115 decoder.debug_check_bounds::<Self>(offset);
1116 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1117 None => return Err(fidl::Error::NotNullable),
1118 Some(len) => len,
1119 };
1120 if len == 0 {
1122 return Ok(());
1123 };
1124 depth.increment()?;
1125 let envelope_size = 8;
1126 let bytes_len = len * envelope_size;
1127 let offset = decoder.out_of_line_offset(bytes_len)?;
1128 let mut _next_ordinal_to_read = 0;
1130 let mut next_offset = offset;
1131 let end_offset = offset + bytes_len;
1132 _next_ordinal_to_read += 1;
1133 if next_offset >= end_offset {
1134 return Ok(());
1135 }
1136
1137 while _next_ordinal_to_read < 1 {
1139 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1140 _next_ordinal_to_read += 1;
1141 next_offset += envelope_size;
1142 }
1143
1144 let next_out_of_line = decoder.next_out_of_line();
1145 let handles_before = decoder.remaining_handles();
1146 if let Some((inlined, num_bytes, num_handles)) =
1147 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1148 {
1149 let member_inline_size =
1150 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1151 if inlined != (member_inline_size <= 4) {
1152 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1153 }
1154 let inner_offset;
1155 let mut inner_depth = depth.clone();
1156 if inlined {
1157 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1158 inner_offset = next_offset;
1159 } else {
1160 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1161 inner_depth.increment()?;
1162 }
1163 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1164 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1165 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1166 {
1167 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1168 }
1169 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1170 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1171 }
1172 }
1173
1174 next_offset += envelope_size;
1175 _next_ordinal_to_read += 1;
1176 if next_offset >= end_offset {
1177 return Ok(());
1178 }
1179
1180 while _next_ordinal_to_read < 2 {
1182 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1183 _next_ordinal_to_read += 1;
1184 next_offset += envelope_size;
1185 }
1186
1187 let next_out_of_line = decoder.next_out_of_line();
1188 let handles_before = decoder.remaining_handles();
1189 if let Some((inlined, num_bytes, num_handles)) =
1190 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1191 {
1192 let member_inline_size =
1193 <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1194 if inlined != (member_inline_size <= 4) {
1195 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1196 }
1197 let inner_offset;
1198 let mut inner_depth = depth.clone();
1199 if inlined {
1200 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1201 inner_offset = next_offset;
1202 } else {
1203 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1204 inner_depth.increment()?;
1205 }
1206 let val_ref = self
1207 .supported_message_types
1208 .get_or_insert_with(|| fidl::new_empty!(MessageType, D));
1209 fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1210 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1211 {
1212 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1213 }
1214 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1215 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1216 }
1217 }
1218
1219 next_offset += envelope_size;
1220 _next_ordinal_to_read += 1;
1221 if next_offset >= end_offset {
1222 return Ok(());
1223 }
1224
1225 while _next_ordinal_to_read < 3 {
1227 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1228 _next_ordinal_to_read += 1;
1229 next_offset += envelope_size;
1230 }
1231
1232 let next_out_of_line = decoder.next_out_of_line();
1233 let handles_before = decoder.remaining_handles();
1234 if let Some((inlined, num_bytes, num_handles)) =
1235 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1236 {
1237 let member_inline_size =
1238 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1239 if inlined != (member_inline_size <= 4) {
1240 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1241 }
1242 let inner_offset;
1243 let mut inner_depth = depth.clone();
1244 if inlined {
1245 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1246 inner_offset = next_offset;
1247 } else {
1248 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1249 inner_depth.increment()?;
1250 }
1251 let val_ref =
1252 self.supports_notification.get_or_insert_with(|| fidl::new_empty!(bool, D));
1253 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1255 {
1256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1257 }
1258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1260 }
1261 }
1262
1263 next_offset += envelope_size;
1264
1265 while next_offset < end_offset {
1267 _next_ordinal_to_read += 1;
1268 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1269 next_offset += envelope_size;
1270 }
1271
1272 Ok(())
1273 }
1274 }
1275
1276 impl Message {
1277 #[inline(always)]
1278 fn max_ordinal_present(&self) -> u64 {
1279 if let Some(_) = self.conversation_id {
1280 return 13;
1281 }
1282 if let Some(_) = self.protected {
1283 return 12;
1284 }
1285 if let Some(_) = self.sent {
1286 return 11;
1287 }
1288 if let Some(_) = self.read {
1289 return 10;
1290 }
1291 if let Some(_) = self.priority {
1292 return 9;
1293 }
1294 if let Some(_) = self.folder {
1295 return 8;
1296 }
1297 if let Some(_) = self.content {
1298 return 7;
1299 }
1300 if let Some(_) = self.type_ {
1301 return 6;
1302 }
1303 if let Some(_) = self.recipient {
1304 return 5;
1305 }
1306 if let Some(_) = self.sender {
1307 return 4;
1308 }
1309 if let Some(_) = self.timestamp {
1310 return 3;
1311 }
1312 if let Some(_) = self.subject {
1313 return 2;
1314 }
1315 if let Some(_) = self.handle {
1316 return 1;
1317 }
1318 0
1319 }
1320 }
1321
1322 impl fidl::encoding::ValueTypeMarker for Message {
1323 type Borrowed<'a> = &'a Self;
1324 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1325 value
1326 }
1327 }
1328
1329 unsafe impl fidl::encoding::TypeMarker for Message {
1330 type Owned = Self;
1331
1332 #[inline(always)]
1333 fn inline_align(_context: fidl::encoding::Context) -> usize {
1334 8
1335 }
1336
1337 #[inline(always)]
1338 fn inline_size(_context: fidl::encoding::Context) -> usize {
1339 16
1340 }
1341 }
1342
1343 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Message, D> for &Message {
1344 unsafe fn encode(
1345 self,
1346 encoder: &mut fidl::encoding::Encoder<'_, D>,
1347 offset: usize,
1348 mut depth: fidl::encoding::Depth,
1349 ) -> fidl::Result<()> {
1350 encoder.debug_check_bounds::<Message>(offset);
1351 let max_ordinal: u64 = self.max_ordinal_present();
1353 encoder.write_num(max_ordinal, offset);
1354 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1355 if max_ordinal == 0 {
1357 return Ok(());
1358 }
1359 depth.increment()?;
1360 let envelope_size = 8;
1361 let bytes_len = max_ordinal as usize * envelope_size;
1362 #[allow(unused_variables)]
1363 let offset = encoder.out_of_line_offset(bytes_len);
1364 let mut _prev_end_offset: usize = 0;
1365 if 1 > max_ordinal {
1366 return Ok(());
1367 }
1368
1369 let cur_offset: usize = (1 - 1) * envelope_size;
1372
1373 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1375
1376 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1381 self.handle.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1382 encoder,
1383 offset + cur_offset,
1384 depth,
1385 )?;
1386
1387 _prev_end_offset = cur_offset + envelope_size;
1388 if 2 > max_ordinal {
1389 return Ok(());
1390 }
1391
1392 let cur_offset: usize = (2 - 1) * envelope_size;
1395
1396 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1398
1399 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
1404 self.subject.as_ref().map(
1405 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
1406 ),
1407 encoder,
1408 offset + cur_offset,
1409 depth,
1410 )?;
1411
1412 _prev_end_offset = cur_offset + envelope_size;
1413 if 3 > max_ordinal {
1414 return Ok(());
1415 }
1416
1417 let cur_offset: usize = (3 - 1) * envelope_size;
1420
1421 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1423
1424 fidl::encoding::encode_in_envelope_optional::<i64, D>(
1429 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1430 encoder,
1431 offset + cur_offset,
1432 depth,
1433 )?;
1434
1435 _prev_end_offset = cur_offset + envelope_size;
1436 if 4 > max_ordinal {
1437 return Ok(());
1438 }
1439
1440 let cur_offset: usize = (4 - 1) * envelope_size;
1443
1444 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1446
1447 fidl::encoding::encode_in_envelope_optional::<Audience, D>(
1452 self.sender.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
1453 encoder,
1454 offset + cur_offset,
1455 depth,
1456 )?;
1457
1458 _prev_end_offset = cur_offset + envelope_size;
1459 if 5 > max_ordinal {
1460 return Ok(());
1461 }
1462
1463 let cur_offset: usize = (5 - 1) * envelope_size;
1466
1467 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1469
1470 fidl::encoding::encode_in_envelope_optional::<Audience, D>(
1475 self.recipient.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
1476 encoder,
1477 offset + cur_offset,
1478 depth,
1479 )?;
1480
1481 _prev_end_offset = cur_offset + envelope_size;
1482 if 6 > max_ordinal {
1483 return Ok(());
1484 }
1485
1486 let cur_offset: usize = (6 - 1) * envelope_size;
1489
1490 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1492
1493 fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
1498 self.type_.as_ref().map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1499 encoder,
1500 offset + cur_offset,
1501 depth,
1502 )?;
1503
1504 _prev_end_offset = cur_offset + envelope_size;
1505 if 7 > max_ordinal {
1506 return Ok(());
1507 }
1508
1509 let cur_offset: usize = (7 - 1) * envelope_size;
1512
1513 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1515
1516 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1521 self.content.as_ref().map(
1522 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1523 ),
1524 encoder,
1525 offset + cur_offset,
1526 depth,
1527 )?;
1528
1529 _prev_end_offset = cur_offset + envelope_size;
1530 if 8 > max_ordinal {
1531 return Ok(());
1532 }
1533
1534 let cur_offset: usize = (8 - 1) * envelope_size;
1537
1538 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1540
1541 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<512>, D>(
1546 self.folder.as_ref().map(
1547 <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow,
1548 ),
1549 encoder,
1550 offset + cur_offset,
1551 depth,
1552 )?;
1553
1554 _prev_end_offset = cur_offset + envelope_size;
1555 if 9 > max_ordinal {
1556 return Ok(());
1557 }
1558
1559 let cur_offset: usize = (9 - 1) * envelope_size;
1562
1563 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1565
1566 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1571 self.priority.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1572 encoder,
1573 offset + cur_offset,
1574 depth,
1575 )?;
1576
1577 _prev_end_offset = cur_offset + envelope_size;
1578 if 10 > max_ordinal {
1579 return Ok(());
1580 }
1581
1582 let cur_offset: usize = (10 - 1) * envelope_size;
1585
1586 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1588
1589 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1594 self.read.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1595 encoder,
1596 offset + cur_offset,
1597 depth,
1598 )?;
1599
1600 _prev_end_offset = cur_offset + envelope_size;
1601 if 11 > max_ordinal {
1602 return Ok(());
1603 }
1604
1605 let cur_offset: usize = (11 - 1) * envelope_size;
1608
1609 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1611
1612 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1617 self.sent.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1618 encoder,
1619 offset + cur_offset,
1620 depth,
1621 )?;
1622
1623 _prev_end_offset = cur_offset + envelope_size;
1624 if 12 > max_ordinal {
1625 return Ok(());
1626 }
1627
1628 let cur_offset: usize = (12 - 1) * envelope_size;
1631
1632 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1634
1635 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1640 self.protected.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1641 encoder,
1642 offset + cur_offset,
1643 depth,
1644 )?;
1645
1646 _prev_end_offset = cur_offset + envelope_size;
1647 if 13 > max_ordinal {
1648 return Ok(());
1649 }
1650
1651 let cur_offset: usize = (13 - 1) * envelope_size;
1654
1655 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1657
1658 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
1663 self.conversation_id.as_ref().map(
1664 <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
1665 ),
1666 encoder,
1667 offset + cur_offset,
1668 depth,
1669 )?;
1670
1671 _prev_end_offset = cur_offset + envelope_size;
1672
1673 Ok(())
1674 }
1675 }
1676
1677 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Message {
1678 #[inline(always)]
1679 fn new_empty() -> Self {
1680 Self::default()
1681 }
1682
1683 unsafe fn decode(
1684 &mut self,
1685 decoder: &mut fidl::encoding::Decoder<'_, D>,
1686 offset: usize,
1687 mut depth: fidl::encoding::Depth,
1688 ) -> fidl::Result<()> {
1689 decoder.debug_check_bounds::<Self>(offset);
1690 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1691 None => return Err(fidl::Error::NotNullable),
1692 Some(len) => len,
1693 };
1694 if len == 0 {
1696 return Ok(());
1697 };
1698 depth.increment()?;
1699 let envelope_size = 8;
1700 let bytes_len = len * envelope_size;
1701 let offset = decoder.out_of_line_offset(bytes_len)?;
1702 let mut _next_ordinal_to_read = 0;
1704 let mut next_offset = offset;
1705 let end_offset = offset + bytes_len;
1706 _next_ordinal_to_read += 1;
1707 if next_offset >= end_offset {
1708 return Ok(());
1709 }
1710
1711 while _next_ordinal_to_read < 1 {
1713 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1714 _next_ordinal_to_read += 1;
1715 next_offset += envelope_size;
1716 }
1717
1718 let next_out_of_line = decoder.next_out_of_line();
1719 let handles_before = decoder.remaining_handles();
1720 if let Some((inlined, num_bytes, num_handles)) =
1721 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1722 {
1723 let member_inline_size =
1724 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1725 if inlined != (member_inline_size <= 4) {
1726 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1727 }
1728 let inner_offset;
1729 let mut inner_depth = depth.clone();
1730 if inlined {
1731 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1732 inner_offset = next_offset;
1733 } else {
1734 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1735 inner_depth.increment()?;
1736 }
1737 let val_ref = self.handle.get_or_insert_with(|| fidl::new_empty!(u64, D));
1738 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1739 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1740 {
1741 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1742 }
1743 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1744 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1745 }
1746 }
1747
1748 next_offset += envelope_size;
1749 _next_ordinal_to_read += 1;
1750 if next_offset >= end_offset {
1751 return Ok(());
1752 }
1753
1754 while _next_ordinal_to_read < 2 {
1756 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1757 _next_ordinal_to_read += 1;
1758 next_offset += envelope_size;
1759 }
1760
1761 let next_out_of_line = decoder.next_out_of_line();
1762 let handles_before = decoder.remaining_handles();
1763 if let Some((inlined, num_bytes, num_handles)) =
1764 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1765 {
1766 let member_inline_size =
1767 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
1768 decoder.context,
1769 );
1770 if inlined != (member_inline_size <= 4) {
1771 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1772 }
1773 let inner_offset;
1774 let mut inner_depth = depth.clone();
1775 if inlined {
1776 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1777 inner_offset = next_offset;
1778 } else {
1779 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1780 inner_depth.increment()?;
1781 }
1782 let val_ref = self
1783 .subject
1784 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
1785 fidl::decode!(
1786 fidl::encoding::BoundedString<256>,
1787 D,
1788 val_ref,
1789 decoder,
1790 inner_offset,
1791 inner_depth
1792 )?;
1793 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1794 {
1795 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1796 }
1797 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1798 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1799 }
1800 }
1801
1802 next_offset += envelope_size;
1803 _next_ordinal_to_read += 1;
1804 if next_offset >= end_offset {
1805 return Ok(());
1806 }
1807
1808 while _next_ordinal_to_read < 3 {
1810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1811 _next_ordinal_to_read += 1;
1812 next_offset += envelope_size;
1813 }
1814
1815 let next_out_of_line = decoder.next_out_of_line();
1816 let handles_before = decoder.remaining_handles();
1817 if let Some((inlined, num_bytes, num_handles)) =
1818 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1819 {
1820 let member_inline_size =
1821 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1822 if inlined != (member_inline_size <= 4) {
1823 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1824 }
1825 let inner_offset;
1826 let mut inner_depth = depth.clone();
1827 if inlined {
1828 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1829 inner_offset = next_offset;
1830 } else {
1831 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1832 inner_depth.increment()?;
1833 }
1834 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
1835 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1836 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1837 {
1838 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1839 }
1840 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1841 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1842 }
1843 }
1844
1845 next_offset += envelope_size;
1846 _next_ordinal_to_read += 1;
1847 if next_offset >= end_offset {
1848 return Ok(());
1849 }
1850
1851 while _next_ordinal_to_read < 4 {
1853 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1854 _next_ordinal_to_read += 1;
1855 next_offset += envelope_size;
1856 }
1857
1858 let next_out_of_line = decoder.next_out_of_line();
1859 let handles_before = decoder.remaining_handles();
1860 if let Some((inlined, num_bytes, num_handles)) =
1861 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1862 {
1863 let member_inline_size =
1864 <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1865 if inlined != (member_inline_size <= 4) {
1866 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1867 }
1868 let inner_offset;
1869 let mut inner_depth = depth.clone();
1870 if inlined {
1871 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1872 inner_offset = next_offset;
1873 } else {
1874 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1875 inner_depth.increment()?;
1876 }
1877 let val_ref = self.sender.get_or_insert_with(|| fidl::new_empty!(Audience, D));
1878 fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
1879 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1880 {
1881 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1882 }
1883 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1884 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1885 }
1886 }
1887
1888 next_offset += envelope_size;
1889 _next_ordinal_to_read += 1;
1890 if next_offset >= end_offset {
1891 return Ok(());
1892 }
1893
1894 while _next_ordinal_to_read < 5 {
1896 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1897 _next_ordinal_to_read += 1;
1898 next_offset += envelope_size;
1899 }
1900
1901 let next_out_of_line = decoder.next_out_of_line();
1902 let handles_before = decoder.remaining_handles();
1903 if let Some((inlined, num_bytes, num_handles)) =
1904 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1905 {
1906 let member_inline_size =
1907 <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1908 if inlined != (member_inline_size <= 4) {
1909 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1910 }
1911 let inner_offset;
1912 let mut inner_depth = depth.clone();
1913 if inlined {
1914 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1915 inner_offset = next_offset;
1916 } else {
1917 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1918 inner_depth.increment()?;
1919 }
1920 let val_ref = self.recipient.get_or_insert_with(|| fidl::new_empty!(Audience, D));
1921 fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
1922 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1923 {
1924 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1925 }
1926 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1927 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1928 }
1929 }
1930
1931 next_offset += envelope_size;
1932 _next_ordinal_to_read += 1;
1933 if next_offset >= end_offset {
1934 return Ok(());
1935 }
1936
1937 while _next_ordinal_to_read < 6 {
1939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1940 _next_ordinal_to_read += 1;
1941 next_offset += envelope_size;
1942 }
1943
1944 let next_out_of_line = decoder.next_out_of_line();
1945 let handles_before = decoder.remaining_handles();
1946 if let Some((inlined, num_bytes, num_handles)) =
1947 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1948 {
1949 let member_inline_size =
1950 <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1951 if inlined != (member_inline_size <= 4) {
1952 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1953 }
1954 let inner_offset;
1955 let mut inner_depth = depth.clone();
1956 if inlined {
1957 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1958 inner_offset = next_offset;
1959 } else {
1960 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1961 inner_depth.increment()?;
1962 }
1963 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(MessageType, D));
1964 fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1966 {
1967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1968 }
1969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1971 }
1972 }
1973
1974 next_offset += envelope_size;
1975 _next_ordinal_to_read += 1;
1976 if next_offset >= end_offset {
1977 return Ok(());
1978 }
1979
1980 while _next_ordinal_to_read < 7 {
1982 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1983 _next_ordinal_to_read += 1;
1984 next_offset += envelope_size;
1985 }
1986
1987 let next_out_of_line = decoder.next_out_of_line();
1988 let handles_before = decoder.remaining_handles();
1989 if let Some((inlined, num_bytes, num_handles)) =
1990 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1991 {
1992 let member_inline_size =
1993 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1994 decoder.context,
1995 );
1996 if inlined != (member_inline_size <= 4) {
1997 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1998 }
1999 let inner_offset;
2000 let mut inner_depth = depth.clone();
2001 if inlined {
2002 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2003 inner_offset = next_offset;
2004 } else {
2005 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2006 inner_depth.increment()?;
2007 }
2008 let val_ref = self
2009 .content
2010 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2011 fidl::decode!(
2012 fidl::encoding::UnboundedString,
2013 D,
2014 val_ref,
2015 decoder,
2016 inner_offset,
2017 inner_depth
2018 )?;
2019 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2020 {
2021 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2022 }
2023 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2024 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2025 }
2026 }
2027
2028 next_offset += envelope_size;
2029 _next_ordinal_to_read += 1;
2030 if next_offset >= end_offset {
2031 return Ok(());
2032 }
2033
2034 while _next_ordinal_to_read < 8 {
2036 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2037 _next_ordinal_to_read += 1;
2038 next_offset += envelope_size;
2039 }
2040
2041 let next_out_of_line = decoder.next_out_of_line();
2042 let handles_before = decoder.remaining_handles();
2043 if let Some((inlined, num_bytes, num_handles)) =
2044 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2045 {
2046 let member_inline_size =
2047 <fidl::encoding::BoundedString<512> as fidl::encoding::TypeMarker>::inline_size(
2048 decoder.context,
2049 );
2050 if inlined != (member_inline_size <= 4) {
2051 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2052 }
2053 let inner_offset;
2054 let mut inner_depth = depth.clone();
2055 if inlined {
2056 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2057 inner_offset = next_offset;
2058 } else {
2059 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2060 inner_depth.increment()?;
2061 }
2062 let val_ref = self
2063 .folder
2064 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<512>, D));
2065 fidl::decode!(
2066 fidl::encoding::BoundedString<512>,
2067 D,
2068 val_ref,
2069 decoder,
2070 inner_offset,
2071 inner_depth
2072 )?;
2073 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2074 {
2075 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2076 }
2077 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2078 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2079 }
2080 }
2081
2082 next_offset += envelope_size;
2083 _next_ordinal_to_read += 1;
2084 if next_offset >= end_offset {
2085 return Ok(());
2086 }
2087
2088 while _next_ordinal_to_read < 9 {
2090 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2091 _next_ordinal_to_read += 1;
2092 next_offset += envelope_size;
2093 }
2094
2095 let next_out_of_line = decoder.next_out_of_line();
2096 let handles_before = decoder.remaining_handles();
2097 if let Some((inlined, num_bytes, num_handles)) =
2098 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2099 {
2100 let member_inline_size =
2101 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2102 if inlined != (member_inline_size <= 4) {
2103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2104 }
2105 let inner_offset;
2106 let mut inner_depth = depth.clone();
2107 if inlined {
2108 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2109 inner_offset = next_offset;
2110 } else {
2111 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2112 inner_depth.increment()?;
2113 }
2114 let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(bool, D));
2115 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2116 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2117 {
2118 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2119 }
2120 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2121 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2122 }
2123 }
2124
2125 next_offset += envelope_size;
2126 _next_ordinal_to_read += 1;
2127 if next_offset >= end_offset {
2128 return Ok(());
2129 }
2130
2131 while _next_ordinal_to_read < 10 {
2133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2134 _next_ordinal_to_read += 1;
2135 next_offset += envelope_size;
2136 }
2137
2138 let next_out_of_line = decoder.next_out_of_line();
2139 let handles_before = decoder.remaining_handles();
2140 if let Some((inlined, num_bytes, num_handles)) =
2141 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2142 {
2143 let member_inline_size =
2144 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2145 if inlined != (member_inline_size <= 4) {
2146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2147 }
2148 let inner_offset;
2149 let mut inner_depth = depth.clone();
2150 if inlined {
2151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2152 inner_offset = next_offset;
2153 } else {
2154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2155 inner_depth.increment()?;
2156 }
2157 let val_ref = self.read.get_or_insert_with(|| fidl::new_empty!(bool, D));
2158 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2159 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2160 {
2161 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2162 }
2163 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2164 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2165 }
2166 }
2167
2168 next_offset += envelope_size;
2169 _next_ordinal_to_read += 1;
2170 if next_offset >= end_offset {
2171 return Ok(());
2172 }
2173
2174 while _next_ordinal_to_read < 11 {
2176 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2177 _next_ordinal_to_read += 1;
2178 next_offset += envelope_size;
2179 }
2180
2181 let next_out_of_line = decoder.next_out_of_line();
2182 let handles_before = decoder.remaining_handles();
2183 if let Some((inlined, num_bytes, num_handles)) =
2184 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2185 {
2186 let member_inline_size =
2187 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2188 if inlined != (member_inline_size <= 4) {
2189 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2190 }
2191 let inner_offset;
2192 let mut inner_depth = depth.clone();
2193 if inlined {
2194 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2195 inner_offset = next_offset;
2196 } else {
2197 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2198 inner_depth.increment()?;
2199 }
2200 let val_ref = self.sent.get_or_insert_with(|| fidl::new_empty!(bool, D));
2201 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2202 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2203 {
2204 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2205 }
2206 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2207 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2208 }
2209 }
2210
2211 next_offset += envelope_size;
2212 _next_ordinal_to_read += 1;
2213 if next_offset >= end_offset {
2214 return Ok(());
2215 }
2216
2217 while _next_ordinal_to_read < 12 {
2219 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2220 _next_ordinal_to_read += 1;
2221 next_offset += envelope_size;
2222 }
2223
2224 let next_out_of_line = decoder.next_out_of_line();
2225 let handles_before = decoder.remaining_handles();
2226 if let Some((inlined, num_bytes, num_handles)) =
2227 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2228 {
2229 let member_inline_size =
2230 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2231 if inlined != (member_inline_size <= 4) {
2232 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2233 }
2234 let inner_offset;
2235 let mut inner_depth = depth.clone();
2236 if inlined {
2237 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2238 inner_offset = next_offset;
2239 } else {
2240 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2241 inner_depth.increment()?;
2242 }
2243 let val_ref = self.protected.get_or_insert_with(|| fidl::new_empty!(bool, D));
2244 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2245 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2246 {
2247 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2248 }
2249 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2250 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2251 }
2252 }
2253
2254 next_offset += envelope_size;
2255 _next_ordinal_to_read += 1;
2256 if next_offset >= end_offset {
2257 return Ok(());
2258 }
2259
2260 while _next_ordinal_to_read < 13 {
2262 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2263 _next_ordinal_to_read += 1;
2264 next_offset += envelope_size;
2265 }
2266
2267 let next_out_of_line = decoder.next_out_of_line();
2268 let handles_before = decoder.remaining_handles();
2269 if let Some((inlined, num_bytes, num_handles)) =
2270 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2271 {
2272 let member_inline_size =
2273 <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
2274 decoder.context,
2275 );
2276 if inlined != (member_inline_size <= 4) {
2277 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2278 }
2279 let inner_offset;
2280 let mut inner_depth = depth.clone();
2281 if inlined {
2282 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2283 inner_offset = next_offset;
2284 } else {
2285 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2286 inner_depth.increment()?;
2287 }
2288 let val_ref = self
2289 .conversation_id
2290 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
2291 fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
2292 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2293 {
2294 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2295 }
2296 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2297 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2298 }
2299 }
2300
2301 next_offset += envelope_size;
2302
2303 while next_offset < end_offset {
2305 _next_ordinal_to_read += 1;
2306 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2307 next_offset += envelope_size;
2308 }
2309
2310 Ok(())
2311 }
2312 }
2313
2314 impl Notification {
2315 #[inline(always)]
2316 fn max_ordinal_present(&self) -> u64 {
2317 if let Some(_) = self.priority {
2318 return 9;
2319 }
2320 if let Some(_) = self.sender {
2321 return 8;
2322 }
2323 if let Some(_) = self.subject {
2324 return 7;
2325 }
2326 if let Some(_) = self.timestamp {
2327 return 6;
2328 }
2329 if let Some(_) = self.message_type {
2330 return 5;
2331 }
2332 if let Some(_) = self.folder {
2333 return 4;
2334 }
2335 if let Some(_) = self.message_handle {
2336 return 3;
2337 }
2338 if let Some(_) = self.mas_instance_id {
2339 return 2;
2340 }
2341 if let Some(_) = self.type_ {
2342 return 1;
2343 }
2344 0
2345 }
2346 }
2347
2348 impl fidl::encoding::ValueTypeMarker for Notification {
2349 type Borrowed<'a> = &'a Self;
2350 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2351 value
2352 }
2353 }
2354
2355 unsafe impl fidl::encoding::TypeMarker for Notification {
2356 type Owned = Self;
2357
2358 #[inline(always)]
2359 fn inline_align(_context: fidl::encoding::Context) -> usize {
2360 8
2361 }
2362
2363 #[inline(always)]
2364 fn inline_size(_context: fidl::encoding::Context) -> usize {
2365 16
2366 }
2367 }
2368
2369 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Notification, D>
2370 for &Notification
2371 {
2372 unsafe fn encode(
2373 self,
2374 encoder: &mut fidl::encoding::Encoder<'_, D>,
2375 offset: usize,
2376 mut depth: fidl::encoding::Depth,
2377 ) -> fidl::Result<()> {
2378 encoder.debug_check_bounds::<Notification>(offset);
2379 let max_ordinal: u64 = self.max_ordinal_present();
2381 encoder.write_num(max_ordinal, offset);
2382 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2383 if max_ordinal == 0 {
2385 return Ok(());
2386 }
2387 depth.increment()?;
2388 let envelope_size = 8;
2389 let bytes_len = max_ordinal as usize * envelope_size;
2390 #[allow(unused_variables)]
2391 let offset = encoder.out_of_line_offset(bytes_len);
2392 let mut _prev_end_offset: usize = 0;
2393 if 1 > max_ordinal {
2394 return Ok(());
2395 }
2396
2397 let cur_offset: usize = (1 - 1) * envelope_size;
2400
2401 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2403
2404 fidl::encoding::encode_in_envelope_optional::<NotificationType, D>(
2409 self.type_
2410 .as_ref()
2411 .map(<NotificationType as fidl::encoding::ValueTypeMarker>::borrow),
2412 encoder,
2413 offset + cur_offset,
2414 depth,
2415 )?;
2416
2417 _prev_end_offset = cur_offset + envelope_size;
2418 if 2 > max_ordinal {
2419 return Ok(());
2420 }
2421
2422 let cur_offset: usize = (2 - 1) * envelope_size;
2425
2426 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2428
2429 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2434 self.mas_instance_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2435 encoder,
2436 offset + cur_offset,
2437 depth,
2438 )?;
2439
2440 _prev_end_offset = cur_offset + envelope_size;
2441 if 3 > max_ordinal {
2442 return Ok(());
2443 }
2444
2445 let cur_offset: usize = (3 - 1) * envelope_size;
2448
2449 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2451
2452 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2457 self.message_handle.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2458 encoder,
2459 offset + cur_offset,
2460 depth,
2461 )?;
2462
2463 _prev_end_offset = cur_offset + envelope_size;
2464 if 4 > max_ordinal {
2465 return Ok(());
2466 }
2467
2468 let cur_offset: usize = (4 - 1) * envelope_size;
2471
2472 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2474
2475 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<512>, D>(
2480 self.folder.as_ref().map(
2481 <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow,
2482 ),
2483 encoder,
2484 offset + cur_offset,
2485 depth,
2486 )?;
2487
2488 _prev_end_offset = cur_offset + envelope_size;
2489 if 5 > max_ordinal {
2490 return Ok(());
2491 }
2492
2493 let cur_offset: usize = (5 - 1) * envelope_size;
2496
2497 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2499
2500 fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
2505 self.message_type
2506 .as_ref()
2507 .map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
2508 encoder,
2509 offset + cur_offset,
2510 depth,
2511 )?;
2512
2513 _prev_end_offset = cur_offset + envelope_size;
2514 if 6 > max_ordinal {
2515 return Ok(());
2516 }
2517
2518 let cur_offset: usize = (6 - 1) * envelope_size;
2521
2522 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2524
2525 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2530 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2531 encoder,
2532 offset + cur_offset,
2533 depth,
2534 )?;
2535
2536 _prev_end_offset = cur_offset + envelope_size;
2537 if 7 > max_ordinal {
2538 return Ok(());
2539 }
2540
2541 let cur_offset: usize = (7 - 1) * envelope_size;
2544
2545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2547
2548 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
2553 self.subject.as_ref().map(
2554 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
2555 ),
2556 encoder,
2557 offset + cur_offset,
2558 depth,
2559 )?;
2560
2561 _prev_end_offset = cur_offset + envelope_size;
2562 if 8 > max_ordinal {
2563 return Ok(());
2564 }
2565
2566 let cur_offset: usize = (8 - 1) * envelope_size;
2569
2570 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2572
2573 fidl::encoding::encode_in_envelope_optional::<Audience, D>(
2578 self.sender.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
2579 encoder,
2580 offset + cur_offset,
2581 depth,
2582 )?;
2583
2584 _prev_end_offset = cur_offset + envelope_size;
2585 if 9 > max_ordinal {
2586 return Ok(());
2587 }
2588
2589 let cur_offset: usize = (9 - 1) * envelope_size;
2592
2593 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2595
2596 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2601 self.priority.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2602 encoder,
2603 offset + cur_offset,
2604 depth,
2605 )?;
2606
2607 _prev_end_offset = cur_offset + envelope_size;
2608
2609 Ok(())
2610 }
2611 }
2612
2613 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notification {
2614 #[inline(always)]
2615 fn new_empty() -> Self {
2616 Self::default()
2617 }
2618
2619 unsafe fn decode(
2620 &mut self,
2621 decoder: &mut fidl::encoding::Decoder<'_, D>,
2622 offset: usize,
2623 mut depth: fidl::encoding::Depth,
2624 ) -> fidl::Result<()> {
2625 decoder.debug_check_bounds::<Self>(offset);
2626 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2627 None => return Err(fidl::Error::NotNullable),
2628 Some(len) => len,
2629 };
2630 if len == 0 {
2632 return Ok(());
2633 };
2634 depth.increment()?;
2635 let envelope_size = 8;
2636 let bytes_len = len * envelope_size;
2637 let offset = decoder.out_of_line_offset(bytes_len)?;
2638 let mut _next_ordinal_to_read = 0;
2640 let mut next_offset = offset;
2641 let end_offset = offset + bytes_len;
2642 _next_ordinal_to_read += 1;
2643 if next_offset >= end_offset {
2644 return Ok(());
2645 }
2646
2647 while _next_ordinal_to_read < 1 {
2649 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2650 _next_ordinal_to_read += 1;
2651 next_offset += envelope_size;
2652 }
2653
2654 let next_out_of_line = decoder.next_out_of_line();
2655 let handles_before = decoder.remaining_handles();
2656 if let Some((inlined, num_bytes, num_handles)) =
2657 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2658 {
2659 let member_inline_size =
2660 <NotificationType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2661 if inlined != (member_inline_size <= 4) {
2662 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2663 }
2664 let inner_offset;
2665 let mut inner_depth = depth.clone();
2666 if inlined {
2667 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2668 inner_offset = next_offset;
2669 } else {
2670 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2671 inner_depth.increment()?;
2672 }
2673 let val_ref =
2674 self.type_.get_or_insert_with(|| fidl::new_empty!(NotificationType, D));
2675 fidl::decode!(NotificationType, D, val_ref, decoder, inner_offset, inner_depth)?;
2676 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2677 {
2678 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2679 }
2680 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2681 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2682 }
2683 }
2684
2685 next_offset += envelope_size;
2686 _next_ordinal_to_read += 1;
2687 if next_offset >= end_offset {
2688 return Ok(());
2689 }
2690
2691 while _next_ordinal_to_read < 2 {
2693 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2694 _next_ordinal_to_read += 1;
2695 next_offset += envelope_size;
2696 }
2697
2698 let next_out_of_line = decoder.next_out_of_line();
2699 let handles_before = decoder.remaining_handles();
2700 if let Some((inlined, num_bytes, num_handles)) =
2701 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2702 {
2703 let member_inline_size =
2704 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2705 if inlined != (member_inline_size <= 4) {
2706 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2707 }
2708 let inner_offset;
2709 let mut inner_depth = depth.clone();
2710 if inlined {
2711 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2712 inner_offset = next_offset;
2713 } else {
2714 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2715 inner_depth.increment()?;
2716 }
2717 let val_ref = self.mas_instance_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
2718 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2720 {
2721 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2722 }
2723 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2724 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2725 }
2726 }
2727
2728 next_offset += envelope_size;
2729 _next_ordinal_to_read += 1;
2730 if next_offset >= end_offset {
2731 return Ok(());
2732 }
2733
2734 while _next_ordinal_to_read < 3 {
2736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2737 _next_ordinal_to_read += 1;
2738 next_offset += envelope_size;
2739 }
2740
2741 let next_out_of_line = decoder.next_out_of_line();
2742 let handles_before = decoder.remaining_handles();
2743 if let Some((inlined, num_bytes, num_handles)) =
2744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2745 {
2746 let member_inline_size =
2747 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2748 if inlined != (member_inline_size <= 4) {
2749 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2750 }
2751 let inner_offset;
2752 let mut inner_depth = depth.clone();
2753 if inlined {
2754 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2755 inner_offset = next_offset;
2756 } else {
2757 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2758 inner_depth.increment()?;
2759 }
2760 let val_ref = self.message_handle.get_or_insert_with(|| fidl::new_empty!(u64, D));
2761 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2762 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2763 {
2764 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2765 }
2766 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2767 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2768 }
2769 }
2770
2771 next_offset += envelope_size;
2772 _next_ordinal_to_read += 1;
2773 if next_offset >= end_offset {
2774 return Ok(());
2775 }
2776
2777 while _next_ordinal_to_read < 4 {
2779 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2780 _next_ordinal_to_read += 1;
2781 next_offset += envelope_size;
2782 }
2783
2784 let next_out_of_line = decoder.next_out_of_line();
2785 let handles_before = decoder.remaining_handles();
2786 if let Some((inlined, num_bytes, num_handles)) =
2787 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2788 {
2789 let member_inline_size =
2790 <fidl::encoding::BoundedString<512> as fidl::encoding::TypeMarker>::inline_size(
2791 decoder.context,
2792 );
2793 if inlined != (member_inline_size <= 4) {
2794 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2795 }
2796 let inner_offset;
2797 let mut inner_depth = depth.clone();
2798 if inlined {
2799 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2800 inner_offset = next_offset;
2801 } else {
2802 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2803 inner_depth.increment()?;
2804 }
2805 let val_ref = self
2806 .folder
2807 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<512>, D));
2808 fidl::decode!(
2809 fidl::encoding::BoundedString<512>,
2810 D,
2811 val_ref,
2812 decoder,
2813 inner_offset,
2814 inner_depth
2815 )?;
2816 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2817 {
2818 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2819 }
2820 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2821 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2822 }
2823 }
2824
2825 next_offset += envelope_size;
2826 _next_ordinal_to_read += 1;
2827 if next_offset >= end_offset {
2828 return Ok(());
2829 }
2830
2831 while _next_ordinal_to_read < 5 {
2833 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2834 _next_ordinal_to_read += 1;
2835 next_offset += envelope_size;
2836 }
2837
2838 let next_out_of_line = decoder.next_out_of_line();
2839 let handles_before = decoder.remaining_handles();
2840 if let Some((inlined, num_bytes, num_handles)) =
2841 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2842 {
2843 let member_inline_size =
2844 <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2845 if inlined != (member_inline_size <= 4) {
2846 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2847 }
2848 let inner_offset;
2849 let mut inner_depth = depth.clone();
2850 if inlined {
2851 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2852 inner_offset = next_offset;
2853 } else {
2854 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2855 inner_depth.increment()?;
2856 }
2857 let val_ref =
2858 self.message_type.get_or_insert_with(|| fidl::new_empty!(MessageType, D));
2859 fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
2860 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2861 {
2862 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2863 }
2864 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2865 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2866 }
2867 }
2868
2869 next_offset += envelope_size;
2870 _next_ordinal_to_read += 1;
2871 if next_offset >= end_offset {
2872 return Ok(());
2873 }
2874
2875 while _next_ordinal_to_read < 6 {
2877 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2878 _next_ordinal_to_read += 1;
2879 next_offset += envelope_size;
2880 }
2881
2882 let next_out_of_line = decoder.next_out_of_line();
2883 let handles_before = decoder.remaining_handles();
2884 if let Some((inlined, num_bytes, num_handles)) =
2885 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2886 {
2887 let member_inline_size =
2888 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2889 if inlined != (member_inline_size <= 4) {
2890 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2891 }
2892 let inner_offset;
2893 let mut inner_depth = depth.clone();
2894 if inlined {
2895 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2896 inner_offset = next_offset;
2897 } else {
2898 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2899 inner_depth.increment()?;
2900 }
2901 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
2902 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2903 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2904 {
2905 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2906 }
2907 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2908 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2909 }
2910 }
2911
2912 next_offset += envelope_size;
2913 _next_ordinal_to_read += 1;
2914 if next_offset >= end_offset {
2915 return Ok(());
2916 }
2917
2918 while _next_ordinal_to_read < 7 {
2920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2921 _next_ordinal_to_read += 1;
2922 next_offset += envelope_size;
2923 }
2924
2925 let next_out_of_line = decoder.next_out_of_line();
2926 let handles_before = decoder.remaining_handles();
2927 if let Some((inlined, num_bytes, num_handles)) =
2928 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2929 {
2930 let member_inline_size =
2931 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
2932 decoder.context,
2933 );
2934 if inlined != (member_inline_size <= 4) {
2935 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2936 }
2937 let inner_offset;
2938 let mut inner_depth = depth.clone();
2939 if inlined {
2940 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2941 inner_offset = next_offset;
2942 } else {
2943 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2944 inner_depth.increment()?;
2945 }
2946 let val_ref = self
2947 .subject
2948 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
2949 fidl::decode!(
2950 fidl::encoding::BoundedString<256>,
2951 D,
2952 val_ref,
2953 decoder,
2954 inner_offset,
2955 inner_depth
2956 )?;
2957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2958 {
2959 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2960 }
2961 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2962 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2963 }
2964 }
2965
2966 next_offset += envelope_size;
2967 _next_ordinal_to_read += 1;
2968 if next_offset >= end_offset {
2969 return Ok(());
2970 }
2971
2972 while _next_ordinal_to_read < 8 {
2974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2975 _next_ordinal_to_read += 1;
2976 next_offset += envelope_size;
2977 }
2978
2979 let next_out_of_line = decoder.next_out_of_line();
2980 let handles_before = decoder.remaining_handles();
2981 if let Some((inlined, num_bytes, num_handles)) =
2982 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2983 {
2984 let member_inline_size =
2985 <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2986 if inlined != (member_inline_size <= 4) {
2987 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2988 }
2989 let inner_offset;
2990 let mut inner_depth = depth.clone();
2991 if inlined {
2992 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2993 inner_offset = next_offset;
2994 } else {
2995 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2996 inner_depth.increment()?;
2997 }
2998 let val_ref = self.sender.get_or_insert_with(|| fidl::new_empty!(Audience, D));
2999 fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
3000 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3001 {
3002 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3003 }
3004 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3005 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3006 }
3007 }
3008
3009 next_offset += envelope_size;
3010 _next_ordinal_to_read += 1;
3011 if next_offset >= end_offset {
3012 return Ok(());
3013 }
3014
3015 while _next_ordinal_to_read < 9 {
3017 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3018 _next_ordinal_to_read += 1;
3019 next_offset += envelope_size;
3020 }
3021
3022 let next_out_of_line = decoder.next_out_of_line();
3023 let handles_before = decoder.remaining_handles();
3024 if let Some((inlined, num_bytes, num_handles)) =
3025 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3026 {
3027 let member_inline_size =
3028 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3029 if inlined != (member_inline_size <= 4) {
3030 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3031 }
3032 let inner_offset;
3033 let mut inner_depth = depth.clone();
3034 if inlined {
3035 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3036 inner_offset = next_offset;
3037 } else {
3038 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3039 inner_depth.increment()?;
3040 }
3041 let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(bool, D));
3042 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3043 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3044 {
3045 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3046 }
3047 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3048 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3049 }
3050 }
3051
3052 next_offset += envelope_size;
3053
3054 while next_offset < end_offset {
3056 _next_ordinal_to_read += 1;
3057 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3058 next_offset += envelope_size;
3059 }
3060
3061 Ok(())
3062 }
3063 }
3064
3065 impl NotificationRegistrationNewEventReportRequest {
3066 #[inline(always)]
3067 fn max_ordinal_present(&self) -> u64 {
3068 if let Some(_) = self.received {
3069 return 2;
3070 }
3071 if let Some(_) = self.notification {
3072 return 1;
3073 }
3074 0
3075 }
3076 }
3077
3078 impl fidl::encoding::ValueTypeMarker for NotificationRegistrationNewEventReportRequest {
3079 type Borrowed<'a> = &'a Self;
3080 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3081 value
3082 }
3083 }
3084
3085 unsafe impl fidl::encoding::TypeMarker for NotificationRegistrationNewEventReportRequest {
3086 type Owned = Self;
3087
3088 #[inline(always)]
3089 fn inline_align(_context: fidl::encoding::Context) -> usize {
3090 8
3091 }
3092
3093 #[inline(always)]
3094 fn inline_size(_context: fidl::encoding::Context) -> usize {
3095 16
3096 }
3097 }
3098
3099 unsafe impl<D: fidl::encoding::ResourceDialect>
3100 fidl::encoding::Encode<NotificationRegistrationNewEventReportRequest, D>
3101 for &NotificationRegistrationNewEventReportRequest
3102 {
3103 unsafe fn encode(
3104 self,
3105 encoder: &mut fidl::encoding::Encoder<'_, D>,
3106 offset: usize,
3107 mut depth: fidl::encoding::Depth,
3108 ) -> fidl::Result<()> {
3109 encoder.debug_check_bounds::<NotificationRegistrationNewEventReportRequest>(offset);
3110 let max_ordinal: u64 = self.max_ordinal_present();
3112 encoder.write_num(max_ordinal, offset);
3113 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3114 if max_ordinal == 0 {
3116 return Ok(());
3117 }
3118 depth.increment()?;
3119 let envelope_size = 8;
3120 let bytes_len = max_ordinal as usize * envelope_size;
3121 #[allow(unused_variables)]
3122 let offset = encoder.out_of_line_offset(bytes_len);
3123 let mut _prev_end_offset: usize = 0;
3124 if 1 > max_ordinal {
3125 return Ok(());
3126 }
3127
3128 let cur_offset: usize = (1 - 1) * envelope_size;
3131
3132 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3134
3135 fidl::encoding::encode_in_envelope_optional::<Notification, D>(
3140 self.notification
3141 .as_ref()
3142 .map(<Notification as fidl::encoding::ValueTypeMarker>::borrow),
3143 encoder,
3144 offset + cur_offset,
3145 depth,
3146 )?;
3147
3148 _prev_end_offset = cur_offset + envelope_size;
3149 if 2 > max_ordinal {
3150 return Ok(());
3151 }
3152
3153 let cur_offset: usize = (2 - 1) * envelope_size;
3156
3157 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3159
3160 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3165 self.received.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3166 encoder,
3167 offset + cur_offset,
3168 depth,
3169 )?;
3170
3171 _prev_end_offset = cur_offset + envelope_size;
3172
3173 Ok(())
3174 }
3175 }
3176
3177 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3178 for NotificationRegistrationNewEventReportRequest
3179 {
3180 #[inline(always)]
3181 fn new_empty() -> Self {
3182 Self::default()
3183 }
3184
3185 unsafe fn decode(
3186 &mut self,
3187 decoder: &mut fidl::encoding::Decoder<'_, D>,
3188 offset: usize,
3189 mut depth: fidl::encoding::Depth,
3190 ) -> fidl::Result<()> {
3191 decoder.debug_check_bounds::<Self>(offset);
3192 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3193 None => return Err(fidl::Error::NotNullable),
3194 Some(len) => len,
3195 };
3196 if len == 0 {
3198 return Ok(());
3199 };
3200 depth.increment()?;
3201 let envelope_size = 8;
3202 let bytes_len = len * envelope_size;
3203 let offset = decoder.out_of_line_offset(bytes_len)?;
3204 let mut _next_ordinal_to_read = 0;
3206 let mut next_offset = offset;
3207 let end_offset = offset + bytes_len;
3208 _next_ordinal_to_read += 1;
3209 if next_offset >= end_offset {
3210 return Ok(());
3211 }
3212
3213 while _next_ordinal_to_read < 1 {
3215 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3216 _next_ordinal_to_read += 1;
3217 next_offset += envelope_size;
3218 }
3219
3220 let next_out_of_line = decoder.next_out_of_line();
3221 let handles_before = decoder.remaining_handles();
3222 if let Some((inlined, num_bytes, num_handles)) =
3223 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3224 {
3225 let member_inline_size =
3226 <Notification as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3227 if inlined != (member_inline_size <= 4) {
3228 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3229 }
3230 let inner_offset;
3231 let mut inner_depth = depth.clone();
3232 if inlined {
3233 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3234 inner_offset = next_offset;
3235 } else {
3236 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3237 inner_depth.increment()?;
3238 }
3239 let val_ref =
3240 self.notification.get_or_insert_with(|| fidl::new_empty!(Notification, D));
3241 fidl::decode!(Notification, D, val_ref, decoder, inner_offset, inner_depth)?;
3242 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3243 {
3244 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3245 }
3246 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3247 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3248 }
3249 }
3250
3251 next_offset += envelope_size;
3252 _next_ordinal_to_read += 1;
3253 if next_offset >= end_offset {
3254 return Ok(());
3255 }
3256
3257 while _next_ordinal_to_read < 2 {
3259 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3260 _next_ordinal_to_read += 1;
3261 next_offset += envelope_size;
3262 }
3263
3264 let next_out_of_line = decoder.next_out_of_line();
3265 let handles_before = decoder.remaining_handles();
3266 if let Some((inlined, num_bytes, num_handles)) =
3267 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3268 {
3269 let member_inline_size =
3270 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3271 if inlined != (member_inline_size <= 4) {
3272 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3273 }
3274 let inner_offset;
3275 let mut inner_depth = depth.clone();
3276 if inlined {
3277 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3278 inner_offset = next_offset;
3279 } else {
3280 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3281 inner_depth.increment()?;
3282 }
3283 let val_ref = self.received.get_or_insert_with(|| fidl::new_empty!(i64, D));
3284 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3285 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3286 {
3287 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3288 }
3289 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3290 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3291 }
3292 }
3293
3294 next_offset += envelope_size;
3295
3296 while next_offset < end_offset {
3298 _next_ordinal_to_read += 1;
3299 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3300 next_offset += envelope_size;
3301 }
3302
3303 Ok(())
3304 }
3305 }
3306}