1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type AlertName = String;
13
14pub const MAX_ALERT_NAME_LENGTH: u32 = 14;
16
17pub const MAX_NUM_PROVIDERS: u32 = 100;
19
20#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
23pub enum SessionState {
24 Ready,
27 Initialized,
29 Starting,
31 Started,
33 Stopping,
35 Stopped,
37 Terminating,
41 #[doc(hidden)]
42 __SourceBreaking { unknown_ordinal: u32 },
43}
44
45#[macro_export]
47macro_rules! SessionStateUnknown {
48 () => {
49 _
50 };
51}
52
53impl SessionState {
54 #[inline]
55 pub fn from_primitive(prim: u32) -> Option<Self> {
56 match prim {
57 1 => Some(Self::Ready),
58 2 => Some(Self::Initialized),
59 3 => Some(Self::Starting),
60 4 => Some(Self::Started),
61 5 => Some(Self::Stopping),
62 6 => Some(Self::Stopped),
63 7 => Some(Self::Terminating),
64 _ => None,
65 }
66 }
67
68 #[inline]
69 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
70 match prim {
71 1 => Self::Ready,
72 2 => Self::Initialized,
73 3 => Self::Starting,
74 4 => Self::Started,
75 5 => Self::Stopping,
76 6 => Self::Stopped,
77 7 => Self::Terminating,
78 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
79 }
80 }
81
82 #[inline]
83 pub fn unknown() -> Self {
84 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
85 }
86
87 #[inline]
88 pub const fn into_primitive(self) -> u32 {
89 match self {
90 Self::Ready => 1,
91 Self::Initialized => 2,
92 Self::Starting => 3,
93 Self::Started => 4,
94 Self::Stopping => 5,
95 Self::Stopped => 6,
96 Self::Terminating => 7,
97 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
98 }
99 }
100
101 #[inline]
102 pub fn is_unknown(&self) -> bool {
103 match self {
104 Self::__SourceBreaking { unknown_ordinal: _ } => true,
105 _ => false,
106 }
107 }
108}
109
110#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112pub enum StartError {
113 NotInitialized,
115 AlreadyStarted,
117 Stopping,
119 Terminating,
121 #[doc(hidden)]
122 __SourceBreaking { unknown_ordinal: u32 },
123}
124
125#[macro_export]
127macro_rules! StartErrorUnknown {
128 () => {
129 _
130 };
131}
132
133impl StartError {
134 #[inline]
135 pub fn from_primitive(prim: u32) -> Option<Self> {
136 match prim {
137 1 => Some(Self::NotInitialized),
138 2 => Some(Self::AlreadyStarted),
139 3 => Some(Self::Stopping),
140 4 => Some(Self::Terminating),
141 _ => None,
142 }
143 }
144
145 #[inline]
146 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
147 match prim {
148 1 => Self::NotInitialized,
149 2 => Self::AlreadyStarted,
150 3 => Self::Stopping,
151 4 => Self::Terminating,
152 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
153 }
154 }
155
156 #[inline]
157 pub fn unknown() -> Self {
158 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
159 }
160
161 #[inline]
162 pub const fn into_primitive(self) -> u32 {
163 match self {
164 Self::NotInitialized => 1,
165 Self::AlreadyStarted => 2,
166 Self::Stopping => 3,
167 Self::Terminating => 4,
168 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
169 }
170 }
171
172 #[inline]
173 pub fn is_unknown(&self) -> bool {
174 match self {
175 Self::__SourceBreaking { unknown_ordinal: _ } => true,
176 _ => false,
177 }
178 }
179}
180
181#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
183pub enum StopError {
184 NotInitialized,
186 NotStarted,
188 Aborted,
190 #[doc(hidden)]
191 __SourceBreaking { unknown_ordinal: u32 },
192}
193
194#[macro_export]
196macro_rules! StopErrorUnknown {
197 () => {
198 _
199 };
200}
201
202impl StopError {
203 #[inline]
204 pub fn from_primitive(prim: u32) -> Option<Self> {
205 match prim {
206 1 => Some(Self::NotInitialized),
207 2 => Some(Self::NotStarted),
208 3 => Some(Self::Aborted),
209 _ => None,
210 }
211 }
212
213 #[inline]
214 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
215 match prim {
216 1 => Self::NotInitialized,
217 2 => Self::NotStarted,
218 3 => Self::Aborted,
219 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
220 }
221 }
222
223 #[inline]
224 pub fn unknown() -> Self {
225 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
226 }
227
228 #[inline]
229 pub const fn into_primitive(self) -> u32 {
230 match self {
231 Self::NotInitialized => 1,
232 Self::NotStarted => 2,
233 Self::Aborted => 3,
234 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
235 }
236 }
237
238 #[inline]
239 pub fn is_unknown(&self) -> bool {
240 match self {
241 Self::__SourceBreaking { unknown_ordinal: _ } => true,
242 _ => false,
243 }
244 }
245}
246
247#[derive(Clone, Debug, PartialEq)]
248pub struct ProvisionerGetKnownCategoriesResponse {
249 pub categories: Vec<fidl_fuchsia_tracing__common::KnownCategory>,
250}
251
252impl fidl::Persistable for ProvisionerGetKnownCategoriesResponse {}
253
254#[derive(Clone, Debug, PartialEq)]
255pub struct ProvisionerGetProvidersResponse {
256 pub providers: Vec<ProviderInfo>,
257}
258
259impl fidl::Persistable for ProvisionerGetProvidersResponse {}
260
261#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
262pub struct SessionOnSessionStateChangeRequest {
263 pub state: SessionState,
264}
265
266impl fidl::Persistable for SessionOnSessionStateChangeRequest {}
267
268#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
269pub struct SessionWatchAlertResponse {
270 pub alert_name: String,
271}
272
273impl fidl::Persistable for SessionWatchAlertResponse {}
274
275#[derive(Clone, Debug, Default, PartialEq)]
282pub struct FxtVersion {
283 pub major: Option<u32>,
285 pub minor: Option<u32>,
287 #[doc(hidden)]
288 pub __source_breaking: fidl::marker::SourceBreaking,
289}
290
291impl fidl::Persistable for FxtVersion {}
292
293#[derive(Clone, Debug, Default, PartialEq)]
295pub struct ProviderInfo {
296 pub id: Option<u32>,
298 pub pid: Option<u64>,
300 pub name: Option<String>,
302 #[doc(hidden)]
303 pub __source_breaking: fidl::marker::SourceBreaking,
304}
305
306impl fidl::Persistable for ProviderInfo {}
307
308#[derive(Clone, Debug, Default, PartialEq)]
309pub struct ProviderSpec {
310 pub name: Option<String>,
311 pub buffer_size_megabytes_hint: Option<u32>,
312 pub categories: Option<Vec<String>>,
313 #[doc(hidden)]
314 pub __source_breaking: fidl::marker::SourceBreaking,
315}
316
317impl fidl::Persistable for ProviderSpec {}
318
319#[derive(Clone, Debug, Default, PartialEq)]
321pub struct ProviderStats {
322 pub name: Option<String>,
323 pub pid: Option<u64>,
324 pub buffering_mode: Option<fidl_fuchsia_tracing__common::BufferingMode>,
325 pub buffer_wrapped_count: Option<u32>,
326 pub records_dropped: Option<u64>,
327 pub percentage_durable_buffer_used: Option<f32>,
328 pub non_durable_bytes_written: Option<u64>,
329 #[doc(hidden)]
330 pub __source_breaking: fidl::marker::SourceBreaking,
331}
332
333impl fidl::Persistable for ProviderStats {}
334
335#[derive(Clone, Debug, Default, PartialEq)]
337pub struct StartOptions {
338 pub buffer_disposition: Option<fidl_fuchsia_tracing__common::BufferDisposition>,
346 pub additional_categories: Option<Vec<String>>,
350 #[doc(hidden)]
351 pub __source_breaking: fidl::marker::SourceBreaking,
352}
353
354impl fidl::Persistable for StartOptions {}
355
356#[derive(Clone, Debug, Default, PartialEq)]
358pub struct StopOptions {
359 pub write_results: Option<bool>,
364 #[doc(hidden)]
365 pub __source_breaking: fidl::marker::SourceBreaking,
366}
367
368impl fidl::Persistable for StopOptions {}
369
370#[derive(Clone, Debug, Default, PartialEq)]
372pub struct StopResult {
373 pub provider_stats: Option<Vec<ProviderStats>>,
374 #[doc(hidden)]
375 pub __source_breaking: fidl::marker::SourceBreaking,
376}
377
378impl fidl::Persistable for StopResult {}
379
380#[derive(Clone, Debug, Default, PartialEq)]
382pub struct TraceConfig {
383 pub categories: Option<Vec<String>>,
385 pub buffer_size_megabytes_hint: Option<u32>,
387 pub start_timeout_milliseconds: Option<u64>,
389 pub buffering_mode: Option<fidl_fuchsia_tracing__common::BufferingMode>,
390 pub provider_specs: Option<Vec<ProviderSpec>>,
392 pub version: Option<FxtVersion>,
395 pub defer_transfer: Option<bool>,
409 #[doc(hidden)]
410 pub __source_breaking: fidl::marker::SourceBreaking,
411}
412
413impl fidl::Persistable for TraceConfig {}
414
415mod internal {
416 use super::*;
417 unsafe impl fidl::encoding::TypeMarker for SessionState {
418 type Owned = Self;
419
420 #[inline(always)]
421 fn inline_align(_context: fidl::encoding::Context) -> usize {
422 std::mem::align_of::<u32>()
423 }
424
425 #[inline(always)]
426 fn inline_size(_context: fidl::encoding::Context) -> usize {
427 std::mem::size_of::<u32>()
428 }
429
430 #[inline(always)]
431 fn encode_is_copy() -> bool {
432 false
433 }
434
435 #[inline(always)]
436 fn decode_is_copy() -> bool {
437 false
438 }
439 }
440
441 impl fidl::encoding::ValueTypeMarker for SessionState {
442 type Borrowed<'a> = Self;
443 #[inline(always)]
444 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
445 *value
446 }
447 }
448
449 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SessionState {
450 #[inline]
451 unsafe fn encode(
452 self,
453 encoder: &mut fidl::encoding::Encoder<'_, D>,
454 offset: usize,
455 _depth: fidl::encoding::Depth,
456 ) -> fidl::Result<()> {
457 encoder.debug_check_bounds::<Self>(offset);
458 encoder.write_num(self.into_primitive(), offset);
459 Ok(())
460 }
461 }
462
463 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SessionState {
464 #[inline(always)]
465 fn new_empty() -> Self {
466 Self::unknown()
467 }
468
469 #[inline]
470 unsafe fn decode(
471 &mut self,
472 decoder: &mut fidl::encoding::Decoder<'_, D>,
473 offset: usize,
474 _depth: fidl::encoding::Depth,
475 ) -> fidl::Result<()> {
476 decoder.debug_check_bounds::<Self>(offset);
477 let prim = decoder.read_num::<u32>(offset);
478
479 *self = Self::from_primitive_allow_unknown(prim);
480 Ok(())
481 }
482 }
483 unsafe impl fidl::encoding::TypeMarker for StartError {
484 type Owned = Self;
485
486 #[inline(always)]
487 fn inline_align(_context: fidl::encoding::Context) -> usize {
488 std::mem::align_of::<u32>()
489 }
490
491 #[inline(always)]
492 fn inline_size(_context: fidl::encoding::Context) -> usize {
493 std::mem::size_of::<u32>()
494 }
495
496 #[inline(always)]
497 fn encode_is_copy() -> bool {
498 false
499 }
500
501 #[inline(always)]
502 fn decode_is_copy() -> bool {
503 false
504 }
505 }
506
507 impl fidl::encoding::ValueTypeMarker for StartError {
508 type Borrowed<'a> = Self;
509 #[inline(always)]
510 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
511 *value
512 }
513 }
514
515 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartError {
516 #[inline]
517 unsafe fn encode(
518 self,
519 encoder: &mut fidl::encoding::Encoder<'_, D>,
520 offset: usize,
521 _depth: fidl::encoding::Depth,
522 ) -> fidl::Result<()> {
523 encoder.debug_check_bounds::<Self>(offset);
524 encoder.write_num(self.into_primitive(), offset);
525 Ok(())
526 }
527 }
528
529 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartError {
530 #[inline(always)]
531 fn new_empty() -> Self {
532 Self::unknown()
533 }
534
535 #[inline]
536 unsafe fn decode(
537 &mut self,
538 decoder: &mut fidl::encoding::Decoder<'_, D>,
539 offset: usize,
540 _depth: fidl::encoding::Depth,
541 ) -> fidl::Result<()> {
542 decoder.debug_check_bounds::<Self>(offset);
543 let prim = decoder.read_num::<u32>(offset);
544
545 *self = Self::from_primitive_allow_unknown(prim);
546 Ok(())
547 }
548 }
549 unsafe impl fidl::encoding::TypeMarker for StopError {
550 type Owned = Self;
551
552 #[inline(always)]
553 fn inline_align(_context: fidl::encoding::Context) -> usize {
554 std::mem::align_of::<u32>()
555 }
556
557 #[inline(always)]
558 fn inline_size(_context: fidl::encoding::Context) -> usize {
559 std::mem::size_of::<u32>()
560 }
561
562 #[inline(always)]
563 fn encode_is_copy() -> bool {
564 false
565 }
566
567 #[inline(always)]
568 fn decode_is_copy() -> bool {
569 false
570 }
571 }
572
573 impl fidl::encoding::ValueTypeMarker for StopError {
574 type Borrowed<'a> = Self;
575 #[inline(always)]
576 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
577 *value
578 }
579 }
580
581 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopError {
582 #[inline]
583 unsafe fn encode(
584 self,
585 encoder: &mut fidl::encoding::Encoder<'_, D>,
586 offset: usize,
587 _depth: fidl::encoding::Depth,
588 ) -> fidl::Result<()> {
589 encoder.debug_check_bounds::<Self>(offset);
590 encoder.write_num(self.into_primitive(), offset);
591 Ok(())
592 }
593 }
594
595 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopError {
596 #[inline(always)]
597 fn new_empty() -> Self {
598 Self::unknown()
599 }
600
601 #[inline]
602 unsafe fn decode(
603 &mut self,
604 decoder: &mut fidl::encoding::Decoder<'_, D>,
605 offset: usize,
606 _depth: fidl::encoding::Depth,
607 ) -> fidl::Result<()> {
608 decoder.debug_check_bounds::<Self>(offset);
609 let prim = decoder.read_num::<u32>(offset);
610
611 *self = Self::from_primitive_allow_unknown(prim);
612 Ok(())
613 }
614 }
615
616 impl fidl::encoding::ValueTypeMarker for ProvisionerGetKnownCategoriesResponse {
617 type Borrowed<'a> = &'a Self;
618 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
619 value
620 }
621 }
622
623 unsafe impl fidl::encoding::TypeMarker for ProvisionerGetKnownCategoriesResponse {
624 type Owned = Self;
625
626 #[inline(always)]
627 fn inline_align(_context: fidl::encoding::Context) -> usize {
628 8
629 }
630
631 #[inline(always)]
632 fn inline_size(_context: fidl::encoding::Context) -> usize {
633 16
634 }
635 }
636
637 unsafe impl<D: fidl::encoding::ResourceDialect>
638 fidl::encoding::Encode<ProvisionerGetKnownCategoriesResponse, D>
639 for &ProvisionerGetKnownCategoriesResponse
640 {
641 #[inline]
642 unsafe fn encode(
643 self,
644 encoder: &mut fidl::encoding::Encoder<'_, D>,
645 offset: usize,
646 _depth: fidl::encoding::Depth,
647 ) -> fidl::Result<()> {
648 encoder.debug_check_bounds::<ProvisionerGetKnownCategoriesResponse>(offset);
649 fidl::encoding::Encode::<ProvisionerGetKnownCategoriesResponse, D>::encode(
651 (
652 <fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000> as fidl::encoding::ValueTypeMarker>::borrow(&self.categories),
653 ),
654 encoder, offset, _depth
655 )
656 }
657 }
658 unsafe impl<
659 D: fidl::encoding::ResourceDialect,
660 T0: fidl::encoding::Encode<
661 fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000>,
662 D,
663 >,
664 > fidl::encoding::Encode<ProvisionerGetKnownCategoriesResponse, D> for (T0,)
665 {
666 #[inline]
667 unsafe fn encode(
668 self,
669 encoder: &mut fidl::encoding::Encoder<'_, D>,
670 offset: usize,
671 depth: fidl::encoding::Depth,
672 ) -> fidl::Result<()> {
673 encoder.debug_check_bounds::<ProvisionerGetKnownCategoriesResponse>(offset);
674 self.0.encode(encoder, offset + 0, depth)?;
678 Ok(())
679 }
680 }
681
682 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
683 for ProvisionerGetKnownCategoriesResponse
684 {
685 #[inline(always)]
686 fn new_empty() -> Self {
687 Self {
688 categories: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000>, D),
689 }
690 }
691
692 #[inline]
693 unsafe fn decode(
694 &mut self,
695 decoder: &mut fidl::encoding::Decoder<'_, D>,
696 offset: usize,
697 _depth: fidl::encoding::Depth,
698 ) -> fidl::Result<()> {
699 decoder.debug_check_bounds::<Self>(offset);
700 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000>, D, &mut self.categories, decoder, offset + 0, _depth)?;
702 Ok(())
703 }
704 }
705
706 impl fidl::encoding::ValueTypeMarker for ProvisionerGetProvidersResponse {
707 type Borrowed<'a> = &'a Self;
708 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
709 value
710 }
711 }
712
713 unsafe impl fidl::encoding::TypeMarker for ProvisionerGetProvidersResponse {
714 type Owned = Self;
715
716 #[inline(always)]
717 fn inline_align(_context: fidl::encoding::Context) -> usize {
718 8
719 }
720
721 #[inline(always)]
722 fn inline_size(_context: fidl::encoding::Context) -> usize {
723 16
724 }
725 }
726
727 unsafe impl<D: fidl::encoding::ResourceDialect>
728 fidl::encoding::Encode<ProvisionerGetProvidersResponse, D>
729 for &ProvisionerGetProvidersResponse
730 {
731 #[inline]
732 unsafe fn encode(
733 self,
734 encoder: &mut fidl::encoding::Encoder<'_, D>,
735 offset: usize,
736 _depth: fidl::encoding::Depth,
737 ) -> fidl::Result<()> {
738 encoder.debug_check_bounds::<ProvisionerGetProvidersResponse>(offset);
739 fidl::encoding::Encode::<ProvisionerGetProvidersResponse, D>::encode(
741 (
742 <fidl::encoding::Vector<ProviderInfo, 100> as fidl::encoding::ValueTypeMarker>::borrow(&self.providers),
743 ),
744 encoder, offset, _depth
745 )
746 }
747 }
748 unsafe impl<
749 D: fidl::encoding::ResourceDialect,
750 T0: fidl::encoding::Encode<fidl::encoding::Vector<ProviderInfo, 100>, D>,
751 > fidl::encoding::Encode<ProvisionerGetProvidersResponse, D> for (T0,)
752 {
753 #[inline]
754 unsafe fn encode(
755 self,
756 encoder: &mut fidl::encoding::Encoder<'_, D>,
757 offset: usize,
758 depth: fidl::encoding::Depth,
759 ) -> fidl::Result<()> {
760 encoder.debug_check_bounds::<ProvisionerGetProvidersResponse>(offset);
761 self.0.encode(encoder, offset + 0, depth)?;
765 Ok(())
766 }
767 }
768
769 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
770 for ProvisionerGetProvidersResponse
771 {
772 #[inline(always)]
773 fn new_empty() -> Self {
774 Self { providers: fidl::new_empty!(fidl::encoding::Vector<ProviderInfo, 100>, D) }
775 }
776
777 #[inline]
778 unsafe fn decode(
779 &mut self,
780 decoder: &mut fidl::encoding::Decoder<'_, D>,
781 offset: usize,
782 _depth: fidl::encoding::Depth,
783 ) -> fidl::Result<()> {
784 decoder.debug_check_bounds::<Self>(offset);
785 fidl::decode!(fidl::encoding::Vector<ProviderInfo, 100>, D, &mut self.providers, decoder, offset + 0, _depth)?;
787 Ok(())
788 }
789 }
790
791 impl fidl::encoding::ValueTypeMarker for SessionOnSessionStateChangeRequest {
792 type Borrowed<'a> = &'a Self;
793 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
794 value
795 }
796 }
797
798 unsafe impl fidl::encoding::TypeMarker for SessionOnSessionStateChangeRequest {
799 type Owned = Self;
800
801 #[inline(always)]
802 fn inline_align(_context: fidl::encoding::Context) -> usize {
803 4
804 }
805
806 #[inline(always)]
807 fn inline_size(_context: fidl::encoding::Context) -> usize {
808 4
809 }
810 }
811
812 unsafe impl<D: fidl::encoding::ResourceDialect>
813 fidl::encoding::Encode<SessionOnSessionStateChangeRequest, D>
814 for &SessionOnSessionStateChangeRequest
815 {
816 #[inline]
817 unsafe fn encode(
818 self,
819 encoder: &mut fidl::encoding::Encoder<'_, D>,
820 offset: usize,
821 _depth: fidl::encoding::Depth,
822 ) -> fidl::Result<()> {
823 encoder.debug_check_bounds::<SessionOnSessionStateChangeRequest>(offset);
824 fidl::encoding::Encode::<SessionOnSessionStateChangeRequest, D>::encode(
826 (<SessionState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
827 encoder,
828 offset,
829 _depth,
830 )
831 }
832 }
833 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SessionState, D>>
834 fidl::encoding::Encode<SessionOnSessionStateChangeRequest, D> for (T0,)
835 {
836 #[inline]
837 unsafe fn encode(
838 self,
839 encoder: &mut fidl::encoding::Encoder<'_, D>,
840 offset: usize,
841 depth: fidl::encoding::Depth,
842 ) -> fidl::Result<()> {
843 encoder.debug_check_bounds::<SessionOnSessionStateChangeRequest>(offset);
844 self.0.encode(encoder, offset + 0, depth)?;
848 Ok(())
849 }
850 }
851
852 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
853 for SessionOnSessionStateChangeRequest
854 {
855 #[inline(always)]
856 fn new_empty() -> Self {
857 Self { state: fidl::new_empty!(SessionState, D) }
858 }
859
860 #[inline]
861 unsafe fn decode(
862 &mut self,
863 decoder: &mut fidl::encoding::Decoder<'_, D>,
864 offset: usize,
865 _depth: fidl::encoding::Depth,
866 ) -> fidl::Result<()> {
867 decoder.debug_check_bounds::<Self>(offset);
868 fidl::decode!(SessionState, D, &mut self.state, decoder, offset + 0, _depth)?;
870 Ok(())
871 }
872 }
873
874 impl fidl::encoding::ValueTypeMarker for SessionWatchAlertResponse {
875 type Borrowed<'a> = &'a Self;
876 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
877 value
878 }
879 }
880
881 unsafe impl fidl::encoding::TypeMarker for SessionWatchAlertResponse {
882 type Owned = Self;
883
884 #[inline(always)]
885 fn inline_align(_context: fidl::encoding::Context) -> usize {
886 8
887 }
888
889 #[inline(always)]
890 fn inline_size(_context: fidl::encoding::Context) -> usize {
891 16
892 }
893 }
894
895 unsafe impl<D: fidl::encoding::ResourceDialect>
896 fidl::encoding::Encode<SessionWatchAlertResponse, D> for &SessionWatchAlertResponse
897 {
898 #[inline]
899 unsafe fn encode(
900 self,
901 encoder: &mut fidl::encoding::Encoder<'_, D>,
902 offset: usize,
903 _depth: fidl::encoding::Depth,
904 ) -> fidl::Result<()> {
905 encoder.debug_check_bounds::<SessionWatchAlertResponse>(offset);
906 fidl::encoding::Encode::<SessionWatchAlertResponse, D>::encode(
908 (<fidl::encoding::BoundedString<14> as fidl::encoding::ValueTypeMarker>::borrow(
909 &self.alert_name,
910 ),),
911 encoder,
912 offset,
913 _depth,
914 )
915 }
916 }
917 unsafe impl<
918 D: fidl::encoding::ResourceDialect,
919 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<14>, D>,
920 > fidl::encoding::Encode<SessionWatchAlertResponse, D> for (T0,)
921 {
922 #[inline]
923 unsafe fn encode(
924 self,
925 encoder: &mut fidl::encoding::Encoder<'_, D>,
926 offset: usize,
927 depth: fidl::encoding::Depth,
928 ) -> fidl::Result<()> {
929 encoder.debug_check_bounds::<SessionWatchAlertResponse>(offset);
930 self.0.encode(encoder, offset + 0, depth)?;
934 Ok(())
935 }
936 }
937
938 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
939 for SessionWatchAlertResponse
940 {
941 #[inline(always)]
942 fn new_empty() -> Self {
943 Self { alert_name: fidl::new_empty!(fidl::encoding::BoundedString<14>, D) }
944 }
945
946 #[inline]
947 unsafe fn decode(
948 &mut self,
949 decoder: &mut fidl::encoding::Decoder<'_, D>,
950 offset: usize,
951 _depth: fidl::encoding::Depth,
952 ) -> fidl::Result<()> {
953 decoder.debug_check_bounds::<Self>(offset);
954 fidl::decode!(
956 fidl::encoding::BoundedString<14>,
957 D,
958 &mut self.alert_name,
959 decoder,
960 offset + 0,
961 _depth
962 )?;
963 Ok(())
964 }
965 }
966
967 impl FxtVersion {
968 #[inline(always)]
969 fn max_ordinal_present(&self) -> u64 {
970 if let Some(_) = self.minor {
971 return 2;
972 }
973 if let Some(_) = self.major {
974 return 1;
975 }
976 0
977 }
978 }
979
980 impl fidl::encoding::ValueTypeMarker for FxtVersion {
981 type Borrowed<'a> = &'a Self;
982 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
983 value
984 }
985 }
986
987 unsafe impl fidl::encoding::TypeMarker for FxtVersion {
988 type Owned = Self;
989
990 #[inline(always)]
991 fn inline_align(_context: fidl::encoding::Context) -> usize {
992 8
993 }
994
995 #[inline(always)]
996 fn inline_size(_context: fidl::encoding::Context) -> usize {
997 16
998 }
999 }
1000
1001 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FxtVersion, D>
1002 for &FxtVersion
1003 {
1004 unsafe fn encode(
1005 self,
1006 encoder: &mut fidl::encoding::Encoder<'_, D>,
1007 offset: usize,
1008 mut depth: fidl::encoding::Depth,
1009 ) -> fidl::Result<()> {
1010 encoder.debug_check_bounds::<FxtVersion>(offset);
1011 let max_ordinal: u64 = self.max_ordinal_present();
1013 encoder.write_num(max_ordinal, offset);
1014 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1015 if max_ordinal == 0 {
1017 return Ok(());
1018 }
1019 depth.increment()?;
1020 let envelope_size = 8;
1021 let bytes_len = max_ordinal as usize * envelope_size;
1022 #[allow(unused_variables)]
1023 let offset = encoder.out_of_line_offset(bytes_len);
1024 let mut _prev_end_offset: usize = 0;
1025 if 1 > max_ordinal {
1026 return Ok(());
1027 }
1028
1029 let cur_offset: usize = (1 - 1) * envelope_size;
1032
1033 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1035
1036 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1041 self.major.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1042 encoder,
1043 offset + cur_offset,
1044 depth,
1045 )?;
1046
1047 _prev_end_offset = cur_offset + envelope_size;
1048 if 2 > max_ordinal {
1049 return Ok(());
1050 }
1051
1052 let cur_offset: usize = (2 - 1) * envelope_size;
1055
1056 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1058
1059 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1064 self.minor.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1065 encoder,
1066 offset + cur_offset,
1067 depth,
1068 )?;
1069
1070 _prev_end_offset = cur_offset + envelope_size;
1071
1072 Ok(())
1073 }
1074 }
1075
1076 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FxtVersion {
1077 #[inline(always)]
1078 fn new_empty() -> Self {
1079 Self::default()
1080 }
1081
1082 unsafe fn decode(
1083 &mut self,
1084 decoder: &mut fidl::encoding::Decoder<'_, D>,
1085 offset: usize,
1086 mut depth: fidl::encoding::Depth,
1087 ) -> fidl::Result<()> {
1088 decoder.debug_check_bounds::<Self>(offset);
1089 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1090 None => return Err(fidl::Error::NotNullable),
1091 Some(len) => len,
1092 };
1093 if len == 0 {
1095 return Ok(());
1096 };
1097 depth.increment()?;
1098 let envelope_size = 8;
1099 let bytes_len = len * envelope_size;
1100 let offset = decoder.out_of_line_offset(bytes_len)?;
1101 let mut _next_ordinal_to_read = 0;
1103 let mut next_offset = offset;
1104 let end_offset = offset + bytes_len;
1105 _next_ordinal_to_read += 1;
1106 if next_offset >= end_offset {
1107 return Ok(());
1108 }
1109
1110 while _next_ordinal_to_read < 1 {
1112 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1113 _next_ordinal_to_read += 1;
1114 next_offset += envelope_size;
1115 }
1116
1117 let next_out_of_line = decoder.next_out_of_line();
1118 let handles_before = decoder.remaining_handles();
1119 if let Some((inlined, num_bytes, num_handles)) =
1120 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1121 {
1122 let member_inline_size =
1123 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1124 if inlined != (member_inline_size <= 4) {
1125 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1126 }
1127 let inner_offset;
1128 let mut inner_depth = depth.clone();
1129 if inlined {
1130 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1131 inner_offset = next_offset;
1132 } else {
1133 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1134 inner_depth.increment()?;
1135 }
1136 let val_ref = self.major.get_or_insert_with(|| fidl::new_empty!(u32, D));
1137 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1138 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1139 {
1140 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1141 }
1142 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1143 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1144 }
1145 }
1146
1147 next_offset += envelope_size;
1148 _next_ordinal_to_read += 1;
1149 if next_offset >= end_offset {
1150 return Ok(());
1151 }
1152
1153 while _next_ordinal_to_read < 2 {
1155 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1156 _next_ordinal_to_read += 1;
1157 next_offset += envelope_size;
1158 }
1159
1160 let next_out_of_line = decoder.next_out_of_line();
1161 let handles_before = decoder.remaining_handles();
1162 if let Some((inlined, num_bytes, num_handles)) =
1163 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1164 {
1165 let member_inline_size =
1166 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1167 if inlined != (member_inline_size <= 4) {
1168 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1169 }
1170 let inner_offset;
1171 let mut inner_depth = depth.clone();
1172 if inlined {
1173 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1174 inner_offset = next_offset;
1175 } else {
1176 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1177 inner_depth.increment()?;
1178 }
1179 let val_ref = self.minor.get_or_insert_with(|| fidl::new_empty!(u32, D));
1180 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1181 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1182 {
1183 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1184 }
1185 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1186 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1187 }
1188 }
1189
1190 next_offset += envelope_size;
1191
1192 while next_offset < end_offset {
1194 _next_ordinal_to_read += 1;
1195 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1196 next_offset += envelope_size;
1197 }
1198
1199 Ok(())
1200 }
1201 }
1202
1203 impl ProviderInfo {
1204 #[inline(always)]
1205 fn max_ordinal_present(&self) -> u64 {
1206 if let Some(_) = self.name {
1207 return 3;
1208 }
1209 if let Some(_) = self.pid {
1210 return 2;
1211 }
1212 if let Some(_) = self.id {
1213 return 1;
1214 }
1215 0
1216 }
1217 }
1218
1219 impl fidl::encoding::ValueTypeMarker for ProviderInfo {
1220 type Borrowed<'a> = &'a Self;
1221 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1222 value
1223 }
1224 }
1225
1226 unsafe impl fidl::encoding::TypeMarker for ProviderInfo {
1227 type Owned = Self;
1228
1229 #[inline(always)]
1230 fn inline_align(_context: fidl::encoding::Context) -> usize {
1231 8
1232 }
1233
1234 #[inline(always)]
1235 fn inline_size(_context: fidl::encoding::Context) -> usize {
1236 16
1237 }
1238 }
1239
1240 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderInfo, D>
1241 for &ProviderInfo
1242 {
1243 unsafe fn encode(
1244 self,
1245 encoder: &mut fidl::encoding::Encoder<'_, D>,
1246 offset: usize,
1247 mut depth: fidl::encoding::Depth,
1248 ) -> fidl::Result<()> {
1249 encoder.debug_check_bounds::<ProviderInfo>(offset);
1250 let max_ordinal: u64 = self.max_ordinal_present();
1252 encoder.write_num(max_ordinal, offset);
1253 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1254 if max_ordinal == 0 {
1256 return Ok(());
1257 }
1258 depth.increment()?;
1259 let envelope_size = 8;
1260 let bytes_len = max_ordinal as usize * envelope_size;
1261 #[allow(unused_variables)]
1262 let offset = encoder.out_of_line_offset(bytes_len);
1263 let mut _prev_end_offset: usize = 0;
1264 if 1 > max_ordinal {
1265 return Ok(());
1266 }
1267
1268 let cur_offset: usize = (1 - 1) * envelope_size;
1271
1272 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1274
1275 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1280 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1281 encoder,
1282 offset + cur_offset,
1283 depth,
1284 )?;
1285
1286 _prev_end_offset = cur_offset + envelope_size;
1287 if 2 > max_ordinal {
1288 return Ok(());
1289 }
1290
1291 let cur_offset: usize = (2 - 1) * envelope_size;
1294
1295 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1297
1298 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1303 self.pid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1304 encoder,
1305 offset + cur_offset,
1306 depth,
1307 )?;
1308
1309 _prev_end_offset = cur_offset + envelope_size;
1310 if 3 > max_ordinal {
1311 return Ok(());
1312 }
1313
1314 let cur_offset: usize = (3 - 1) * envelope_size;
1317
1318 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1320
1321 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1326 self.name.as_ref().map(
1327 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1328 ),
1329 encoder,
1330 offset + cur_offset,
1331 depth,
1332 )?;
1333
1334 _prev_end_offset = cur_offset + envelope_size;
1335
1336 Ok(())
1337 }
1338 }
1339
1340 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderInfo {
1341 #[inline(always)]
1342 fn new_empty() -> Self {
1343 Self::default()
1344 }
1345
1346 unsafe fn decode(
1347 &mut self,
1348 decoder: &mut fidl::encoding::Decoder<'_, D>,
1349 offset: usize,
1350 mut depth: fidl::encoding::Depth,
1351 ) -> fidl::Result<()> {
1352 decoder.debug_check_bounds::<Self>(offset);
1353 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1354 None => return Err(fidl::Error::NotNullable),
1355 Some(len) => len,
1356 };
1357 if len == 0 {
1359 return Ok(());
1360 };
1361 depth.increment()?;
1362 let envelope_size = 8;
1363 let bytes_len = len * envelope_size;
1364 let offset = decoder.out_of_line_offset(bytes_len)?;
1365 let mut _next_ordinal_to_read = 0;
1367 let mut next_offset = offset;
1368 let end_offset = offset + bytes_len;
1369 _next_ordinal_to_read += 1;
1370 if next_offset >= end_offset {
1371 return Ok(());
1372 }
1373
1374 while _next_ordinal_to_read < 1 {
1376 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1377 _next_ordinal_to_read += 1;
1378 next_offset += envelope_size;
1379 }
1380
1381 let next_out_of_line = decoder.next_out_of_line();
1382 let handles_before = decoder.remaining_handles();
1383 if let Some((inlined, num_bytes, num_handles)) =
1384 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1385 {
1386 let member_inline_size =
1387 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1388 if inlined != (member_inline_size <= 4) {
1389 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1390 }
1391 let inner_offset;
1392 let mut inner_depth = depth.clone();
1393 if inlined {
1394 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1395 inner_offset = next_offset;
1396 } else {
1397 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1398 inner_depth.increment()?;
1399 }
1400 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1401 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1402 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1403 {
1404 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1405 }
1406 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1407 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1408 }
1409 }
1410
1411 next_offset += envelope_size;
1412 _next_ordinal_to_read += 1;
1413 if next_offset >= end_offset {
1414 return Ok(());
1415 }
1416
1417 while _next_ordinal_to_read < 2 {
1419 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1420 _next_ordinal_to_read += 1;
1421 next_offset += envelope_size;
1422 }
1423
1424 let next_out_of_line = decoder.next_out_of_line();
1425 let handles_before = decoder.remaining_handles();
1426 if let Some((inlined, num_bytes, num_handles)) =
1427 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1428 {
1429 let member_inline_size =
1430 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1431 if inlined != (member_inline_size <= 4) {
1432 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1433 }
1434 let inner_offset;
1435 let mut inner_depth = depth.clone();
1436 if inlined {
1437 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1438 inner_offset = next_offset;
1439 } else {
1440 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1441 inner_depth.increment()?;
1442 }
1443 let val_ref = self.pid.get_or_insert_with(|| fidl::new_empty!(u64, D));
1444 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1445 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1446 {
1447 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1448 }
1449 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1450 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1451 }
1452 }
1453
1454 next_offset += envelope_size;
1455 _next_ordinal_to_read += 1;
1456 if next_offset >= end_offset {
1457 return Ok(());
1458 }
1459
1460 while _next_ordinal_to_read < 3 {
1462 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1463 _next_ordinal_to_read += 1;
1464 next_offset += envelope_size;
1465 }
1466
1467 let next_out_of_line = decoder.next_out_of_line();
1468 let handles_before = decoder.remaining_handles();
1469 if let Some((inlined, num_bytes, num_handles)) =
1470 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1471 {
1472 let member_inline_size =
1473 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1474 decoder.context,
1475 );
1476 if inlined != (member_inline_size <= 4) {
1477 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1478 }
1479 let inner_offset;
1480 let mut inner_depth = depth.clone();
1481 if inlined {
1482 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1483 inner_offset = next_offset;
1484 } else {
1485 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1486 inner_depth.increment()?;
1487 }
1488 let val_ref = self
1489 .name
1490 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1491 fidl::decode!(
1492 fidl::encoding::BoundedString<100>,
1493 D,
1494 val_ref,
1495 decoder,
1496 inner_offset,
1497 inner_depth
1498 )?;
1499 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1500 {
1501 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1502 }
1503 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1504 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1505 }
1506 }
1507
1508 next_offset += envelope_size;
1509
1510 while next_offset < end_offset {
1512 _next_ordinal_to_read += 1;
1513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1514 next_offset += envelope_size;
1515 }
1516
1517 Ok(())
1518 }
1519 }
1520
1521 impl ProviderSpec {
1522 #[inline(always)]
1523 fn max_ordinal_present(&self) -> u64 {
1524 if let Some(_) = self.categories {
1525 return 3;
1526 }
1527 if let Some(_) = self.buffer_size_megabytes_hint {
1528 return 2;
1529 }
1530 if let Some(_) = self.name {
1531 return 1;
1532 }
1533 0
1534 }
1535 }
1536
1537 impl fidl::encoding::ValueTypeMarker for ProviderSpec {
1538 type Borrowed<'a> = &'a Self;
1539 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1540 value
1541 }
1542 }
1543
1544 unsafe impl fidl::encoding::TypeMarker for ProviderSpec {
1545 type Owned = Self;
1546
1547 #[inline(always)]
1548 fn inline_align(_context: fidl::encoding::Context) -> usize {
1549 8
1550 }
1551
1552 #[inline(always)]
1553 fn inline_size(_context: fidl::encoding::Context) -> usize {
1554 16
1555 }
1556 }
1557
1558 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderSpec, D>
1559 for &ProviderSpec
1560 {
1561 unsafe fn encode(
1562 self,
1563 encoder: &mut fidl::encoding::Encoder<'_, D>,
1564 offset: usize,
1565 mut depth: fidl::encoding::Depth,
1566 ) -> fidl::Result<()> {
1567 encoder.debug_check_bounds::<ProviderSpec>(offset);
1568 let max_ordinal: u64 = self.max_ordinal_present();
1570 encoder.write_num(max_ordinal, offset);
1571 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1572 if max_ordinal == 0 {
1574 return Ok(());
1575 }
1576 depth.increment()?;
1577 let envelope_size = 8;
1578 let bytes_len = max_ordinal as usize * envelope_size;
1579 #[allow(unused_variables)]
1580 let offset = encoder.out_of_line_offset(bytes_len);
1581 let mut _prev_end_offset: usize = 0;
1582 if 1 > max_ordinal {
1583 return Ok(());
1584 }
1585
1586 let cur_offset: usize = (1 - 1) * envelope_size;
1589
1590 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1592
1593 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1598 self.name.as_ref().map(
1599 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1600 ),
1601 encoder,
1602 offset + cur_offset,
1603 depth,
1604 )?;
1605
1606 _prev_end_offset = cur_offset + envelope_size;
1607 if 2 > max_ordinal {
1608 return Ok(());
1609 }
1610
1611 let cur_offset: usize = (2 - 1) * envelope_size;
1614
1615 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1617
1618 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1623 self.buffer_size_megabytes_hint
1624 .as_ref()
1625 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1626 encoder,
1627 offset + cur_offset,
1628 depth,
1629 )?;
1630
1631 _prev_end_offset = cur_offset + envelope_size;
1632 if 3 > max_ordinal {
1633 return Ok(());
1634 }
1635
1636 let cur_offset: usize = (3 - 1) * envelope_size;
1639
1640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1642
1643 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>, D>(
1648 self.categories.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000> as fidl::encoding::ValueTypeMarker>::borrow),
1649 encoder, offset + cur_offset, depth
1650 )?;
1651
1652 _prev_end_offset = cur_offset + envelope_size;
1653
1654 Ok(())
1655 }
1656 }
1657
1658 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderSpec {
1659 #[inline(always)]
1660 fn new_empty() -> Self {
1661 Self::default()
1662 }
1663
1664 unsafe fn decode(
1665 &mut self,
1666 decoder: &mut fidl::encoding::Decoder<'_, D>,
1667 offset: usize,
1668 mut depth: fidl::encoding::Depth,
1669 ) -> fidl::Result<()> {
1670 decoder.debug_check_bounds::<Self>(offset);
1671 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1672 None => return Err(fidl::Error::NotNullable),
1673 Some(len) => len,
1674 };
1675 if len == 0 {
1677 return Ok(());
1678 };
1679 depth.increment()?;
1680 let envelope_size = 8;
1681 let bytes_len = len * envelope_size;
1682 let offset = decoder.out_of_line_offset(bytes_len)?;
1683 let mut _next_ordinal_to_read = 0;
1685 let mut next_offset = offset;
1686 let end_offset = offset + bytes_len;
1687 _next_ordinal_to_read += 1;
1688 if next_offset >= end_offset {
1689 return Ok(());
1690 }
1691
1692 while _next_ordinal_to_read < 1 {
1694 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1695 _next_ordinal_to_read += 1;
1696 next_offset += envelope_size;
1697 }
1698
1699 let next_out_of_line = decoder.next_out_of_line();
1700 let handles_before = decoder.remaining_handles();
1701 if let Some((inlined, num_bytes, num_handles)) =
1702 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1703 {
1704 let member_inline_size =
1705 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1706 decoder.context,
1707 );
1708 if inlined != (member_inline_size <= 4) {
1709 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1710 }
1711 let inner_offset;
1712 let mut inner_depth = depth.clone();
1713 if inlined {
1714 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1715 inner_offset = next_offset;
1716 } else {
1717 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1718 inner_depth.increment()?;
1719 }
1720 let val_ref = self
1721 .name
1722 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1723 fidl::decode!(
1724 fidl::encoding::BoundedString<100>,
1725 D,
1726 val_ref,
1727 decoder,
1728 inner_offset,
1729 inner_depth
1730 )?;
1731 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1732 {
1733 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1734 }
1735 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1736 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1737 }
1738 }
1739
1740 next_offset += envelope_size;
1741 _next_ordinal_to_read += 1;
1742 if next_offset >= end_offset {
1743 return Ok(());
1744 }
1745
1746 while _next_ordinal_to_read < 2 {
1748 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1749 _next_ordinal_to_read += 1;
1750 next_offset += envelope_size;
1751 }
1752
1753 let next_out_of_line = decoder.next_out_of_line();
1754 let handles_before = decoder.remaining_handles();
1755 if let Some((inlined, num_bytes, num_handles)) =
1756 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1757 {
1758 let member_inline_size =
1759 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1760 if inlined != (member_inline_size <= 4) {
1761 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1762 }
1763 let inner_offset;
1764 let mut inner_depth = depth.clone();
1765 if inlined {
1766 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1767 inner_offset = next_offset;
1768 } else {
1769 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1770 inner_depth.increment()?;
1771 }
1772 let val_ref =
1773 self.buffer_size_megabytes_hint.get_or_insert_with(|| fidl::new_empty!(u32, D));
1774 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
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 = <fidl::encoding::Vector<
1803 fidl::encoding::BoundedString<100>,
1804 5000,
1805 > as fidl::encoding::TypeMarker>::inline_size(
1806 decoder.context
1807 );
1808 if inlined != (member_inline_size <= 4) {
1809 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1810 }
1811 let inner_offset;
1812 let mut inner_depth = depth.clone();
1813 if inlined {
1814 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1815 inner_offset = next_offset;
1816 } else {
1817 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1818 inner_depth.increment()?;
1819 }
1820 let val_ref = self.categories.get_or_insert_with(|| {
1821 fidl::new_empty!(
1822 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
1823 D
1824 )
1825 });
1826 fidl::decode!(
1827 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
1828 D,
1829 val_ref,
1830 decoder,
1831 inner_offset,
1832 inner_depth
1833 )?;
1834 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1835 {
1836 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1837 }
1838 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1839 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1840 }
1841 }
1842
1843 next_offset += envelope_size;
1844
1845 while next_offset < end_offset {
1847 _next_ordinal_to_read += 1;
1848 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1849 next_offset += envelope_size;
1850 }
1851
1852 Ok(())
1853 }
1854 }
1855
1856 impl ProviderStats {
1857 #[inline(always)]
1858 fn max_ordinal_present(&self) -> u64 {
1859 if let Some(_) = self.non_durable_bytes_written {
1860 return 7;
1861 }
1862 if let Some(_) = self.percentage_durable_buffer_used {
1863 return 6;
1864 }
1865 if let Some(_) = self.records_dropped {
1866 return 5;
1867 }
1868 if let Some(_) = self.buffer_wrapped_count {
1869 return 4;
1870 }
1871 if let Some(_) = self.buffering_mode {
1872 return 3;
1873 }
1874 if let Some(_) = self.pid {
1875 return 2;
1876 }
1877 if let Some(_) = self.name {
1878 return 1;
1879 }
1880 0
1881 }
1882 }
1883
1884 impl fidl::encoding::ValueTypeMarker for ProviderStats {
1885 type Borrowed<'a> = &'a Self;
1886 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1887 value
1888 }
1889 }
1890
1891 unsafe impl fidl::encoding::TypeMarker for ProviderStats {
1892 type Owned = Self;
1893
1894 #[inline(always)]
1895 fn inline_align(_context: fidl::encoding::Context) -> usize {
1896 8
1897 }
1898
1899 #[inline(always)]
1900 fn inline_size(_context: fidl::encoding::Context) -> usize {
1901 16
1902 }
1903 }
1904
1905 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderStats, D>
1906 for &ProviderStats
1907 {
1908 unsafe fn encode(
1909 self,
1910 encoder: &mut fidl::encoding::Encoder<'_, D>,
1911 offset: usize,
1912 mut depth: fidl::encoding::Depth,
1913 ) -> fidl::Result<()> {
1914 encoder.debug_check_bounds::<ProviderStats>(offset);
1915 let max_ordinal: u64 = self.max_ordinal_present();
1917 encoder.write_num(max_ordinal, offset);
1918 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1919 if max_ordinal == 0 {
1921 return Ok(());
1922 }
1923 depth.increment()?;
1924 let envelope_size = 8;
1925 let bytes_len = max_ordinal as usize * envelope_size;
1926 #[allow(unused_variables)]
1927 let offset = encoder.out_of_line_offset(bytes_len);
1928 let mut _prev_end_offset: usize = 0;
1929 if 1 > max_ordinal {
1930 return Ok(());
1931 }
1932
1933 let cur_offset: usize = (1 - 1) * envelope_size;
1936
1937 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1939
1940 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1945 self.name.as_ref().map(
1946 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1947 ),
1948 encoder,
1949 offset + cur_offset,
1950 depth,
1951 )?;
1952
1953 _prev_end_offset = cur_offset + envelope_size;
1954 if 2 > max_ordinal {
1955 return Ok(());
1956 }
1957
1958 let cur_offset: usize = (2 - 1) * envelope_size;
1961
1962 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1964
1965 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1970 self.pid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1971 encoder,
1972 offset + cur_offset,
1973 depth,
1974 )?;
1975
1976 _prev_end_offset = cur_offset + envelope_size;
1977 if 3 > max_ordinal {
1978 return Ok(());
1979 }
1980
1981 let cur_offset: usize = (3 - 1) * envelope_size;
1984
1985 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1987
1988 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_tracing__common::BufferingMode, D>(
1993 self.buffering_mode.as_ref().map(<fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::ValueTypeMarker>::borrow),
1994 encoder, offset + cur_offset, depth
1995 )?;
1996
1997 _prev_end_offset = cur_offset + envelope_size;
1998 if 4 > max_ordinal {
1999 return Ok(());
2000 }
2001
2002 let cur_offset: usize = (4 - 1) * envelope_size;
2005
2006 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2008
2009 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2014 self.buffer_wrapped_count
2015 .as_ref()
2016 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2017 encoder,
2018 offset + cur_offset,
2019 depth,
2020 )?;
2021
2022 _prev_end_offset = cur_offset + envelope_size;
2023 if 5 > max_ordinal {
2024 return Ok(());
2025 }
2026
2027 let cur_offset: usize = (5 - 1) * envelope_size;
2030
2031 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2033
2034 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2039 self.records_dropped.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2040 encoder,
2041 offset + cur_offset,
2042 depth,
2043 )?;
2044
2045 _prev_end_offset = cur_offset + envelope_size;
2046 if 6 > max_ordinal {
2047 return Ok(());
2048 }
2049
2050 let cur_offset: usize = (6 - 1) * envelope_size;
2053
2054 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2056
2057 fidl::encoding::encode_in_envelope_optional::<f32, D>(
2062 self.percentage_durable_buffer_used
2063 .as_ref()
2064 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
2065 encoder,
2066 offset + cur_offset,
2067 depth,
2068 )?;
2069
2070 _prev_end_offset = cur_offset + envelope_size;
2071 if 7 > max_ordinal {
2072 return Ok(());
2073 }
2074
2075 let cur_offset: usize = (7 - 1) * envelope_size;
2078
2079 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2081
2082 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2087 self.non_durable_bytes_written
2088 .as_ref()
2089 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2090 encoder,
2091 offset + cur_offset,
2092 depth,
2093 )?;
2094
2095 _prev_end_offset = cur_offset + envelope_size;
2096
2097 Ok(())
2098 }
2099 }
2100
2101 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderStats {
2102 #[inline(always)]
2103 fn new_empty() -> Self {
2104 Self::default()
2105 }
2106
2107 unsafe fn decode(
2108 &mut self,
2109 decoder: &mut fidl::encoding::Decoder<'_, D>,
2110 offset: usize,
2111 mut depth: fidl::encoding::Depth,
2112 ) -> fidl::Result<()> {
2113 decoder.debug_check_bounds::<Self>(offset);
2114 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2115 None => return Err(fidl::Error::NotNullable),
2116 Some(len) => len,
2117 };
2118 if len == 0 {
2120 return Ok(());
2121 };
2122 depth.increment()?;
2123 let envelope_size = 8;
2124 let bytes_len = len * envelope_size;
2125 let offset = decoder.out_of_line_offset(bytes_len)?;
2126 let mut _next_ordinal_to_read = 0;
2128 let mut next_offset = offset;
2129 let end_offset = offset + bytes_len;
2130 _next_ordinal_to_read += 1;
2131 if next_offset >= end_offset {
2132 return Ok(());
2133 }
2134
2135 while _next_ordinal_to_read < 1 {
2137 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2138 _next_ordinal_to_read += 1;
2139 next_offset += envelope_size;
2140 }
2141
2142 let next_out_of_line = decoder.next_out_of_line();
2143 let handles_before = decoder.remaining_handles();
2144 if let Some((inlined, num_bytes, num_handles)) =
2145 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2146 {
2147 let member_inline_size =
2148 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
2149 decoder.context,
2150 );
2151 if inlined != (member_inline_size <= 4) {
2152 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2153 }
2154 let inner_offset;
2155 let mut inner_depth = depth.clone();
2156 if inlined {
2157 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2158 inner_offset = next_offset;
2159 } else {
2160 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2161 inner_depth.increment()?;
2162 }
2163 let val_ref = self
2164 .name
2165 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
2166 fidl::decode!(
2167 fidl::encoding::BoundedString<100>,
2168 D,
2169 val_ref,
2170 decoder,
2171 inner_offset,
2172 inner_depth
2173 )?;
2174 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2175 {
2176 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2177 }
2178 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2179 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2180 }
2181 }
2182
2183 next_offset += envelope_size;
2184 _next_ordinal_to_read += 1;
2185 if next_offset >= end_offset {
2186 return Ok(());
2187 }
2188
2189 while _next_ordinal_to_read < 2 {
2191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2192 _next_ordinal_to_read += 1;
2193 next_offset += envelope_size;
2194 }
2195
2196 let next_out_of_line = decoder.next_out_of_line();
2197 let handles_before = decoder.remaining_handles();
2198 if let Some((inlined, num_bytes, num_handles)) =
2199 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2200 {
2201 let member_inline_size =
2202 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2203 if inlined != (member_inline_size <= 4) {
2204 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2205 }
2206 let inner_offset;
2207 let mut inner_depth = depth.clone();
2208 if inlined {
2209 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2210 inner_offset = next_offset;
2211 } else {
2212 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2213 inner_depth.increment()?;
2214 }
2215 let val_ref = self.pid.get_or_insert_with(|| fidl::new_empty!(u64, D));
2216 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2217 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2218 {
2219 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2220 }
2221 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2222 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2223 }
2224 }
2225
2226 next_offset += envelope_size;
2227 _next_ordinal_to_read += 1;
2228 if next_offset >= end_offset {
2229 return Ok(());
2230 }
2231
2232 while _next_ordinal_to_read < 3 {
2234 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2235 _next_ordinal_to_read += 1;
2236 next_offset += envelope_size;
2237 }
2238
2239 let next_out_of_line = decoder.next_out_of_line();
2240 let handles_before = decoder.remaining_handles();
2241 if let Some((inlined, num_bytes, num_handles)) =
2242 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2243 {
2244 let member_inline_size = <fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2245 if inlined != (member_inline_size <= 4) {
2246 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2247 }
2248 let inner_offset;
2249 let mut inner_depth = depth.clone();
2250 if inlined {
2251 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2252 inner_offset = next_offset;
2253 } else {
2254 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2255 inner_depth.increment()?;
2256 }
2257 let val_ref = self.buffering_mode.get_or_insert_with(|| {
2258 fidl::new_empty!(fidl_fuchsia_tracing__common::BufferingMode, D)
2259 });
2260 fidl::decode!(
2261 fidl_fuchsia_tracing__common::BufferingMode,
2262 D,
2263 val_ref,
2264 decoder,
2265 inner_offset,
2266 inner_depth
2267 )?;
2268 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2269 {
2270 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2271 }
2272 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2273 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2274 }
2275 }
2276
2277 next_offset += envelope_size;
2278 _next_ordinal_to_read += 1;
2279 if next_offset >= end_offset {
2280 return Ok(());
2281 }
2282
2283 while _next_ordinal_to_read < 4 {
2285 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2286 _next_ordinal_to_read += 1;
2287 next_offset += envelope_size;
2288 }
2289
2290 let next_out_of_line = decoder.next_out_of_line();
2291 let handles_before = decoder.remaining_handles();
2292 if let Some((inlined, num_bytes, num_handles)) =
2293 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2294 {
2295 let member_inline_size =
2296 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2297 if inlined != (member_inline_size <= 4) {
2298 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2299 }
2300 let inner_offset;
2301 let mut inner_depth = depth.clone();
2302 if inlined {
2303 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2304 inner_offset = next_offset;
2305 } else {
2306 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2307 inner_depth.increment()?;
2308 }
2309 let val_ref =
2310 self.buffer_wrapped_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
2311 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2312 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2313 {
2314 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2315 }
2316 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2317 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2318 }
2319 }
2320
2321 next_offset += envelope_size;
2322 _next_ordinal_to_read += 1;
2323 if next_offset >= end_offset {
2324 return Ok(());
2325 }
2326
2327 while _next_ordinal_to_read < 5 {
2329 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2330 _next_ordinal_to_read += 1;
2331 next_offset += envelope_size;
2332 }
2333
2334 let next_out_of_line = decoder.next_out_of_line();
2335 let handles_before = decoder.remaining_handles();
2336 if let Some((inlined, num_bytes, num_handles)) =
2337 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2338 {
2339 let member_inline_size =
2340 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2341 if inlined != (member_inline_size <= 4) {
2342 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2343 }
2344 let inner_offset;
2345 let mut inner_depth = depth.clone();
2346 if inlined {
2347 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2348 inner_offset = next_offset;
2349 } else {
2350 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2351 inner_depth.increment()?;
2352 }
2353 let val_ref = self.records_dropped.get_or_insert_with(|| fidl::new_empty!(u64, D));
2354 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2355 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2356 {
2357 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2358 }
2359 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2360 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2361 }
2362 }
2363
2364 next_offset += envelope_size;
2365 _next_ordinal_to_read += 1;
2366 if next_offset >= end_offset {
2367 return Ok(());
2368 }
2369
2370 while _next_ordinal_to_read < 6 {
2372 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2373 _next_ordinal_to_read += 1;
2374 next_offset += envelope_size;
2375 }
2376
2377 let next_out_of_line = decoder.next_out_of_line();
2378 let handles_before = decoder.remaining_handles();
2379 if let Some((inlined, num_bytes, num_handles)) =
2380 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2381 {
2382 let member_inline_size =
2383 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2384 if inlined != (member_inline_size <= 4) {
2385 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2386 }
2387 let inner_offset;
2388 let mut inner_depth = depth.clone();
2389 if inlined {
2390 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2391 inner_offset = next_offset;
2392 } else {
2393 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2394 inner_depth.increment()?;
2395 }
2396 let val_ref = self
2397 .percentage_durable_buffer_used
2398 .get_or_insert_with(|| fidl::new_empty!(f32, D));
2399 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
2400 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2401 {
2402 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2403 }
2404 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2405 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2406 }
2407 }
2408
2409 next_offset += envelope_size;
2410 _next_ordinal_to_read += 1;
2411 if next_offset >= end_offset {
2412 return Ok(());
2413 }
2414
2415 while _next_ordinal_to_read < 7 {
2417 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2418 _next_ordinal_to_read += 1;
2419 next_offset += envelope_size;
2420 }
2421
2422 let next_out_of_line = decoder.next_out_of_line();
2423 let handles_before = decoder.remaining_handles();
2424 if let Some((inlined, num_bytes, num_handles)) =
2425 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2426 {
2427 let member_inline_size =
2428 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2429 if inlined != (member_inline_size <= 4) {
2430 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2431 }
2432 let inner_offset;
2433 let mut inner_depth = depth.clone();
2434 if inlined {
2435 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2436 inner_offset = next_offset;
2437 } else {
2438 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2439 inner_depth.increment()?;
2440 }
2441 let val_ref =
2442 self.non_durable_bytes_written.get_or_insert_with(|| fidl::new_empty!(u64, D));
2443 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2444 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2445 {
2446 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2447 }
2448 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2449 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2450 }
2451 }
2452
2453 next_offset += envelope_size;
2454
2455 while next_offset < end_offset {
2457 _next_ordinal_to_read += 1;
2458 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2459 next_offset += envelope_size;
2460 }
2461
2462 Ok(())
2463 }
2464 }
2465
2466 impl StartOptions {
2467 #[inline(always)]
2468 fn max_ordinal_present(&self) -> u64 {
2469 if let Some(_) = self.additional_categories {
2470 return 2;
2471 }
2472 if let Some(_) = self.buffer_disposition {
2473 return 1;
2474 }
2475 0
2476 }
2477 }
2478
2479 impl fidl::encoding::ValueTypeMarker for StartOptions {
2480 type Borrowed<'a> = &'a Self;
2481 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2482 value
2483 }
2484 }
2485
2486 unsafe impl fidl::encoding::TypeMarker for StartOptions {
2487 type Owned = Self;
2488
2489 #[inline(always)]
2490 fn inline_align(_context: fidl::encoding::Context) -> usize {
2491 8
2492 }
2493
2494 #[inline(always)]
2495 fn inline_size(_context: fidl::encoding::Context) -> usize {
2496 16
2497 }
2498 }
2499
2500 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartOptions, D>
2501 for &StartOptions
2502 {
2503 unsafe fn encode(
2504 self,
2505 encoder: &mut fidl::encoding::Encoder<'_, D>,
2506 offset: usize,
2507 mut depth: fidl::encoding::Depth,
2508 ) -> fidl::Result<()> {
2509 encoder.debug_check_bounds::<StartOptions>(offset);
2510 let max_ordinal: u64 = self.max_ordinal_present();
2512 encoder.write_num(max_ordinal, offset);
2513 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2514 if max_ordinal == 0 {
2516 return Ok(());
2517 }
2518 depth.increment()?;
2519 let envelope_size = 8;
2520 let bytes_len = max_ordinal as usize * envelope_size;
2521 #[allow(unused_variables)]
2522 let offset = encoder.out_of_line_offset(bytes_len);
2523 let mut _prev_end_offset: usize = 0;
2524 if 1 > max_ordinal {
2525 return Ok(());
2526 }
2527
2528 let cur_offset: usize = (1 - 1) * envelope_size;
2531
2532 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2534
2535 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_tracing__common::BufferDisposition, D>(
2540 self.buffer_disposition.as_ref().map(<fidl_fuchsia_tracing__common::BufferDisposition as fidl::encoding::ValueTypeMarker>::borrow),
2541 encoder, offset + cur_offset, depth
2542 )?;
2543
2544 _prev_end_offset = cur_offset + envelope_size;
2545 if 2 > max_ordinal {
2546 return Ok(());
2547 }
2548
2549 let cur_offset: usize = (2 - 1) * envelope_size;
2552
2553 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2555
2556 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>, D>(
2561 self.additional_categories.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000> as fidl::encoding::ValueTypeMarker>::borrow),
2562 encoder, offset + cur_offset, depth
2563 )?;
2564
2565 _prev_end_offset = cur_offset + envelope_size;
2566
2567 Ok(())
2568 }
2569 }
2570
2571 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartOptions {
2572 #[inline(always)]
2573 fn new_empty() -> Self {
2574 Self::default()
2575 }
2576
2577 unsafe fn decode(
2578 &mut self,
2579 decoder: &mut fidl::encoding::Decoder<'_, D>,
2580 offset: usize,
2581 mut depth: fidl::encoding::Depth,
2582 ) -> fidl::Result<()> {
2583 decoder.debug_check_bounds::<Self>(offset);
2584 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2585 None => return Err(fidl::Error::NotNullable),
2586 Some(len) => len,
2587 };
2588 if len == 0 {
2590 return Ok(());
2591 };
2592 depth.increment()?;
2593 let envelope_size = 8;
2594 let bytes_len = len * envelope_size;
2595 let offset = decoder.out_of_line_offset(bytes_len)?;
2596 let mut _next_ordinal_to_read = 0;
2598 let mut next_offset = offset;
2599 let end_offset = offset + bytes_len;
2600 _next_ordinal_to_read += 1;
2601 if next_offset >= end_offset {
2602 return Ok(());
2603 }
2604
2605 while _next_ordinal_to_read < 1 {
2607 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2608 _next_ordinal_to_read += 1;
2609 next_offset += envelope_size;
2610 }
2611
2612 let next_out_of_line = decoder.next_out_of_line();
2613 let handles_before = decoder.remaining_handles();
2614 if let Some((inlined, num_bytes, num_handles)) =
2615 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2616 {
2617 let member_inline_size = <fidl_fuchsia_tracing__common::BufferDisposition as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2618 if inlined != (member_inline_size <= 4) {
2619 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2620 }
2621 let inner_offset;
2622 let mut inner_depth = depth.clone();
2623 if inlined {
2624 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2625 inner_offset = next_offset;
2626 } else {
2627 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2628 inner_depth.increment()?;
2629 }
2630 let val_ref = self.buffer_disposition.get_or_insert_with(|| {
2631 fidl::new_empty!(fidl_fuchsia_tracing__common::BufferDisposition, D)
2632 });
2633 fidl::decode!(
2634 fidl_fuchsia_tracing__common::BufferDisposition,
2635 D,
2636 val_ref,
2637 decoder,
2638 inner_offset,
2639 inner_depth
2640 )?;
2641 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2642 {
2643 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2644 }
2645 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2646 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2647 }
2648 }
2649
2650 next_offset += envelope_size;
2651 _next_ordinal_to_read += 1;
2652 if next_offset >= end_offset {
2653 return Ok(());
2654 }
2655
2656 while _next_ordinal_to_read < 2 {
2658 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2659 _next_ordinal_to_read += 1;
2660 next_offset += envelope_size;
2661 }
2662
2663 let next_out_of_line = decoder.next_out_of_line();
2664 let handles_before = decoder.remaining_handles();
2665 if let Some((inlined, num_bytes, num_handles)) =
2666 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2667 {
2668 let member_inline_size = <fidl::encoding::Vector<
2669 fidl::encoding::BoundedString<100>,
2670 5000,
2671 > as fidl::encoding::TypeMarker>::inline_size(
2672 decoder.context
2673 );
2674 if inlined != (member_inline_size <= 4) {
2675 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2676 }
2677 let inner_offset;
2678 let mut inner_depth = depth.clone();
2679 if inlined {
2680 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2681 inner_offset = next_offset;
2682 } else {
2683 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2684 inner_depth.increment()?;
2685 }
2686 let val_ref = self.additional_categories.get_or_insert_with(|| {
2687 fidl::new_empty!(
2688 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
2689 D
2690 )
2691 });
2692 fidl::decode!(
2693 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
2694 D,
2695 val_ref,
2696 decoder,
2697 inner_offset,
2698 inner_depth
2699 )?;
2700 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2701 {
2702 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2703 }
2704 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2705 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2706 }
2707 }
2708
2709 next_offset += envelope_size;
2710
2711 while next_offset < end_offset {
2713 _next_ordinal_to_read += 1;
2714 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2715 next_offset += envelope_size;
2716 }
2717
2718 Ok(())
2719 }
2720 }
2721
2722 impl StopOptions {
2723 #[inline(always)]
2724 fn max_ordinal_present(&self) -> u64 {
2725 if let Some(_) = self.write_results {
2726 return 1;
2727 }
2728 0
2729 }
2730 }
2731
2732 impl fidl::encoding::ValueTypeMarker for StopOptions {
2733 type Borrowed<'a> = &'a Self;
2734 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2735 value
2736 }
2737 }
2738
2739 unsafe impl fidl::encoding::TypeMarker for StopOptions {
2740 type Owned = Self;
2741
2742 #[inline(always)]
2743 fn inline_align(_context: fidl::encoding::Context) -> usize {
2744 8
2745 }
2746
2747 #[inline(always)]
2748 fn inline_size(_context: fidl::encoding::Context) -> usize {
2749 16
2750 }
2751 }
2752
2753 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopOptions, D>
2754 for &StopOptions
2755 {
2756 unsafe fn encode(
2757 self,
2758 encoder: &mut fidl::encoding::Encoder<'_, D>,
2759 offset: usize,
2760 mut depth: fidl::encoding::Depth,
2761 ) -> fidl::Result<()> {
2762 encoder.debug_check_bounds::<StopOptions>(offset);
2763 let max_ordinal: u64 = self.max_ordinal_present();
2765 encoder.write_num(max_ordinal, offset);
2766 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2767 if max_ordinal == 0 {
2769 return Ok(());
2770 }
2771 depth.increment()?;
2772 let envelope_size = 8;
2773 let bytes_len = max_ordinal as usize * envelope_size;
2774 #[allow(unused_variables)]
2775 let offset = encoder.out_of_line_offset(bytes_len);
2776 let mut _prev_end_offset: usize = 0;
2777 if 1 > max_ordinal {
2778 return Ok(());
2779 }
2780
2781 let cur_offset: usize = (1 - 1) * envelope_size;
2784
2785 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2787
2788 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2793 self.write_results.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2794 encoder,
2795 offset + cur_offset,
2796 depth,
2797 )?;
2798
2799 _prev_end_offset = cur_offset + envelope_size;
2800
2801 Ok(())
2802 }
2803 }
2804
2805 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopOptions {
2806 #[inline(always)]
2807 fn new_empty() -> Self {
2808 Self::default()
2809 }
2810
2811 unsafe fn decode(
2812 &mut self,
2813 decoder: &mut fidl::encoding::Decoder<'_, D>,
2814 offset: usize,
2815 mut depth: fidl::encoding::Depth,
2816 ) -> fidl::Result<()> {
2817 decoder.debug_check_bounds::<Self>(offset);
2818 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2819 None => return Err(fidl::Error::NotNullable),
2820 Some(len) => len,
2821 };
2822 if len == 0 {
2824 return Ok(());
2825 };
2826 depth.increment()?;
2827 let envelope_size = 8;
2828 let bytes_len = len * envelope_size;
2829 let offset = decoder.out_of_line_offset(bytes_len)?;
2830 let mut _next_ordinal_to_read = 0;
2832 let mut next_offset = offset;
2833 let end_offset = offset + bytes_len;
2834 _next_ordinal_to_read += 1;
2835 if next_offset >= end_offset {
2836 return Ok(());
2837 }
2838
2839 while _next_ordinal_to_read < 1 {
2841 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2842 _next_ordinal_to_read += 1;
2843 next_offset += envelope_size;
2844 }
2845
2846 let next_out_of_line = decoder.next_out_of_line();
2847 let handles_before = decoder.remaining_handles();
2848 if let Some((inlined, num_bytes, num_handles)) =
2849 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2850 {
2851 let member_inline_size =
2852 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2853 if inlined != (member_inline_size <= 4) {
2854 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2855 }
2856 let inner_offset;
2857 let mut inner_depth = depth.clone();
2858 if inlined {
2859 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2860 inner_offset = next_offset;
2861 } else {
2862 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2863 inner_depth.increment()?;
2864 }
2865 let val_ref = self.write_results.get_or_insert_with(|| fidl::new_empty!(bool, D));
2866 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2867 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2868 {
2869 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2870 }
2871 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2872 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2873 }
2874 }
2875
2876 next_offset += envelope_size;
2877
2878 while next_offset < end_offset {
2880 _next_ordinal_to_read += 1;
2881 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2882 next_offset += envelope_size;
2883 }
2884
2885 Ok(())
2886 }
2887 }
2888
2889 impl StopResult {
2890 #[inline(always)]
2891 fn max_ordinal_present(&self) -> u64 {
2892 if let Some(_) = self.provider_stats {
2893 return 1;
2894 }
2895 0
2896 }
2897 }
2898
2899 impl fidl::encoding::ValueTypeMarker for StopResult {
2900 type Borrowed<'a> = &'a Self;
2901 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2902 value
2903 }
2904 }
2905
2906 unsafe impl fidl::encoding::TypeMarker for StopResult {
2907 type Owned = Self;
2908
2909 #[inline(always)]
2910 fn inline_align(_context: fidl::encoding::Context) -> usize {
2911 8
2912 }
2913
2914 #[inline(always)]
2915 fn inline_size(_context: fidl::encoding::Context) -> usize {
2916 16
2917 }
2918 }
2919
2920 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopResult, D>
2921 for &StopResult
2922 {
2923 unsafe fn encode(
2924 self,
2925 encoder: &mut fidl::encoding::Encoder<'_, D>,
2926 offset: usize,
2927 mut depth: fidl::encoding::Depth,
2928 ) -> fidl::Result<()> {
2929 encoder.debug_check_bounds::<StopResult>(offset);
2930 let max_ordinal: u64 = self.max_ordinal_present();
2932 encoder.write_num(max_ordinal, offset);
2933 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2934 if max_ordinal == 0 {
2936 return Ok(());
2937 }
2938 depth.increment()?;
2939 let envelope_size = 8;
2940 let bytes_len = max_ordinal as usize * envelope_size;
2941 #[allow(unused_variables)]
2942 let offset = encoder.out_of_line_offset(bytes_len);
2943 let mut _prev_end_offset: usize = 0;
2944 if 1 > max_ordinal {
2945 return Ok(());
2946 }
2947
2948 let cur_offset: usize = (1 - 1) * envelope_size;
2951
2952 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2954
2955 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProviderStats, 100>, D>(
2960 self.provider_stats.as_ref().map(<fidl::encoding::Vector<ProviderStats, 100> as fidl::encoding::ValueTypeMarker>::borrow),
2961 encoder, offset + cur_offset, depth
2962 )?;
2963
2964 _prev_end_offset = cur_offset + envelope_size;
2965
2966 Ok(())
2967 }
2968 }
2969
2970 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResult {
2971 #[inline(always)]
2972 fn new_empty() -> Self {
2973 Self::default()
2974 }
2975
2976 unsafe fn decode(
2977 &mut self,
2978 decoder: &mut fidl::encoding::Decoder<'_, D>,
2979 offset: usize,
2980 mut depth: fidl::encoding::Depth,
2981 ) -> fidl::Result<()> {
2982 decoder.debug_check_bounds::<Self>(offset);
2983 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2984 None => return Err(fidl::Error::NotNullable),
2985 Some(len) => len,
2986 };
2987 if len == 0 {
2989 return Ok(());
2990 };
2991 depth.increment()?;
2992 let envelope_size = 8;
2993 let bytes_len = len * envelope_size;
2994 let offset = decoder.out_of_line_offset(bytes_len)?;
2995 let mut _next_ordinal_to_read = 0;
2997 let mut next_offset = offset;
2998 let end_offset = offset + bytes_len;
2999 _next_ordinal_to_read += 1;
3000 if next_offset >= end_offset {
3001 return Ok(());
3002 }
3003
3004 while _next_ordinal_to_read < 1 {
3006 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3007 _next_ordinal_to_read += 1;
3008 next_offset += envelope_size;
3009 }
3010
3011 let next_out_of_line = decoder.next_out_of_line();
3012 let handles_before = decoder.remaining_handles();
3013 if let Some((inlined, num_bytes, num_handles)) =
3014 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3015 {
3016 let member_inline_size = <fidl::encoding::Vector<ProviderStats, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3017 if inlined != (member_inline_size <= 4) {
3018 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3019 }
3020 let inner_offset;
3021 let mut inner_depth = depth.clone();
3022 if inlined {
3023 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3024 inner_offset = next_offset;
3025 } else {
3026 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3027 inner_depth.increment()?;
3028 }
3029 let val_ref = self.provider_stats.get_or_insert_with(
3030 || fidl::new_empty!(fidl::encoding::Vector<ProviderStats, 100>, D),
3031 );
3032 fidl::decode!(fidl::encoding::Vector<ProviderStats, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
3033 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3034 {
3035 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3036 }
3037 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3038 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3039 }
3040 }
3041
3042 next_offset += envelope_size;
3043
3044 while next_offset < end_offset {
3046 _next_ordinal_to_read += 1;
3047 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3048 next_offset += envelope_size;
3049 }
3050
3051 Ok(())
3052 }
3053 }
3054
3055 impl TraceConfig {
3056 #[inline(always)]
3057 fn max_ordinal_present(&self) -> u64 {
3058 if let Some(_) = self.defer_transfer {
3059 return 7;
3060 }
3061 if let Some(_) = self.version {
3062 return 6;
3063 }
3064 if let Some(_) = self.provider_specs {
3065 return 5;
3066 }
3067 if let Some(_) = self.buffering_mode {
3068 return 4;
3069 }
3070 if let Some(_) = self.start_timeout_milliseconds {
3071 return 3;
3072 }
3073 if let Some(_) = self.buffer_size_megabytes_hint {
3074 return 2;
3075 }
3076 if let Some(_) = self.categories {
3077 return 1;
3078 }
3079 0
3080 }
3081 }
3082
3083 impl fidl::encoding::ValueTypeMarker for TraceConfig {
3084 type Borrowed<'a> = &'a Self;
3085 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3086 value
3087 }
3088 }
3089
3090 unsafe impl fidl::encoding::TypeMarker for TraceConfig {
3091 type Owned = Self;
3092
3093 #[inline(always)]
3094 fn inline_align(_context: fidl::encoding::Context) -> usize {
3095 8
3096 }
3097
3098 #[inline(always)]
3099 fn inline_size(_context: fidl::encoding::Context) -> usize {
3100 16
3101 }
3102 }
3103
3104 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TraceConfig, D>
3105 for &TraceConfig
3106 {
3107 unsafe fn encode(
3108 self,
3109 encoder: &mut fidl::encoding::Encoder<'_, D>,
3110 offset: usize,
3111 mut depth: fidl::encoding::Depth,
3112 ) -> fidl::Result<()> {
3113 encoder.debug_check_bounds::<TraceConfig>(offset);
3114 let max_ordinal: u64 = self.max_ordinal_present();
3116 encoder.write_num(max_ordinal, offset);
3117 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3118 if max_ordinal == 0 {
3120 return Ok(());
3121 }
3122 depth.increment()?;
3123 let envelope_size = 8;
3124 let bytes_len = max_ordinal as usize * envelope_size;
3125 #[allow(unused_variables)]
3126 let offset = encoder.out_of_line_offset(bytes_len);
3127 let mut _prev_end_offset: usize = 0;
3128 if 1 > max_ordinal {
3129 return Ok(());
3130 }
3131
3132 let cur_offset: usize = (1 - 1) * envelope_size;
3135
3136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3138
3139 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>, D>(
3144 self.categories.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000> as fidl::encoding::ValueTypeMarker>::borrow),
3145 encoder, offset + cur_offset, depth
3146 )?;
3147
3148 _prev_end_offset = cur_offset + envelope_size;
3149 if 2 > max_ordinal {
3150 return Ok(());
3151 }
3152
3153 let cur_offset: usize = (2 - 1) * envelope_size;
3156
3157 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3159
3160 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3165 self.buffer_size_megabytes_hint
3166 .as_ref()
3167 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3168 encoder,
3169 offset + cur_offset,
3170 depth,
3171 )?;
3172
3173 _prev_end_offset = cur_offset + envelope_size;
3174 if 3 > max_ordinal {
3175 return Ok(());
3176 }
3177
3178 let cur_offset: usize = (3 - 1) * envelope_size;
3181
3182 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3184
3185 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3190 self.start_timeout_milliseconds
3191 .as_ref()
3192 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3193 encoder,
3194 offset + cur_offset,
3195 depth,
3196 )?;
3197
3198 _prev_end_offset = cur_offset + envelope_size;
3199 if 4 > max_ordinal {
3200 return Ok(());
3201 }
3202
3203 let cur_offset: usize = (4 - 1) * envelope_size;
3206
3207 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3209
3210 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_tracing__common::BufferingMode, D>(
3215 self.buffering_mode.as_ref().map(<fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::ValueTypeMarker>::borrow),
3216 encoder, offset + cur_offset, depth
3217 )?;
3218
3219 _prev_end_offset = cur_offset + envelope_size;
3220 if 5 > max_ordinal {
3221 return Ok(());
3222 }
3223
3224 let cur_offset: usize = (5 - 1) * envelope_size;
3227
3228 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3230
3231 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProviderSpec, 100>, D>(
3236 self.provider_specs.as_ref().map(<fidl::encoding::Vector<ProviderSpec, 100> as fidl::encoding::ValueTypeMarker>::borrow),
3237 encoder, offset + cur_offset, depth
3238 )?;
3239
3240 _prev_end_offset = cur_offset + envelope_size;
3241 if 6 > max_ordinal {
3242 return Ok(());
3243 }
3244
3245 let cur_offset: usize = (6 - 1) * envelope_size;
3248
3249 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3251
3252 fidl::encoding::encode_in_envelope_optional::<FxtVersion, D>(
3257 self.version.as_ref().map(<FxtVersion as fidl::encoding::ValueTypeMarker>::borrow),
3258 encoder,
3259 offset + cur_offset,
3260 depth,
3261 )?;
3262
3263 _prev_end_offset = cur_offset + envelope_size;
3264 if 7 > max_ordinal {
3265 return Ok(());
3266 }
3267
3268 let cur_offset: usize = (7 - 1) * envelope_size;
3271
3272 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3274
3275 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3280 self.defer_transfer.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3281 encoder,
3282 offset + cur_offset,
3283 depth,
3284 )?;
3285
3286 _prev_end_offset = cur_offset + envelope_size;
3287
3288 Ok(())
3289 }
3290 }
3291
3292 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TraceConfig {
3293 #[inline(always)]
3294 fn new_empty() -> Self {
3295 Self::default()
3296 }
3297
3298 unsafe fn decode(
3299 &mut self,
3300 decoder: &mut fidl::encoding::Decoder<'_, D>,
3301 offset: usize,
3302 mut depth: fidl::encoding::Depth,
3303 ) -> fidl::Result<()> {
3304 decoder.debug_check_bounds::<Self>(offset);
3305 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3306 None => return Err(fidl::Error::NotNullable),
3307 Some(len) => len,
3308 };
3309 if len == 0 {
3311 return Ok(());
3312 };
3313 depth.increment()?;
3314 let envelope_size = 8;
3315 let bytes_len = len * envelope_size;
3316 let offset = decoder.out_of_line_offset(bytes_len)?;
3317 let mut _next_ordinal_to_read = 0;
3319 let mut next_offset = offset;
3320 let end_offset = offset + bytes_len;
3321 _next_ordinal_to_read += 1;
3322 if next_offset >= end_offset {
3323 return Ok(());
3324 }
3325
3326 while _next_ordinal_to_read < 1 {
3328 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3329 _next_ordinal_to_read += 1;
3330 next_offset += envelope_size;
3331 }
3332
3333 let next_out_of_line = decoder.next_out_of_line();
3334 let handles_before = decoder.remaining_handles();
3335 if let Some((inlined, num_bytes, num_handles)) =
3336 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3337 {
3338 let member_inline_size = <fidl::encoding::Vector<
3339 fidl::encoding::BoundedString<100>,
3340 5000,
3341 > as fidl::encoding::TypeMarker>::inline_size(
3342 decoder.context
3343 );
3344 if inlined != (member_inline_size <= 4) {
3345 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3346 }
3347 let inner_offset;
3348 let mut inner_depth = depth.clone();
3349 if inlined {
3350 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3351 inner_offset = next_offset;
3352 } else {
3353 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3354 inner_depth.increment()?;
3355 }
3356 let val_ref = self.categories.get_or_insert_with(|| {
3357 fidl::new_empty!(
3358 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
3359 D
3360 )
3361 });
3362 fidl::decode!(
3363 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
3364 D,
3365 val_ref,
3366 decoder,
3367 inner_offset,
3368 inner_depth
3369 )?;
3370 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3371 {
3372 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3373 }
3374 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3375 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3376 }
3377 }
3378
3379 next_offset += envelope_size;
3380 _next_ordinal_to_read += 1;
3381 if next_offset >= end_offset {
3382 return Ok(());
3383 }
3384
3385 while _next_ordinal_to_read < 2 {
3387 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3388 _next_ordinal_to_read += 1;
3389 next_offset += envelope_size;
3390 }
3391
3392 let next_out_of_line = decoder.next_out_of_line();
3393 let handles_before = decoder.remaining_handles();
3394 if let Some((inlined, num_bytes, num_handles)) =
3395 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3396 {
3397 let member_inline_size =
3398 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3399 if inlined != (member_inline_size <= 4) {
3400 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3401 }
3402 let inner_offset;
3403 let mut inner_depth = depth.clone();
3404 if inlined {
3405 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3406 inner_offset = next_offset;
3407 } else {
3408 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3409 inner_depth.increment()?;
3410 }
3411 let val_ref =
3412 self.buffer_size_megabytes_hint.get_or_insert_with(|| fidl::new_empty!(u32, D));
3413 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3414 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3415 {
3416 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3417 }
3418 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3419 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3420 }
3421 }
3422
3423 next_offset += envelope_size;
3424 _next_ordinal_to_read += 1;
3425 if next_offset >= end_offset {
3426 return Ok(());
3427 }
3428
3429 while _next_ordinal_to_read < 3 {
3431 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3432 _next_ordinal_to_read += 1;
3433 next_offset += envelope_size;
3434 }
3435
3436 let next_out_of_line = decoder.next_out_of_line();
3437 let handles_before = decoder.remaining_handles();
3438 if let Some((inlined, num_bytes, num_handles)) =
3439 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3440 {
3441 let member_inline_size =
3442 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3443 if inlined != (member_inline_size <= 4) {
3444 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3445 }
3446 let inner_offset;
3447 let mut inner_depth = depth.clone();
3448 if inlined {
3449 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3450 inner_offset = next_offset;
3451 } else {
3452 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3453 inner_depth.increment()?;
3454 }
3455 let val_ref =
3456 self.start_timeout_milliseconds.get_or_insert_with(|| fidl::new_empty!(u64, D));
3457 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3458 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3459 {
3460 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3461 }
3462 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3463 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3464 }
3465 }
3466
3467 next_offset += envelope_size;
3468 _next_ordinal_to_read += 1;
3469 if next_offset >= end_offset {
3470 return Ok(());
3471 }
3472
3473 while _next_ordinal_to_read < 4 {
3475 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3476 _next_ordinal_to_read += 1;
3477 next_offset += envelope_size;
3478 }
3479
3480 let next_out_of_line = decoder.next_out_of_line();
3481 let handles_before = decoder.remaining_handles();
3482 if let Some((inlined, num_bytes, num_handles)) =
3483 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3484 {
3485 let member_inline_size = <fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3486 if inlined != (member_inline_size <= 4) {
3487 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3488 }
3489 let inner_offset;
3490 let mut inner_depth = depth.clone();
3491 if inlined {
3492 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3493 inner_offset = next_offset;
3494 } else {
3495 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3496 inner_depth.increment()?;
3497 }
3498 let val_ref = self.buffering_mode.get_or_insert_with(|| {
3499 fidl::new_empty!(fidl_fuchsia_tracing__common::BufferingMode, D)
3500 });
3501 fidl::decode!(
3502 fidl_fuchsia_tracing__common::BufferingMode,
3503 D,
3504 val_ref,
3505 decoder,
3506 inner_offset,
3507 inner_depth
3508 )?;
3509 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3510 {
3511 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3512 }
3513 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3514 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3515 }
3516 }
3517
3518 next_offset += envelope_size;
3519 _next_ordinal_to_read += 1;
3520 if next_offset >= end_offset {
3521 return Ok(());
3522 }
3523
3524 while _next_ordinal_to_read < 5 {
3526 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3527 _next_ordinal_to_read += 1;
3528 next_offset += envelope_size;
3529 }
3530
3531 let next_out_of_line = decoder.next_out_of_line();
3532 let handles_before = decoder.remaining_handles();
3533 if let Some((inlined, num_bytes, num_handles)) =
3534 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3535 {
3536 let member_inline_size = <fidl::encoding::Vector<ProviderSpec, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3537 if inlined != (member_inline_size <= 4) {
3538 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3539 }
3540 let inner_offset;
3541 let mut inner_depth = depth.clone();
3542 if inlined {
3543 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3544 inner_offset = next_offset;
3545 } else {
3546 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3547 inner_depth.increment()?;
3548 }
3549 let val_ref = self.provider_specs.get_or_insert_with(
3550 || fidl::new_empty!(fidl::encoding::Vector<ProviderSpec, 100>, D),
3551 );
3552 fidl::decode!(fidl::encoding::Vector<ProviderSpec, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
3553 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3554 {
3555 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3556 }
3557 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3558 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3559 }
3560 }
3561
3562 next_offset += envelope_size;
3563 _next_ordinal_to_read += 1;
3564 if next_offset >= end_offset {
3565 return Ok(());
3566 }
3567
3568 while _next_ordinal_to_read < 6 {
3570 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3571 _next_ordinal_to_read += 1;
3572 next_offset += envelope_size;
3573 }
3574
3575 let next_out_of_line = decoder.next_out_of_line();
3576 let handles_before = decoder.remaining_handles();
3577 if let Some((inlined, num_bytes, num_handles)) =
3578 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3579 {
3580 let member_inline_size =
3581 <FxtVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3582 if inlined != (member_inline_size <= 4) {
3583 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3584 }
3585 let inner_offset;
3586 let mut inner_depth = depth.clone();
3587 if inlined {
3588 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3589 inner_offset = next_offset;
3590 } else {
3591 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3592 inner_depth.increment()?;
3593 }
3594 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(FxtVersion, D));
3595 fidl::decode!(FxtVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
3596 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3597 {
3598 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3599 }
3600 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3601 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3602 }
3603 }
3604
3605 next_offset += envelope_size;
3606 _next_ordinal_to_read += 1;
3607 if next_offset >= end_offset {
3608 return Ok(());
3609 }
3610
3611 while _next_ordinal_to_read < 7 {
3613 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3614 _next_ordinal_to_read += 1;
3615 next_offset += envelope_size;
3616 }
3617
3618 let next_out_of_line = decoder.next_out_of_line();
3619 let handles_before = decoder.remaining_handles();
3620 if let Some((inlined, num_bytes, num_handles)) =
3621 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3622 {
3623 let member_inline_size =
3624 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3625 if inlined != (member_inline_size <= 4) {
3626 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3627 }
3628 let inner_offset;
3629 let mut inner_depth = depth.clone();
3630 if inlined {
3631 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3632 inner_offset = next_offset;
3633 } else {
3634 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3635 inner_depth.increment()?;
3636 }
3637 let val_ref = self.defer_transfer.get_or_insert_with(|| fidl::new_empty!(bool, D));
3638 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3639 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3640 {
3641 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3642 }
3643 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3644 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3645 }
3646 }
3647
3648 next_offset += envelope_size;
3649
3650 while next_offset < end_offset {
3652 _next_ordinal_to_read += 1;
3653 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3654 next_offset += envelope_size;
3655 }
3656
3657 Ok(())
3658 }
3659 }
3660}