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
305mod internal {
306 use super::*;
307 unsafe impl fidl::encoding::TypeMarker for MessageType {
308 type Owned = Self;
309
310 #[inline(always)]
311 fn inline_align(_context: fidl::encoding::Context) -> usize {
312 1
313 }
314
315 #[inline(always)]
316 fn inline_size(_context: fidl::encoding::Context) -> usize {
317 1
318 }
319 }
320
321 impl fidl::encoding::ValueTypeMarker for MessageType {
322 type Borrowed<'a> = Self;
323 #[inline(always)]
324 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
325 *value
326 }
327 }
328
329 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MessageType {
330 #[inline]
331 unsafe fn encode(
332 self,
333 encoder: &mut fidl::encoding::Encoder<'_, D>,
334 offset: usize,
335 _depth: fidl::encoding::Depth,
336 ) -> fidl::Result<()> {
337 encoder.debug_check_bounds::<Self>(offset);
338 encoder.write_num(self.bits(), offset);
339 Ok(())
340 }
341 }
342
343 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MessageType {
344 #[inline(always)]
345 fn new_empty() -> Self {
346 Self::empty()
347 }
348
349 #[inline]
350 unsafe fn decode(
351 &mut self,
352 decoder: &mut fidl::encoding::Decoder<'_, D>,
353 offset: usize,
354 _depth: fidl::encoding::Depth,
355 ) -> fidl::Result<()> {
356 decoder.debug_check_bounds::<Self>(offset);
357 let prim = decoder.read_num::<u8>(offset);
358 *self = Self::from_bits_allow_unknown(prim);
359 Ok(())
360 }
361 }
362 unsafe impl fidl::encoding::TypeMarker for Error {
363 type Owned = Self;
364
365 #[inline(always)]
366 fn inline_align(_context: fidl::encoding::Context) -> usize {
367 std::mem::align_of::<u32>()
368 }
369
370 #[inline(always)]
371 fn inline_size(_context: fidl::encoding::Context) -> usize {
372 std::mem::size_of::<u32>()
373 }
374
375 #[inline(always)]
376 fn encode_is_copy() -> bool {
377 true
378 }
379
380 #[inline(always)]
381 fn decode_is_copy() -> bool {
382 false
383 }
384 }
385
386 impl fidl::encoding::ValueTypeMarker for Error {
387 type Borrowed<'a> = Self;
388 #[inline(always)]
389 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
390 *value
391 }
392 }
393
394 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
395 #[inline]
396 unsafe fn encode(
397 self,
398 encoder: &mut fidl::encoding::Encoder<'_, D>,
399 offset: usize,
400 _depth: fidl::encoding::Depth,
401 ) -> fidl::Result<()> {
402 encoder.debug_check_bounds::<Self>(offset);
403 encoder.write_num(self.into_primitive(), offset);
404 Ok(())
405 }
406 }
407
408 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
409 #[inline(always)]
410 fn new_empty() -> Self {
411 Self::Unknown
412 }
413
414 #[inline]
415 unsafe fn decode(
416 &mut self,
417 decoder: &mut fidl::encoding::Decoder<'_, D>,
418 offset: usize,
419 _depth: fidl::encoding::Depth,
420 ) -> fidl::Result<()> {
421 decoder.debug_check_bounds::<Self>(offset);
422 let prim = decoder.read_num::<u32>(offset);
423
424 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
425 Ok(())
426 }
427 }
428 unsafe impl fidl::encoding::TypeMarker for NotificationType {
429 type Owned = Self;
430
431 #[inline(always)]
432 fn inline_align(_context: fidl::encoding::Context) -> usize {
433 std::mem::align_of::<u32>()
434 }
435
436 #[inline(always)]
437 fn inline_size(_context: fidl::encoding::Context) -> usize {
438 std::mem::size_of::<u32>()
439 }
440
441 #[inline(always)]
442 fn encode_is_copy() -> bool {
443 false
444 }
445
446 #[inline(always)]
447 fn decode_is_copy() -> bool {
448 false
449 }
450 }
451
452 impl fidl::encoding::ValueTypeMarker for NotificationType {
453 type Borrowed<'a> = Self;
454 #[inline(always)]
455 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
456 *value
457 }
458 }
459
460 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
461 for NotificationType
462 {
463 #[inline]
464 unsafe fn encode(
465 self,
466 encoder: &mut fidl::encoding::Encoder<'_, D>,
467 offset: usize,
468 _depth: fidl::encoding::Depth,
469 ) -> fidl::Result<()> {
470 encoder.debug_check_bounds::<Self>(offset);
471 encoder.write_num(self.into_primitive(), offset);
472 Ok(())
473 }
474 }
475
476 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NotificationType {
477 #[inline(always)]
478 fn new_empty() -> Self {
479 Self::unknown()
480 }
481
482 #[inline]
483 unsafe fn decode(
484 &mut self,
485 decoder: &mut fidl::encoding::Decoder<'_, D>,
486 offset: usize,
487 _depth: fidl::encoding::Depth,
488 ) -> fidl::Result<()> {
489 decoder.debug_check_bounds::<Self>(offset);
490 let prim = decoder.read_num::<u32>(offset);
491
492 *self = Self::from_primitive_allow_unknown(prim);
493 Ok(())
494 }
495 }
496
497 impl fidl::encoding::ValueTypeMarker for AccessorListAllMasInstancesResponse {
498 type Borrowed<'a> = &'a Self;
499 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
500 value
501 }
502 }
503
504 unsafe impl fidl::encoding::TypeMarker for AccessorListAllMasInstancesResponse {
505 type Owned = Self;
506
507 #[inline(always)]
508 fn inline_align(_context: fidl::encoding::Context) -> usize {
509 8
510 }
511
512 #[inline(always)]
513 fn inline_size(_context: fidl::encoding::Context) -> usize {
514 16
515 }
516 }
517
518 unsafe impl<D: fidl::encoding::ResourceDialect>
519 fidl::encoding::Encode<AccessorListAllMasInstancesResponse, D>
520 for &AccessorListAllMasInstancesResponse
521 {
522 #[inline]
523 unsafe fn encode(
524 self,
525 encoder: &mut fidl::encoding::Encoder<'_, D>,
526 offset: usize,
527 _depth: fidl::encoding::Depth,
528 ) -> fidl::Result<()> {
529 encoder.debug_check_bounds::<AccessorListAllMasInstancesResponse>(offset);
530 fidl::encoding::Encode::<AccessorListAllMasInstancesResponse, D>::encode(
532 (
533 <fidl::encoding::Vector<MasInstance, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.instances),
534 ),
535 encoder, offset, _depth
536 )
537 }
538 }
539 unsafe impl<
540 D: fidl::encoding::ResourceDialect,
541 T0: fidl::encoding::Encode<fidl::encoding::Vector<MasInstance, 256>, D>,
542 > fidl::encoding::Encode<AccessorListAllMasInstancesResponse, D> for (T0,)
543 {
544 #[inline]
545 unsafe fn encode(
546 self,
547 encoder: &mut fidl::encoding::Encoder<'_, D>,
548 offset: usize,
549 depth: fidl::encoding::Depth,
550 ) -> fidl::Result<()> {
551 encoder.debug_check_bounds::<AccessorListAllMasInstancesResponse>(offset);
552 self.0.encode(encoder, offset + 0, depth)?;
556 Ok(())
557 }
558 }
559
560 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
561 for AccessorListAllMasInstancesResponse
562 {
563 #[inline(always)]
564 fn new_empty() -> Self {
565 Self { instances: fidl::new_empty!(fidl::encoding::Vector<MasInstance, 256>, D) }
566 }
567
568 #[inline]
569 unsafe fn decode(
570 &mut self,
571 decoder: &mut fidl::encoding::Decoder<'_, D>,
572 offset: usize,
573 _depth: fidl::encoding::Depth,
574 ) -> fidl::Result<()> {
575 decoder.debug_check_bounds::<Self>(offset);
576 fidl::decode!(fidl::encoding::Vector<MasInstance, 256>, D, &mut self.instances, decoder, offset + 0, _depth)?;
578 Ok(())
579 }
580 }
581
582 impl fidl::encoding::ValueTypeMarker for MessageControllerGetDetailsRequest {
583 type Borrowed<'a> = &'a Self;
584 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
585 value
586 }
587 }
588
589 unsafe impl fidl::encoding::TypeMarker for MessageControllerGetDetailsRequest {
590 type Owned = Self;
591
592 #[inline(always)]
593 fn inline_align(_context: fidl::encoding::Context) -> usize {
594 8
595 }
596
597 #[inline(always)]
598 fn inline_size(_context: fidl::encoding::Context) -> usize {
599 16
600 }
601 }
602
603 unsafe impl<D: fidl::encoding::ResourceDialect>
604 fidl::encoding::Encode<MessageControllerGetDetailsRequest, D>
605 for &MessageControllerGetDetailsRequest
606 {
607 #[inline]
608 unsafe fn encode(
609 self,
610 encoder: &mut fidl::encoding::Encoder<'_, D>,
611 offset: usize,
612 _depth: fidl::encoding::Depth,
613 ) -> fidl::Result<()> {
614 encoder.debug_check_bounds::<MessageControllerGetDetailsRequest>(offset);
615 fidl::encoding::Encode::<MessageControllerGetDetailsRequest, D>::encode(
617 (
618 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.handle),
619 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_attachment),
620 ),
621 encoder,
622 offset,
623 _depth,
624 )
625 }
626 }
627 unsafe impl<
628 D: fidl::encoding::ResourceDialect,
629 T0: fidl::encoding::Encode<u64, D>,
630 T1: fidl::encoding::Encode<bool, D>,
631 > fidl::encoding::Encode<MessageControllerGetDetailsRequest, D> for (T0, T1)
632 {
633 #[inline]
634 unsafe fn encode(
635 self,
636 encoder: &mut fidl::encoding::Encoder<'_, D>,
637 offset: usize,
638 depth: fidl::encoding::Depth,
639 ) -> fidl::Result<()> {
640 encoder.debug_check_bounds::<MessageControllerGetDetailsRequest>(offset);
641 unsafe {
644 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
645 (ptr as *mut u64).write_unaligned(0);
646 }
647 self.0.encode(encoder, offset + 0, depth)?;
649 self.1.encode(encoder, offset + 8, depth)?;
650 Ok(())
651 }
652 }
653
654 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
655 for MessageControllerGetDetailsRequest
656 {
657 #[inline(always)]
658 fn new_empty() -> Self {
659 Self { handle: fidl::new_empty!(u64, D), include_attachment: fidl::new_empty!(bool, D) }
660 }
661
662 #[inline]
663 unsafe fn decode(
664 &mut self,
665 decoder: &mut fidl::encoding::Decoder<'_, D>,
666 offset: usize,
667 _depth: fidl::encoding::Depth,
668 ) -> fidl::Result<()> {
669 decoder.debug_check_bounds::<Self>(offset);
670 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
672 let padval = unsafe { (ptr as *const u64).read_unaligned() };
673 let mask = 0xffffffffffffff00u64;
674 let maskedval = padval & mask;
675 if maskedval != 0 {
676 return Err(fidl::Error::NonZeroPadding {
677 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
678 });
679 }
680 fidl::decode!(u64, D, &mut self.handle, decoder, offset + 0, _depth)?;
681 fidl::decode!(bool, D, &mut self.include_attachment, decoder, offset + 8, _depth)?;
682 Ok(())
683 }
684 }
685
686 impl Audience {
687 #[inline(always)]
688 fn max_ordinal_present(&self) -> u64 {
689 if let Some(_) = self.name {
690 return 2;
691 }
692 if let Some(_) = self.addressing {
693 return 1;
694 }
695 0
696 }
697 }
698
699 impl fidl::encoding::ValueTypeMarker for Audience {
700 type Borrowed<'a> = &'a Self;
701 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
702 value
703 }
704 }
705
706 unsafe impl fidl::encoding::TypeMarker for Audience {
707 type Owned = Self;
708
709 #[inline(always)]
710 fn inline_align(_context: fidl::encoding::Context) -> usize {
711 8
712 }
713
714 #[inline(always)]
715 fn inline_size(_context: fidl::encoding::Context) -> usize {
716 16
717 }
718 }
719
720 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Audience, D> for &Audience {
721 unsafe fn encode(
722 self,
723 encoder: &mut fidl::encoding::Encoder<'_, D>,
724 offset: usize,
725 mut depth: fidl::encoding::Depth,
726 ) -> fidl::Result<()> {
727 encoder.debug_check_bounds::<Audience>(offset);
728 let max_ordinal: u64 = self.max_ordinal_present();
730 encoder.write_num(max_ordinal, offset);
731 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
732 if max_ordinal == 0 {
734 return Ok(());
735 }
736 depth.increment()?;
737 let envelope_size = 8;
738 let bytes_len = max_ordinal as usize * envelope_size;
739 #[allow(unused_variables)]
740 let offset = encoder.out_of_line_offset(bytes_len);
741 let mut _prev_end_offset: usize = 0;
742 if 1 > max_ordinal {
743 return Ok(());
744 }
745
746 let cur_offset: usize = (1 - 1) * envelope_size;
749
750 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
752
753 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
758 self.addressing.as_ref().map(
759 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
760 ),
761 encoder,
762 offset + cur_offset,
763 depth,
764 )?;
765
766 _prev_end_offset = cur_offset + envelope_size;
767 if 2 > max_ordinal {
768 return Ok(());
769 }
770
771 let cur_offset: usize = (2 - 1) * envelope_size;
774
775 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
777
778 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
783 self.name.as_ref().map(
784 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
785 ),
786 encoder,
787 offset + cur_offset,
788 depth,
789 )?;
790
791 _prev_end_offset = cur_offset + envelope_size;
792
793 Ok(())
794 }
795 }
796
797 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Audience {
798 #[inline(always)]
799 fn new_empty() -> Self {
800 Self::default()
801 }
802
803 unsafe fn decode(
804 &mut self,
805 decoder: &mut fidl::encoding::Decoder<'_, D>,
806 offset: usize,
807 mut depth: fidl::encoding::Depth,
808 ) -> fidl::Result<()> {
809 decoder.debug_check_bounds::<Self>(offset);
810 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
811 None => return Err(fidl::Error::NotNullable),
812 Some(len) => len,
813 };
814 if len == 0 {
816 return Ok(());
817 };
818 depth.increment()?;
819 let envelope_size = 8;
820 let bytes_len = len * envelope_size;
821 let offset = decoder.out_of_line_offset(bytes_len)?;
822 let mut _next_ordinal_to_read = 0;
824 let mut next_offset = offset;
825 let end_offset = offset + bytes_len;
826 _next_ordinal_to_read += 1;
827 if next_offset >= end_offset {
828 return Ok(());
829 }
830
831 while _next_ordinal_to_read < 1 {
833 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
834 _next_ordinal_to_read += 1;
835 next_offset += envelope_size;
836 }
837
838 let next_out_of_line = decoder.next_out_of_line();
839 let handles_before = decoder.remaining_handles();
840 if let Some((inlined, num_bytes, num_handles)) =
841 fidl::encoding::decode_envelope_header(decoder, next_offset)?
842 {
843 let member_inline_size =
844 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
845 decoder.context,
846 );
847 if inlined != (member_inline_size <= 4) {
848 return Err(fidl::Error::InvalidInlineBitInEnvelope);
849 }
850 let inner_offset;
851 let mut inner_depth = depth.clone();
852 if inlined {
853 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
854 inner_offset = next_offset;
855 } else {
856 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
857 inner_depth.increment()?;
858 }
859 let val_ref = self
860 .addressing
861 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
862 fidl::decode!(
863 fidl::encoding::BoundedString<256>,
864 D,
865 val_ref,
866 decoder,
867 inner_offset,
868 inner_depth
869 )?;
870 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
871 {
872 return Err(fidl::Error::InvalidNumBytesInEnvelope);
873 }
874 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
875 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
876 }
877 }
878
879 next_offset += envelope_size;
880 _next_ordinal_to_read += 1;
881 if next_offset >= end_offset {
882 return Ok(());
883 }
884
885 while _next_ordinal_to_read < 2 {
887 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
888 _next_ordinal_to_read += 1;
889 next_offset += envelope_size;
890 }
891
892 let next_out_of_line = decoder.next_out_of_line();
893 let handles_before = decoder.remaining_handles();
894 if let Some((inlined, num_bytes, num_handles)) =
895 fidl::encoding::decode_envelope_header(decoder, next_offset)?
896 {
897 let member_inline_size =
898 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
899 decoder.context,
900 );
901 if inlined != (member_inline_size <= 4) {
902 return Err(fidl::Error::InvalidInlineBitInEnvelope);
903 }
904 let inner_offset;
905 let mut inner_depth = depth.clone();
906 if inlined {
907 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
908 inner_offset = next_offset;
909 } else {
910 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
911 inner_depth.increment()?;
912 }
913 let val_ref = self
914 .name
915 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
916 fidl::decode!(
917 fidl::encoding::BoundedString<256>,
918 D,
919 val_ref,
920 decoder,
921 inner_offset,
922 inner_depth
923 )?;
924 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
925 {
926 return Err(fidl::Error::InvalidNumBytesInEnvelope);
927 }
928 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
929 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
930 }
931 }
932
933 next_offset += envelope_size;
934
935 while next_offset < end_offset {
937 _next_ordinal_to_read += 1;
938 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
939 next_offset += envelope_size;
940 }
941
942 Ok(())
943 }
944 }
945
946 impl MasInstance {
947 #[inline(always)]
948 fn max_ordinal_present(&self) -> u64 {
949 if let Some(_) = self.supports_notification {
950 return 3;
951 }
952 if let Some(_) = self.supported_message_types {
953 return 2;
954 }
955 if let Some(_) = self.id {
956 return 1;
957 }
958 0
959 }
960 }
961
962 impl fidl::encoding::ValueTypeMarker for MasInstance {
963 type Borrowed<'a> = &'a Self;
964 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
965 value
966 }
967 }
968
969 unsafe impl fidl::encoding::TypeMarker for MasInstance {
970 type Owned = Self;
971
972 #[inline(always)]
973 fn inline_align(_context: fidl::encoding::Context) -> usize {
974 8
975 }
976
977 #[inline(always)]
978 fn inline_size(_context: fidl::encoding::Context) -> usize {
979 16
980 }
981 }
982
983 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MasInstance, D>
984 for &MasInstance
985 {
986 unsafe fn encode(
987 self,
988 encoder: &mut fidl::encoding::Encoder<'_, D>,
989 offset: usize,
990 mut depth: fidl::encoding::Depth,
991 ) -> fidl::Result<()> {
992 encoder.debug_check_bounds::<MasInstance>(offset);
993 let max_ordinal: u64 = self.max_ordinal_present();
995 encoder.write_num(max_ordinal, offset);
996 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
997 if max_ordinal == 0 {
999 return Ok(());
1000 }
1001 depth.increment()?;
1002 let envelope_size = 8;
1003 let bytes_len = max_ordinal as usize * envelope_size;
1004 #[allow(unused_variables)]
1005 let offset = encoder.out_of_line_offset(bytes_len);
1006 let mut _prev_end_offset: usize = 0;
1007 if 1 > max_ordinal {
1008 return Ok(());
1009 }
1010
1011 let cur_offset: usize = (1 - 1) * envelope_size;
1014
1015 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1017
1018 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1023 self.id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1024 encoder,
1025 offset + cur_offset,
1026 depth,
1027 )?;
1028
1029 _prev_end_offset = cur_offset + envelope_size;
1030 if 2 > max_ordinal {
1031 return Ok(());
1032 }
1033
1034 let cur_offset: usize = (2 - 1) * envelope_size;
1037
1038 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1040
1041 fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
1046 self.supported_message_types
1047 .as_ref()
1048 .map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1049 encoder,
1050 offset + cur_offset,
1051 depth,
1052 )?;
1053
1054 _prev_end_offset = cur_offset + envelope_size;
1055 if 3 > max_ordinal {
1056 return Ok(());
1057 }
1058
1059 let cur_offset: usize = (3 - 1) * envelope_size;
1062
1063 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1065
1066 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1071 self.supports_notification
1072 .as_ref()
1073 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1074 encoder,
1075 offset + cur_offset,
1076 depth,
1077 )?;
1078
1079 _prev_end_offset = cur_offset + envelope_size;
1080
1081 Ok(())
1082 }
1083 }
1084
1085 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MasInstance {
1086 #[inline(always)]
1087 fn new_empty() -> Self {
1088 Self::default()
1089 }
1090
1091 unsafe fn decode(
1092 &mut self,
1093 decoder: &mut fidl::encoding::Decoder<'_, D>,
1094 offset: usize,
1095 mut depth: fidl::encoding::Depth,
1096 ) -> fidl::Result<()> {
1097 decoder.debug_check_bounds::<Self>(offset);
1098 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1099 None => return Err(fidl::Error::NotNullable),
1100 Some(len) => len,
1101 };
1102 if len == 0 {
1104 return Ok(());
1105 };
1106 depth.increment()?;
1107 let envelope_size = 8;
1108 let bytes_len = len * envelope_size;
1109 let offset = decoder.out_of_line_offset(bytes_len)?;
1110 let mut _next_ordinal_to_read = 0;
1112 let mut next_offset = offset;
1113 let end_offset = offset + bytes_len;
1114 _next_ordinal_to_read += 1;
1115 if next_offset >= end_offset {
1116 return Ok(());
1117 }
1118
1119 while _next_ordinal_to_read < 1 {
1121 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1122 _next_ordinal_to_read += 1;
1123 next_offset += envelope_size;
1124 }
1125
1126 let next_out_of_line = decoder.next_out_of_line();
1127 let handles_before = decoder.remaining_handles();
1128 if let Some((inlined, num_bytes, num_handles)) =
1129 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1130 {
1131 let member_inline_size =
1132 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1133 if inlined != (member_inline_size <= 4) {
1134 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1135 }
1136 let inner_offset;
1137 let mut inner_depth = depth.clone();
1138 if inlined {
1139 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1140 inner_offset = next_offset;
1141 } else {
1142 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1143 inner_depth.increment()?;
1144 }
1145 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1146 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1147 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1148 {
1149 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1150 }
1151 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1152 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1153 }
1154 }
1155
1156 next_offset += envelope_size;
1157 _next_ordinal_to_read += 1;
1158 if next_offset >= end_offset {
1159 return Ok(());
1160 }
1161
1162 while _next_ordinal_to_read < 2 {
1164 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1165 _next_ordinal_to_read += 1;
1166 next_offset += envelope_size;
1167 }
1168
1169 let next_out_of_line = decoder.next_out_of_line();
1170 let handles_before = decoder.remaining_handles();
1171 if let Some((inlined, num_bytes, num_handles)) =
1172 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1173 {
1174 let member_inline_size =
1175 <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1176 if inlined != (member_inline_size <= 4) {
1177 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1178 }
1179 let inner_offset;
1180 let mut inner_depth = depth.clone();
1181 if inlined {
1182 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1183 inner_offset = next_offset;
1184 } else {
1185 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1186 inner_depth.increment()?;
1187 }
1188 let val_ref = self
1189 .supported_message_types
1190 .get_or_insert_with(|| fidl::new_empty!(MessageType, D));
1191 fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1192 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1193 {
1194 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1195 }
1196 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1197 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1198 }
1199 }
1200
1201 next_offset += envelope_size;
1202 _next_ordinal_to_read += 1;
1203 if next_offset >= end_offset {
1204 return Ok(());
1205 }
1206
1207 while _next_ordinal_to_read < 3 {
1209 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1210 _next_ordinal_to_read += 1;
1211 next_offset += envelope_size;
1212 }
1213
1214 let next_out_of_line = decoder.next_out_of_line();
1215 let handles_before = decoder.remaining_handles();
1216 if let Some((inlined, num_bytes, num_handles)) =
1217 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1218 {
1219 let member_inline_size =
1220 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1221 if inlined != (member_inline_size <= 4) {
1222 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1223 }
1224 let inner_offset;
1225 let mut inner_depth = depth.clone();
1226 if inlined {
1227 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1228 inner_offset = next_offset;
1229 } else {
1230 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1231 inner_depth.increment()?;
1232 }
1233 let val_ref =
1234 self.supports_notification.get_or_insert_with(|| fidl::new_empty!(bool, D));
1235 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1236 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1237 {
1238 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1239 }
1240 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1241 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1242 }
1243 }
1244
1245 next_offset += envelope_size;
1246
1247 while next_offset < end_offset {
1249 _next_ordinal_to_read += 1;
1250 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1251 next_offset += envelope_size;
1252 }
1253
1254 Ok(())
1255 }
1256 }
1257
1258 impl Message {
1259 #[inline(always)]
1260 fn max_ordinal_present(&self) -> u64 {
1261 if let Some(_) = self.conversation_id {
1262 return 13;
1263 }
1264 if let Some(_) = self.protected {
1265 return 12;
1266 }
1267 if let Some(_) = self.sent {
1268 return 11;
1269 }
1270 if let Some(_) = self.read {
1271 return 10;
1272 }
1273 if let Some(_) = self.priority {
1274 return 9;
1275 }
1276 if let Some(_) = self.folder {
1277 return 8;
1278 }
1279 if let Some(_) = self.content {
1280 return 7;
1281 }
1282 if let Some(_) = self.type_ {
1283 return 6;
1284 }
1285 if let Some(_) = self.recipient {
1286 return 5;
1287 }
1288 if let Some(_) = self.sender {
1289 return 4;
1290 }
1291 if let Some(_) = self.timestamp {
1292 return 3;
1293 }
1294 if let Some(_) = self.subject {
1295 return 2;
1296 }
1297 if let Some(_) = self.handle {
1298 return 1;
1299 }
1300 0
1301 }
1302 }
1303
1304 impl fidl::encoding::ValueTypeMarker for Message {
1305 type Borrowed<'a> = &'a Self;
1306 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1307 value
1308 }
1309 }
1310
1311 unsafe impl fidl::encoding::TypeMarker for Message {
1312 type Owned = Self;
1313
1314 #[inline(always)]
1315 fn inline_align(_context: fidl::encoding::Context) -> usize {
1316 8
1317 }
1318
1319 #[inline(always)]
1320 fn inline_size(_context: fidl::encoding::Context) -> usize {
1321 16
1322 }
1323 }
1324
1325 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Message, D> for &Message {
1326 unsafe fn encode(
1327 self,
1328 encoder: &mut fidl::encoding::Encoder<'_, D>,
1329 offset: usize,
1330 mut depth: fidl::encoding::Depth,
1331 ) -> fidl::Result<()> {
1332 encoder.debug_check_bounds::<Message>(offset);
1333 let max_ordinal: u64 = self.max_ordinal_present();
1335 encoder.write_num(max_ordinal, offset);
1336 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1337 if max_ordinal == 0 {
1339 return Ok(());
1340 }
1341 depth.increment()?;
1342 let envelope_size = 8;
1343 let bytes_len = max_ordinal as usize * envelope_size;
1344 #[allow(unused_variables)]
1345 let offset = encoder.out_of_line_offset(bytes_len);
1346 let mut _prev_end_offset: usize = 0;
1347 if 1 > max_ordinal {
1348 return Ok(());
1349 }
1350
1351 let cur_offset: usize = (1 - 1) * envelope_size;
1354
1355 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1357
1358 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1363 self.handle.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1364 encoder,
1365 offset + cur_offset,
1366 depth,
1367 )?;
1368
1369 _prev_end_offset = cur_offset + envelope_size;
1370 if 2 > max_ordinal {
1371 return Ok(());
1372 }
1373
1374 let cur_offset: usize = (2 - 1) * envelope_size;
1377
1378 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1380
1381 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
1386 self.subject.as_ref().map(
1387 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
1388 ),
1389 encoder,
1390 offset + cur_offset,
1391 depth,
1392 )?;
1393
1394 _prev_end_offset = cur_offset + envelope_size;
1395 if 3 > max_ordinal {
1396 return Ok(());
1397 }
1398
1399 let cur_offset: usize = (3 - 1) * envelope_size;
1402
1403 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1405
1406 fidl::encoding::encode_in_envelope_optional::<i64, D>(
1411 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1412 encoder,
1413 offset + cur_offset,
1414 depth,
1415 )?;
1416
1417 _prev_end_offset = cur_offset + envelope_size;
1418 if 4 > max_ordinal {
1419 return Ok(());
1420 }
1421
1422 let cur_offset: usize = (4 - 1) * envelope_size;
1425
1426 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1428
1429 fidl::encoding::encode_in_envelope_optional::<Audience, D>(
1434 self.sender.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
1435 encoder,
1436 offset + cur_offset,
1437 depth,
1438 )?;
1439
1440 _prev_end_offset = cur_offset + envelope_size;
1441 if 5 > max_ordinal {
1442 return Ok(());
1443 }
1444
1445 let cur_offset: usize = (5 - 1) * envelope_size;
1448
1449 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1451
1452 fidl::encoding::encode_in_envelope_optional::<Audience, D>(
1457 self.recipient.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
1458 encoder,
1459 offset + cur_offset,
1460 depth,
1461 )?;
1462
1463 _prev_end_offset = cur_offset + envelope_size;
1464 if 6 > max_ordinal {
1465 return Ok(());
1466 }
1467
1468 let cur_offset: usize = (6 - 1) * envelope_size;
1471
1472 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1474
1475 fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
1480 self.type_.as_ref().map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1481 encoder,
1482 offset + cur_offset,
1483 depth,
1484 )?;
1485
1486 _prev_end_offset = cur_offset + envelope_size;
1487 if 7 > max_ordinal {
1488 return Ok(());
1489 }
1490
1491 let cur_offset: usize = (7 - 1) * envelope_size;
1494
1495 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1497
1498 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1503 self.content.as_ref().map(
1504 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1505 ),
1506 encoder,
1507 offset + cur_offset,
1508 depth,
1509 )?;
1510
1511 _prev_end_offset = cur_offset + envelope_size;
1512 if 8 > max_ordinal {
1513 return Ok(());
1514 }
1515
1516 let cur_offset: usize = (8 - 1) * envelope_size;
1519
1520 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1522
1523 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<512>, D>(
1528 self.folder.as_ref().map(
1529 <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow,
1530 ),
1531 encoder,
1532 offset + cur_offset,
1533 depth,
1534 )?;
1535
1536 _prev_end_offset = cur_offset + envelope_size;
1537 if 9 > max_ordinal {
1538 return Ok(());
1539 }
1540
1541 let cur_offset: usize = (9 - 1) * envelope_size;
1544
1545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1547
1548 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1553 self.priority.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1554 encoder,
1555 offset + cur_offset,
1556 depth,
1557 )?;
1558
1559 _prev_end_offset = cur_offset + envelope_size;
1560 if 10 > max_ordinal {
1561 return Ok(());
1562 }
1563
1564 let cur_offset: usize = (10 - 1) * envelope_size;
1567
1568 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1570
1571 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1576 self.read.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1577 encoder,
1578 offset + cur_offset,
1579 depth,
1580 )?;
1581
1582 _prev_end_offset = cur_offset + envelope_size;
1583 if 11 > max_ordinal {
1584 return Ok(());
1585 }
1586
1587 let cur_offset: usize = (11 - 1) * envelope_size;
1590
1591 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1593
1594 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1599 self.sent.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1600 encoder,
1601 offset + cur_offset,
1602 depth,
1603 )?;
1604
1605 _prev_end_offset = cur_offset + envelope_size;
1606 if 12 > max_ordinal {
1607 return Ok(());
1608 }
1609
1610 let cur_offset: usize = (12 - 1) * envelope_size;
1613
1614 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1616
1617 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1622 self.protected.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1623 encoder,
1624 offset + cur_offset,
1625 depth,
1626 )?;
1627
1628 _prev_end_offset = cur_offset + envelope_size;
1629 if 13 > max_ordinal {
1630 return Ok(());
1631 }
1632
1633 let cur_offset: usize = (13 - 1) * envelope_size;
1636
1637 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1639
1640 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
1645 self.conversation_id.as_ref().map(
1646 <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
1647 ),
1648 encoder,
1649 offset + cur_offset,
1650 depth,
1651 )?;
1652
1653 _prev_end_offset = cur_offset + envelope_size;
1654
1655 Ok(())
1656 }
1657 }
1658
1659 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Message {
1660 #[inline(always)]
1661 fn new_empty() -> Self {
1662 Self::default()
1663 }
1664
1665 unsafe fn decode(
1666 &mut self,
1667 decoder: &mut fidl::encoding::Decoder<'_, D>,
1668 offset: usize,
1669 mut depth: fidl::encoding::Depth,
1670 ) -> fidl::Result<()> {
1671 decoder.debug_check_bounds::<Self>(offset);
1672 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1673 None => return Err(fidl::Error::NotNullable),
1674 Some(len) => len,
1675 };
1676 if len == 0 {
1678 return Ok(());
1679 };
1680 depth.increment()?;
1681 let envelope_size = 8;
1682 let bytes_len = len * envelope_size;
1683 let offset = decoder.out_of_line_offset(bytes_len)?;
1684 let mut _next_ordinal_to_read = 0;
1686 let mut next_offset = offset;
1687 let end_offset = offset + bytes_len;
1688 _next_ordinal_to_read += 1;
1689 if next_offset >= end_offset {
1690 return Ok(());
1691 }
1692
1693 while _next_ordinal_to_read < 1 {
1695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1696 _next_ordinal_to_read += 1;
1697 next_offset += envelope_size;
1698 }
1699
1700 let next_out_of_line = decoder.next_out_of_line();
1701 let handles_before = decoder.remaining_handles();
1702 if let Some((inlined, num_bytes, num_handles)) =
1703 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1704 {
1705 let member_inline_size =
1706 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1707 if inlined != (member_inline_size <= 4) {
1708 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1709 }
1710 let inner_offset;
1711 let mut inner_depth = depth.clone();
1712 if inlined {
1713 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1714 inner_offset = next_offset;
1715 } else {
1716 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1717 inner_depth.increment()?;
1718 }
1719 let val_ref = self.handle.get_or_insert_with(|| fidl::new_empty!(u64, D));
1720 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1721 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1722 {
1723 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1724 }
1725 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1726 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1727 }
1728 }
1729
1730 next_offset += envelope_size;
1731 _next_ordinal_to_read += 1;
1732 if next_offset >= end_offset {
1733 return Ok(());
1734 }
1735
1736 while _next_ordinal_to_read < 2 {
1738 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1739 _next_ordinal_to_read += 1;
1740 next_offset += envelope_size;
1741 }
1742
1743 let next_out_of_line = decoder.next_out_of_line();
1744 let handles_before = decoder.remaining_handles();
1745 if let Some((inlined, num_bytes, num_handles)) =
1746 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1747 {
1748 let member_inline_size =
1749 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
1750 decoder.context,
1751 );
1752 if inlined != (member_inline_size <= 4) {
1753 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1754 }
1755 let inner_offset;
1756 let mut inner_depth = depth.clone();
1757 if inlined {
1758 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1759 inner_offset = next_offset;
1760 } else {
1761 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1762 inner_depth.increment()?;
1763 }
1764 let val_ref = self
1765 .subject
1766 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
1767 fidl::decode!(
1768 fidl::encoding::BoundedString<256>,
1769 D,
1770 val_ref,
1771 decoder,
1772 inner_offset,
1773 inner_depth
1774 )?;
1775 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1776 {
1777 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1778 }
1779 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1780 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1781 }
1782 }
1783
1784 next_offset += envelope_size;
1785 _next_ordinal_to_read += 1;
1786 if next_offset >= end_offset {
1787 return Ok(());
1788 }
1789
1790 while _next_ordinal_to_read < 3 {
1792 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1793 _next_ordinal_to_read += 1;
1794 next_offset += envelope_size;
1795 }
1796
1797 let next_out_of_line = decoder.next_out_of_line();
1798 let handles_before = decoder.remaining_handles();
1799 if let Some((inlined, num_bytes, num_handles)) =
1800 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1801 {
1802 let member_inline_size =
1803 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1804 if inlined != (member_inline_size <= 4) {
1805 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1806 }
1807 let inner_offset;
1808 let mut inner_depth = depth.clone();
1809 if inlined {
1810 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1811 inner_offset = next_offset;
1812 } else {
1813 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1814 inner_depth.increment()?;
1815 }
1816 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
1817 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1818 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1819 {
1820 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1821 }
1822 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1823 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1824 }
1825 }
1826
1827 next_offset += envelope_size;
1828 _next_ordinal_to_read += 1;
1829 if next_offset >= end_offset {
1830 return Ok(());
1831 }
1832
1833 while _next_ordinal_to_read < 4 {
1835 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1836 _next_ordinal_to_read += 1;
1837 next_offset += envelope_size;
1838 }
1839
1840 let next_out_of_line = decoder.next_out_of_line();
1841 let handles_before = decoder.remaining_handles();
1842 if let Some((inlined, num_bytes, num_handles)) =
1843 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1844 {
1845 let member_inline_size =
1846 <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1847 if inlined != (member_inline_size <= 4) {
1848 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1849 }
1850 let inner_offset;
1851 let mut inner_depth = depth.clone();
1852 if inlined {
1853 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1854 inner_offset = next_offset;
1855 } else {
1856 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1857 inner_depth.increment()?;
1858 }
1859 let val_ref = self.sender.get_or_insert_with(|| fidl::new_empty!(Audience, D));
1860 fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
1861 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1862 {
1863 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1864 }
1865 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1866 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1867 }
1868 }
1869
1870 next_offset += envelope_size;
1871 _next_ordinal_to_read += 1;
1872 if next_offset >= end_offset {
1873 return Ok(());
1874 }
1875
1876 while _next_ordinal_to_read < 5 {
1878 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1879 _next_ordinal_to_read += 1;
1880 next_offset += envelope_size;
1881 }
1882
1883 let next_out_of_line = decoder.next_out_of_line();
1884 let handles_before = decoder.remaining_handles();
1885 if let Some((inlined, num_bytes, num_handles)) =
1886 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1887 {
1888 let member_inline_size =
1889 <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1890 if inlined != (member_inline_size <= 4) {
1891 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1892 }
1893 let inner_offset;
1894 let mut inner_depth = depth.clone();
1895 if inlined {
1896 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1897 inner_offset = next_offset;
1898 } else {
1899 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1900 inner_depth.increment()?;
1901 }
1902 let val_ref = self.recipient.get_or_insert_with(|| fidl::new_empty!(Audience, D));
1903 fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
1904 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1905 {
1906 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1907 }
1908 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1909 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1910 }
1911 }
1912
1913 next_offset += envelope_size;
1914 _next_ordinal_to_read += 1;
1915 if next_offset >= end_offset {
1916 return Ok(());
1917 }
1918
1919 while _next_ordinal_to_read < 6 {
1921 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1922 _next_ordinal_to_read += 1;
1923 next_offset += envelope_size;
1924 }
1925
1926 let next_out_of_line = decoder.next_out_of_line();
1927 let handles_before = decoder.remaining_handles();
1928 if let Some((inlined, num_bytes, num_handles)) =
1929 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1930 {
1931 let member_inline_size =
1932 <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1933 if inlined != (member_inline_size <= 4) {
1934 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1935 }
1936 let inner_offset;
1937 let mut inner_depth = depth.clone();
1938 if inlined {
1939 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1940 inner_offset = next_offset;
1941 } else {
1942 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1943 inner_depth.increment()?;
1944 }
1945 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(MessageType, D));
1946 fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1947 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1948 {
1949 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1950 }
1951 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1952 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1953 }
1954 }
1955
1956 next_offset += envelope_size;
1957 _next_ordinal_to_read += 1;
1958 if next_offset >= end_offset {
1959 return Ok(());
1960 }
1961
1962 while _next_ordinal_to_read < 7 {
1964 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1965 _next_ordinal_to_read += 1;
1966 next_offset += envelope_size;
1967 }
1968
1969 let next_out_of_line = decoder.next_out_of_line();
1970 let handles_before = decoder.remaining_handles();
1971 if let Some((inlined, num_bytes, num_handles)) =
1972 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1973 {
1974 let member_inline_size =
1975 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1976 decoder.context,
1977 );
1978 if inlined != (member_inline_size <= 4) {
1979 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1980 }
1981 let inner_offset;
1982 let mut inner_depth = depth.clone();
1983 if inlined {
1984 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1985 inner_offset = next_offset;
1986 } else {
1987 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1988 inner_depth.increment()?;
1989 }
1990 let val_ref = self
1991 .content
1992 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1993 fidl::decode!(
1994 fidl::encoding::UnboundedString,
1995 D,
1996 val_ref,
1997 decoder,
1998 inner_offset,
1999 inner_depth
2000 )?;
2001 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2002 {
2003 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2004 }
2005 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2006 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2007 }
2008 }
2009
2010 next_offset += envelope_size;
2011 _next_ordinal_to_read += 1;
2012 if next_offset >= end_offset {
2013 return Ok(());
2014 }
2015
2016 while _next_ordinal_to_read < 8 {
2018 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2019 _next_ordinal_to_read += 1;
2020 next_offset += envelope_size;
2021 }
2022
2023 let next_out_of_line = decoder.next_out_of_line();
2024 let handles_before = decoder.remaining_handles();
2025 if let Some((inlined, num_bytes, num_handles)) =
2026 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2027 {
2028 let member_inline_size =
2029 <fidl::encoding::BoundedString<512> as fidl::encoding::TypeMarker>::inline_size(
2030 decoder.context,
2031 );
2032 if inlined != (member_inline_size <= 4) {
2033 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2034 }
2035 let inner_offset;
2036 let mut inner_depth = depth.clone();
2037 if inlined {
2038 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2039 inner_offset = next_offset;
2040 } else {
2041 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2042 inner_depth.increment()?;
2043 }
2044 let val_ref = self
2045 .folder
2046 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<512>, D));
2047 fidl::decode!(
2048 fidl::encoding::BoundedString<512>,
2049 D,
2050 val_ref,
2051 decoder,
2052 inner_offset,
2053 inner_depth
2054 )?;
2055 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2056 {
2057 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2058 }
2059 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2060 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2061 }
2062 }
2063
2064 next_offset += envelope_size;
2065 _next_ordinal_to_read += 1;
2066 if next_offset >= end_offset {
2067 return Ok(());
2068 }
2069
2070 while _next_ordinal_to_read < 9 {
2072 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2073 _next_ordinal_to_read += 1;
2074 next_offset += envelope_size;
2075 }
2076
2077 let next_out_of_line = decoder.next_out_of_line();
2078 let handles_before = decoder.remaining_handles();
2079 if let Some((inlined, num_bytes, num_handles)) =
2080 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2081 {
2082 let member_inline_size =
2083 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2084 if inlined != (member_inline_size <= 4) {
2085 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2086 }
2087 let inner_offset;
2088 let mut inner_depth = depth.clone();
2089 if inlined {
2090 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2091 inner_offset = next_offset;
2092 } else {
2093 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2094 inner_depth.increment()?;
2095 }
2096 let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(bool, D));
2097 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2098 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2099 {
2100 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2101 }
2102 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2103 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2104 }
2105 }
2106
2107 next_offset += envelope_size;
2108 _next_ordinal_to_read += 1;
2109 if next_offset >= end_offset {
2110 return Ok(());
2111 }
2112
2113 while _next_ordinal_to_read < 10 {
2115 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2116 _next_ordinal_to_read += 1;
2117 next_offset += envelope_size;
2118 }
2119
2120 let next_out_of_line = decoder.next_out_of_line();
2121 let handles_before = decoder.remaining_handles();
2122 if let Some((inlined, num_bytes, num_handles)) =
2123 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2124 {
2125 let member_inline_size =
2126 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2127 if inlined != (member_inline_size <= 4) {
2128 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2129 }
2130 let inner_offset;
2131 let mut inner_depth = depth.clone();
2132 if inlined {
2133 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2134 inner_offset = next_offset;
2135 } else {
2136 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2137 inner_depth.increment()?;
2138 }
2139 let val_ref = self.read.get_or_insert_with(|| fidl::new_empty!(bool, D));
2140 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2141 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2142 {
2143 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2144 }
2145 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2146 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2147 }
2148 }
2149
2150 next_offset += envelope_size;
2151 _next_ordinal_to_read += 1;
2152 if next_offset >= end_offset {
2153 return Ok(());
2154 }
2155
2156 while _next_ordinal_to_read < 11 {
2158 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2159 _next_ordinal_to_read += 1;
2160 next_offset += envelope_size;
2161 }
2162
2163 let next_out_of_line = decoder.next_out_of_line();
2164 let handles_before = decoder.remaining_handles();
2165 if let Some((inlined, num_bytes, num_handles)) =
2166 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2167 {
2168 let member_inline_size =
2169 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2170 if inlined != (member_inline_size <= 4) {
2171 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2172 }
2173 let inner_offset;
2174 let mut inner_depth = depth.clone();
2175 if inlined {
2176 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2177 inner_offset = next_offset;
2178 } else {
2179 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2180 inner_depth.increment()?;
2181 }
2182 let val_ref = self.sent.get_or_insert_with(|| fidl::new_empty!(bool, D));
2183 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2184 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2185 {
2186 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2187 }
2188 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2189 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2190 }
2191 }
2192
2193 next_offset += envelope_size;
2194 _next_ordinal_to_read += 1;
2195 if next_offset >= end_offset {
2196 return Ok(());
2197 }
2198
2199 while _next_ordinal_to_read < 12 {
2201 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2202 _next_ordinal_to_read += 1;
2203 next_offset += envelope_size;
2204 }
2205
2206 let next_out_of_line = decoder.next_out_of_line();
2207 let handles_before = decoder.remaining_handles();
2208 if let Some((inlined, num_bytes, num_handles)) =
2209 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2210 {
2211 let member_inline_size =
2212 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2213 if inlined != (member_inline_size <= 4) {
2214 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2215 }
2216 let inner_offset;
2217 let mut inner_depth = depth.clone();
2218 if inlined {
2219 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2220 inner_offset = next_offset;
2221 } else {
2222 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2223 inner_depth.increment()?;
2224 }
2225 let val_ref = self.protected.get_or_insert_with(|| fidl::new_empty!(bool, D));
2226 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2227 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2228 {
2229 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2230 }
2231 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2232 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2233 }
2234 }
2235
2236 next_offset += envelope_size;
2237 _next_ordinal_to_read += 1;
2238 if next_offset >= end_offset {
2239 return Ok(());
2240 }
2241
2242 while _next_ordinal_to_read < 13 {
2244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2245 _next_ordinal_to_read += 1;
2246 next_offset += envelope_size;
2247 }
2248
2249 let next_out_of_line = decoder.next_out_of_line();
2250 let handles_before = decoder.remaining_handles();
2251 if let Some((inlined, num_bytes, num_handles)) =
2252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2253 {
2254 let member_inline_size =
2255 <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
2256 decoder.context,
2257 );
2258 if inlined != (member_inline_size <= 4) {
2259 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2260 }
2261 let inner_offset;
2262 let mut inner_depth = depth.clone();
2263 if inlined {
2264 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2265 inner_offset = next_offset;
2266 } else {
2267 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2268 inner_depth.increment()?;
2269 }
2270 let val_ref = self
2271 .conversation_id
2272 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
2273 fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
2274 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2275 {
2276 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2277 }
2278 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2279 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2280 }
2281 }
2282
2283 next_offset += envelope_size;
2284
2285 while next_offset < end_offset {
2287 _next_ordinal_to_read += 1;
2288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2289 next_offset += envelope_size;
2290 }
2291
2292 Ok(())
2293 }
2294 }
2295
2296 impl Notification {
2297 #[inline(always)]
2298 fn max_ordinal_present(&self) -> u64 {
2299 if let Some(_) = self.priority {
2300 return 9;
2301 }
2302 if let Some(_) = self.sender {
2303 return 8;
2304 }
2305 if let Some(_) = self.subject {
2306 return 7;
2307 }
2308 if let Some(_) = self.timestamp {
2309 return 6;
2310 }
2311 if let Some(_) = self.message_type {
2312 return 5;
2313 }
2314 if let Some(_) = self.folder {
2315 return 4;
2316 }
2317 if let Some(_) = self.message_handle {
2318 return 3;
2319 }
2320 if let Some(_) = self.mas_instance_id {
2321 return 2;
2322 }
2323 if let Some(_) = self.type_ {
2324 return 1;
2325 }
2326 0
2327 }
2328 }
2329
2330 impl fidl::encoding::ValueTypeMarker for Notification {
2331 type Borrowed<'a> = &'a Self;
2332 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2333 value
2334 }
2335 }
2336
2337 unsafe impl fidl::encoding::TypeMarker for Notification {
2338 type Owned = Self;
2339
2340 #[inline(always)]
2341 fn inline_align(_context: fidl::encoding::Context) -> usize {
2342 8
2343 }
2344
2345 #[inline(always)]
2346 fn inline_size(_context: fidl::encoding::Context) -> usize {
2347 16
2348 }
2349 }
2350
2351 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Notification, D>
2352 for &Notification
2353 {
2354 unsafe fn encode(
2355 self,
2356 encoder: &mut fidl::encoding::Encoder<'_, D>,
2357 offset: usize,
2358 mut depth: fidl::encoding::Depth,
2359 ) -> fidl::Result<()> {
2360 encoder.debug_check_bounds::<Notification>(offset);
2361 let max_ordinal: u64 = self.max_ordinal_present();
2363 encoder.write_num(max_ordinal, offset);
2364 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2365 if max_ordinal == 0 {
2367 return Ok(());
2368 }
2369 depth.increment()?;
2370 let envelope_size = 8;
2371 let bytes_len = max_ordinal as usize * envelope_size;
2372 #[allow(unused_variables)]
2373 let offset = encoder.out_of_line_offset(bytes_len);
2374 let mut _prev_end_offset: usize = 0;
2375 if 1 > max_ordinal {
2376 return Ok(());
2377 }
2378
2379 let cur_offset: usize = (1 - 1) * envelope_size;
2382
2383 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2385
2386 fidl::encoding::encode_in_envelope_optional::<NotificationType, D>(
2391 self.type_
2392 .as_ref()
2393 .map(<NotificationType as fidl::encoding::ValueTypeMarker>::borrow),
2394 encoder,
2395 offset + cur_offset,
2396 depth,
2397 )?;
2398
2399 _prev_end_offset = cur_offset + envelope_size;
2400 if 2 > max_ordinal {
2401 return Ok(());
2402 }
2403
2404 let cur_offset: usize = (2 - 1) * envelope_size;
2407
2408 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2410
2411 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2416 self.mas_instance_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2417 encoder,
2418 offset + cur_offset,
2419 depth,
2420 )?;
2421
2422 _prev_end_offset = cur_offset + envelope_size;
2423 if 3 > max_ordinal {
2424 return Ok(());
2425 }
2426
2427 let cur_offset: usize = (3 - 1) * envelope_size;
2430
2431 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2433
2434 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2439 self.message_handle.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2440 encoder,
2441 offset + cur_offset,
2442 depth,
2443 )?;
2444
2445 _prev_end_offset = cur_offset + envelope_size;
2446 if 4 > max_ordinal {
2447 return Ok(());
2448 }
2449
2450 let cur_offset: usize = (4 - 1) * envelope_size;
2453
2454 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2456
2457 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<512>, D>(
2462 self.folder.as_ref().map(
2463 <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow,
2464 ),
2465 encoder,
2466 offset + cur_offset,
2467 depth,
2468 )?;
2469
2470 _prev_end_offset = cur_offset + envelope_size;
2471 if 5 > max_ordinal {
2472 return Ok(());
2473 }
2474
2475 let cur_offset: usize = (5 - 1) * envelope_size;
2478
2479 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2481
2482 fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
2487 self.message_type
2488 .as_ref()
2489 .map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
2490 encoder,
2491 offset + cur_offset,
2492 depth,
2493 )?;
2494
2495 _prev_end_offset = cur_offset + envelope_size;
2496 if 6 > max_ordinal {
2497 return Ok(());
2498 }
2499
2500 let cur_offset: usize = (6 - 1) * envelope_size;
2503
2504 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2506
2507 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2512 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2513 encoder,
2514 offset + cur_offset,
2515 depth,
2516 )?;
2517
2518 _prev_end_offset = cur_offset + envelope_size;
2519 if 7 > max_ordinal {
2520 return Ok(());
2521 }
2522
2523 let cur_offset: usize = (7 - 1) * envelope_size;
2526
2527 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2529
2530 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
2535 self.subject.as_ref().map(
2536 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
2537 ),
2538 encoder,
2539 offset + cur_offset,
2540 depth,
2541 )?;
2542
2543 _prev_end_offset = cur_offset + envelope_size;
2544 if 8 > max_ordinal {
2545 return Ok(());
2546 }
2547
2548 let cur_offset: usize = (8 - 1) * envelope_size;
2551
2552 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2554
2555 fidl::encoding::encode_in_envelope_optional::<Audience, D>(
2560 self.sender.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
2561 encoder,
2562 offset + cur_offset,
2563 depth,
2564 )?;
2565
2566 _prev_end_offset = cur_offset + envelope_size;
2567 if 9 > max_ordinal {
2568 return Ok(());
2569 }
2570
2571 let cur_offset: usize = (9 - 1) * envelope_size;
2574
2575 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2577
2578 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2583 self.priority.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2584 encoder,
2585 offset + cur_offset,
2586 depth,
2587 )?;
2588
2589 _prev_end_offset = cur_offset + envelope_size;
2590
2591 Ok(())
2592 }
2593 }
2594
2595 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notification {
2596 #[inline(always)]
2597 fn new_empty() -> Self {
2598 Self::default()
2599 }
2600
2601 unsafe fn decode(
2602 &mut self,
2603 decoder: &mut fidl::encoding::Decoder<'_, D>,
2604 offset: usize,
2605 mut depth: fidl::encoding::Depth,
2606 ) -> fidl::Result<()> {
2607 decoder.debug_check_bounds::<Self>(offset);
2608 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2609 None => return Err(fidl::Error::NotNullable),
2610 Some(len) => len,
2611 };
2612 if len == 0 {
2614 return Ok(());
2615 };
2616 depth.increment()?;
2617 let envelope_size = 8;
2618 let bytes_len = len * envelope_size;
2619 let offset = decoder.out_of_line_offset(bytes_len)?;
2620 let mut _next_ordinal_to_read = 0;
2622 let mut next_offset = offset;
2623 let end_offset = offset + bytes_len;
2624 _next_ordinal_to_read += 1;
2625 if next_offset >= end_offset {
2626 return Ok(());
2627 }
2628
2629 while _next_ordinal_to_read < 1 {
2631 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2632 _next_ordinal_to_read += 1;
2633 next_offset += envelope_size;
2634 }
2635
2636 let next_out_of_line = decoder.next_out_of_line();
2637 let handles_before = decoder.remaining_handles();
2638 if let Some((inlined, num_bytes, num_handles)) =
2639 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2640 {
2641 let member_inline_size =
2642 <NotificationType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2643 if inlined != (member_inline_size <= 4) {
2644 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2645 }
2646 let inner_offset;
2647 let mut inner_depth = depth.clone();
2648 if inlined {
2649 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2650 inner_offset = next_offset;
2651 } else {
2652 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2653 inner_depth.increment()?;
2654 }
2655 let val_ref =
2656 self.type_.get_or_insert_with(|| fidl::new_empty!(NotificationType, D));
2657 fidl::decode!(NotificationType, D, val_ref, decoder, inner_offset, inner_depth)?;
2658 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2659 {
2660 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2661 }
2662 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2663 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2664 }
2665 }
2666
2667 next_offset += envelope_size;
2668 _next_ordinal_to_read += 1;
2669 if next_offset >= end_offset {
2670 return Ok(());
2671 }
2672
2673 while _next_ordinal_to_read < 2 {
2675 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2676 _next_ordinal_to_read += 1;
2677 next_offset += envelope_size;
2678 }
2679
2680 let next_out_of_line = decoder.next_out_of_line();
2681 let handles_before = decoder.remaining_handles();
2682 if let Some((inlined, num_bytes, num_handles)) =
2683 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2684 {
2685 let member_inline_size =
2686 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2687 if inlined != (member_inline_size <= 4) {
2688 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2689 }
2690 let inner_offset;
2691 let mut inner_depth = depth.clone();
2692 if inlined {
2693 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2694 inner_offset = next_offset;
2695 } else {
2696 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2697 inner_depth.increment()?;
2698 }
2699 let val_ref = self.mas_instance_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
2700 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2701 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2702 {
2703 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2704 }
2705 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2706 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2707 }
2708 }
2709
2710 next_offset += envelope_size;
2711 _next_ordinal_to_read += 1;
2712 if next_offset >= end_offset {
2713 return Ok(());
2714 }
2715
2716 while _next_ordinal_to_read < 3 {
2718 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2719 _next_ordinal_to_read += 1;
2720 next_offset += envelope_size;
2721 }
2722
2723 let next_out_of_line = decoder.next_out_of_line();
2724 let handles_before = decoder.remaining_handles();
2725 if let Some((inlined, num_bytes, num_handles)) =
2726 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2727 {
2728 let member_inline_size =
2729 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2730 if inlined != (member_inline_size <= 4) {
2731 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2732 }
2733 let inner_offset;
2734 let mut inner_depth = depth.clone();
2735 if inlined {
2736 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2737 inner_offset = next_offset;
2738 } else {
2739 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2740 inner_depth.increment()?;
2741 }
2742 let val_ref = self.message_handle.get_or_insert_with(|| fidl::new_empty!(u64, D));
2743 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2744 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2745 {
2746 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2747 }
2748 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2749 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2750 }
2751 }
2752
2753 next_offset += envelope_size;
2754 _next_ordinal_to_read += 1;
2755 if next_offset >= end_offset {
2756 return Ok(());
2757 }
2758
2759 while _next_ordinal_to_read < 4 {
2761 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2762 _next_ordinal_to_read += 1;
2763 next_offset += envelope_size;
2764 }
2765
2766 let next_out_of_line = decoder.next_out_of_line();
2767 let handles_before = decoder.remaining_handles();
2768 if let Some((inlined, num_bytes, num_handles)) =
2769 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2770 {
2771 let member_inline_size =
2772 <fidl::encoding::BoundedString<512> as fidl::encoding::TypeMarker>::inline_size(
2773 decoder.context,
2774 );
2775 if inlined != (member_inline_size <= 4) {
2776 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2777 }
2778 let inner_offset;
2779 let mut inner_depth = depth.clone();
2780 if inlined {
2781 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2782 inner_offset = next_offset;
2783 } else {
2784 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2785 inner_depth.increment()?;
2786 }
2787 let val_ref = self
2788 .folder
2789 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<512>, D));
2790 fidl::decode!(
2791 fidl::encoding::BoundedString<512>,
2792 D,
2793 val_ref,
2794 decoder,
2795 inner_offset,
2796 inner_depth
2797 )?;
2798 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2799 {
2800 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2801 }
2802 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2803 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2804 }
2805 }
2806
2807 next_offset += envelope_size;
2808 _next_ordinal_to_read += 1;
2809 if next_offset >= end_offset {
2810 return Ok(());
2811 }
2812
2813 while _next_ordinal_to_read < 5 {
2815 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2816 _next_ordinal_to_read += 1;
2817 next_offset += envelope_size;
2818 }
2819
2820 let next_out_of_line = decoder.next_out_of_line();
2821 let handles_before = decoder.remaining_handles();
2822 if let Some((inlined, num_bytes, num_handles)) =
2823 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2824 {
2825 let member_inline_size =
2826 <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2827 if inlined != (member_inline_size <= 4) {
2828 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2829 }
2830 let inner_offset;
2831 let mut inner_depth = depth.clone();
2832 if inlined {
2833 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2834 inner_offset = next_offset;
2835 } else {
2836 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2837 inner_depth.increment()?;
2838 }
2839 let val_ref =
2840 self.message_type.get_or_insert_with(|| fidl::new_empty!(MessageType, D));
2841 fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
2842 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2843 {
2844 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2845 }
2846 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2847 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2848 }
2849 }
2850
2851 next_offset += envelope_size;
2852 _next_ordinal_to_read += 1;
2853 if next_offset >= end_offset {
2854 return Ok(());
2855 }
2856
2857 while _next_ordinal_to_read < 6 {
2859 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2860 _next_ordinal_to_read += 1;
2861 next_offset += envelope_size;
2862 }
2863
2864 let next_out_of_line = decoder.next_out_of_line();
2865 let handles_before = decoder.remaining_handles();
2866 if let Some((inlined, num_bytes, num_handles)) =
2867 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2868 {
2869 let member_inline_size =
2870 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2871 if inlined != (member_inline_size <= 4) {
2872 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2873 }
2874 let inner_offset;
2875 let mut inner_depth = depth.clone();
2876 if inlined {
2877 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2878 inner_offset = next_offset;
2879 } else {
2880 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2881 inner_depth.increment()?;
2882 }
2883 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
2884 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2885 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2886 {
2887 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2888 }
2889 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2890 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2891 }
2892 }
2893
2894 next_offset += envelope_size;
2895 _next_ordinal_to_read += 1;
2896 if next_offset >= end_offset {
2897 return Ok(());
2898 }
2899
2900 while _next_ordinal_to_read < 7 {
2902 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2903 _next_ordinal_to_read += 1;
2904 next_offset += envelope_size;
2905 }
2906
2907 let next_out_of_line = decoder.next_out_of_line();
2908 let handles_before = decoder.remaining_handles();
2909 if let Some((inlined, num_bytes, num_handles)) =
2910 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2911 {
2912 let member_inline_size =
2913 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
2914 decoder.context,
2915 );
2916 if inlined != (member_inline_size <= 4) {
2917 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2918 }
2919 let inner_offset;
2920 let mut inner_depth = depth.clone();
2921 if inlined {
2922 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2923 inner_offset = next_offset;
2924 } else {
2925 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2926 inner_depth.increment()?;
2927 }
2928 let val_ref = self
2929 .subject
2930 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
2931 fidl::decode!(
2932 fidl::encoding::BoundedString<256>,
2933 D,
2934 val_ref,
2935 decoder,
2936 inner_offset,
2937 inner_depth
2938 )?;
2939 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2940 {
2941 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2942 }
2943 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2944 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2945 }
2946 }
2947
2948 next_offset += envelope_size;
2949 _next_ordinal_to_read += 1;
2950 if next_offset >= end_offset {
2951 return Ok(());
2952 }
2953
2954 while _next_ordinal_to_read < 8 {
2956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2957 _next_ordinal_to_read += 1;
2958 next_offset += envelope_size;
2959 }
2960
2961 let next_out_of_line = decoder.next_out_of_line();
2962 let handles_before = decoder.remaining_handles();
2963 if let Some((inlined, num_bytes, num_handles)) =
2964 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2965 {
2966 let member_inline_size =
2967 <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2968 if inlined != (member_inline_size <= 4) {
2969 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2970 }
2971 let inner_offset;
2972 let mut inner_depth = depth.clone();
2973 if inlined {
2974 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2975 inner_offset = next_offset;
2976 } else {
2977 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2978 inner_depth.increment()?;
2979 }
2980 let val_ref = self.sender.get_or_insert_with(|| fidl::new_empty!(Audience, D));
2981 fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
2982 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2983 {
2984 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2985 }
2986 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2987 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2988 }
2989 }
2990
2991 next_offset += envelope_size;
2992 _next_ordinal_to_read += 1;
2993 if next_offset >= end_offset {
2994 return Ok(());
2995 }
2996
2997 while _next_ordinal_to_read < 9 {
2999 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3000 _next_ordinal_to_read += 1;
3001 next_offset += envelope_size;
3002 }
3003
3004 let next_out_of_line = decoder.next_out_of_line();
3005 let handles_before = decoder.remaining_handles();
3006 if let Some((inlined, num_bytes, num_handles)) =
3007 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3008 {
3009 let member_inline_size =
3010 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3011 if inlined != (member_inline_size <= 4) {
3012 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3013 }
3014 let inner_offset;
3015 let mut inner_depth = depth.clone();
3016 if inlined {
3017 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3018 inner_offset = next_offset;
3019 } else {
3020 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3021 inner_depth.increment()?;
3022 }
3023 let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(bool, D));
3024 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3025 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3026 {
3027 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3028 }
3029 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3030 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3031 }
3032 }
3033
3034 next_offset += envelope_size;
3035
3036 while next_offset < end_offset {
3038 _next_ordinal_to_read += 1;
3039 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3040 next_offset += envelope_size;
3041 }
3042
3043 Ok(())
3044 }
3045 }
3046
3047 impl NotificationRegistrationNewEventReportRequest {
3048 #[inline(always)]
3049 fn max_ordinal_present(&self) -> u64 {
3050 if let Some(_) = self.received {
3051 return 2;
3052 }
3053 if let Some(_) = self.notification {
3054 return 1;
3055 }
3056 0
3057 }
3058 }
3059
3060 impl fidl::encoding::ValueTypeMarker for NotificationRegistrationNewEventReportRequest {
3061 type Borrowed<'a> = &'a Self;
3062 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3063 value
3064 }
3065 }
3066
3067 unsafe impl fidl::encoding::TypeMarker for NotificationRegistrationNewEventReportRequest {
3068 type Owned = Self;
3069
3070 #[inline(always)]
3071 fn inline_align(_context: fidl::encoding::Context) -> usize {
3072 8
3073 }
3074
3075 #[inline(always)]
3076 fn inline_size(_context: fidl::encoding::Context) -> usize {
3077 16
3078 }
3079 }
3080
3081 unsafe impl<D: fidl::encoding::ResourceDialect>
3082 fidl::encoding::Encode<NotificationRegistrationNewEventReportRequest, D>
3083 for &NotificationRegistrationNewEventReportRequest
3084 {
3085 unsafe fn encode(
3086 self,
3087 encoder: &mut fidl::encoding::Encoder<'_, D>,
3088 offset: usize,
3089 mut depth: fidl::encoding::Depth,
3090 ) -> fidl::Result<()> {
3091 encoder.debug_check_bounds::<NotificationRegistrationNewEventReportRequest>(offset);
3092 let max_ordinal: u64 = self.max_ordinal_present();
3094 encoder.write_num(max_ordinal, offset);
3095 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3096 if max_ordinal == 0 {
3098 return Ok(());
3099 }
3100 depth.increment()?;
3101 let envelope_size = 8;
3102 let bytes_len = max_ordinal as usize * envelope_size;
3103 #[allow(unused_variables)]
3104 let offset = encoder.out_of_line_offset(bytes_len);
3105 let mut _prev_end_offset: usize = 0;
3106 if 1 > max_ordinal {
3107 return Ok(());
3108 }
3109
3110 let cur_offset: usize = (1 - 1) * envelope_size;
3113
3114 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3116
3117 fidl::encoding::encode_in_envelope_optional::<Notification, D>(
3122 self.notification
3123 .as_ref()
3124 .map(<Notification as fidl::encoding::ValueTypeMarker>::borrow),
3125 encoder,
3126 offset + cur_offset,
3127 depth,
3128 )?;
3129
3130 _prev_end_offset = cur_offset + envelope_size;
3131 if 2 > max_ordinal {
3132 return Ok(());
3133 }
3134
3135 let cur_offset: usize = (2 - 1) * envelope_size;
3138
3139 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3141
3142 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3147 self.received.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3148 encoder,
3149 offset + cur_offset,
3150 depth,
3151 )?;
3152
3153 _prev_end_offset = cur_offset + envelope_size;
3154
3155 Ok(())
3156 }
3157 }
3158
3159 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3160 for NotificationRegistrationNewEventReportRequest
3161 {
3162 #[inline(always)]
3163 fn new_empty() -> Self {
3164 Self::default()
3165 }
3166
3167 unsafe fn decode(
3168 &mut self,
3169 decoder: &mut fidl::encoding::Decoder<'_, D>,
3170 offset: usize,
3171 mut depth: fidl::encoding::Depth,
3172 ) -> fidl::Result<()> {
3173 decoder.debug_check_bounds::<Self>(offset);
3174 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3175 None => return Err(fidl::Error::NotNullable),
3176 Some(len) => len,
3177 };
3178 if len == 0 {
3180 return Ok(());
3181 };
3182 depth.increment()?;
3183 let envelope_size = 8;
3184 let bytes_len = len * envelope_size;
3185 let offset = decoder.out_of_line_offset(bytes_len)?;
3186 let mut _next_ordinal_to_read = 0;
3188 let mut next_offset = offset;
3189 let end_offset = offset + bytes_len;
3190 _next_ordinal_to_read += 1;
3191 if next_offset >= end_offset {
3192 return Ok(());
3193 }
3194
3195 while _next_ordinal_to_read < 1 {
3197 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3198 _next_ordinal_to_read += 1;
3199 next_offset += envelope_size;
3200 }
3201
3202 let next_out_of_line = decoder.next_out_of_line();
3203 let handles_before = decoder.remaining_handles();
3204 if let Some((inlined, num_bytes, num_handles)) =
3205 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3206 {
3207 let member_inline_size =
3208 <Notification as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3209 if inlined != (member_inline_size <= 4) {
3210 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3211 }
3212 let inner_offset;
3213 let mut inner_depth = depth.clone();
3214 if inlined {
3215 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3216 inner_offset = next_offset;
3217 } else {
3218 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3219 inner_depth.increment()?;
3220 }
3221 let val_ref =
3222 self.notification.get_or_insert_with(|| fidl::new_empty!(Notification, D));
3223 fidl::decode!(Notification, D, val_ref, decoder, inner_offset, inner_depth)?;
3224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3225 {
3226 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3227 }
3228 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3229 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3230 }
3231 }
3232
3233 next_offset += envelope_size;
3234 _next_ordinal_to_read += 1;
3235 if next_offset >= end_offset {
3236 return Ok(());
3237 }
3238
3239 while _next_ordinal_to_read < 2 {
3241 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3242 _next_ordinal_to_read += 1;
3243 next_offset += envelope_size;
3244 }
3245
3246 let next_out_of_line = decoder.next_out_of_line();
3247 let handles_before = decoder.remaining_handles();
3248 if let Some((inlined, num_bytes, num_handles)) =
3249 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3250 {
3251 let member_inline_size =
3252 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3253 if inlined != (member_inline_size <= 4) {
3254 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3255 }
3256 let inner_offset;
3257 let mut inner_depth = depth.clone();
3258 if inlined {
3259 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3260 inner_offset = next_offset;
3261 } else {
3262 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3263 inner_depth.increment()?;
3264 }
3265 let val_ref = self.received.get_or_insert_with(|| fidl::new_empty!(i64, D));
3266 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3267 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3268 {
3269 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3270 }
3271 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3272 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3273 }
3274 }
3275
3276 next_offset += envelope_size;
3277
3278 while next_offset < end_offset {
3280 _next_ordinal_to_read += 1;
3281 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3282 next_offset += envelope_size;
3283 }
3284
3285 Ok(())
3286 }
3287 }
3288}