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
415pub mod provisioner_ordinals {
416 pub const INITIALIZE_TRACING: u64 = 0x3b046ed3a0684ab8;
417 pub const GET_PROVIDERS: u64 = 0xc4d4f36edc50d43;
418 pub const GET_KNOWN_CATEGORIES: u64 = 0x41ef99397b945a4;
419}
420
421pub mod session_ordinals {
422 pub const START_TRACING: u64 = 0xde9b6ccbe936631;
423 pub const STOP_TRACING: u64 = 0x50fefc9b3ff9b03a;
424 pub const WATCH_ALERT: u64 = 0x1f1c080716d92276;
425 pub const ON_SESSION_STATE_CHANGE: u64 = 0x7ab1640718b971cd;
426}
427
428mod internal {
429 use super::*;
430 unsafe impl fidl::encoding::TypeMarker for SessionState {
431 type Owned = Self;
432
433 #[inline(always)]
434 fn inline_align(_context: fidl::encoding::Context) -> usize {
435 std::mem::align_of::<u32>()
436 }
437
438 #[inline(always)]
439 fn inline_size(_context: fidl::encoding::Context) -> usize {
440 std::mem::size_of::<u32>()
441 }
442
443 #[inline(always)]
444 fn encode_is_copy() -> bool {
445 false
446 }
447
448 #[inline(always)]
449 fn decode_is_copy() -> bool {
450 false
451 }
452 }
453
454 impl fidl::encoding::ValueTypeMarker for SessionState {
455 type Borrowed<'a> = Self;
456 #[inline(always)]
457 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
458 *value
459 }
460 }
461
462 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SessionState {
463 #[inline]
464 unsafe fn encode(
465 self,
466 encoder: &mut fidl::encoding::Encoder<'_, D>,
467 offset: usize,
468 _depth: fidl::encoding::Depth,
469 ) -> fidl::Result<()> {
470 encoder.debug_check_bounds::<Self>(offset);
471 encoder.write_num(self.into_primitive(), offset);
472 Ok(())
473 }
474 }
475
476 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SessionState {
477 #[inline(always)]
478 fn new_empty() -> Self {
479 Self::unknown()
480 }
481
482 #[inline]
483 unsafe fn decode(
484 &mut self,
485 decoder: &mut fidl::encoding::Decoder<'_, D>,
486 offset: usize,
487 _depth: fidl::encoding::Depth,
488 ) -> fidl::Result<()> {
489 decoder.debug_check_bounds::<Self>(offset);
490 let prim = decoder.read_num::<u32>(offset);
491
492 *self = Self::from_primitive_allow_unknown(prim);
493 Ok(())
494 }
495 }
496 unsafe impl fidl::encoding::TypeMarker for StartError {
497 type Owned = Self;
498
499 #[inline(always)]
500 fn inline_align(_context: fidl::encoding::Context) -> usize {
501 std::mem::align_of::<u32>()
502 }
503
504 #[inline(always)]
505 fn inline_size(_context: fidl::encoding::Context) -> usize {
506 std::mem::size_of::<u32>()
507 }
508
509 #[inline(always)]
510 fn encode_is_copy() -> bool {
511 false
512 }
513
514 #[inline(always)]
515 fn decode_is_copy() -> bool {
516 false
517 }
518 }
519
520 impl fidl::encoding::ValueTypeMarker for StartError {
521 type Borrowed<'a> = Self;
522 #[inline(always)]
523 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
524 *value
525 }
526 }
527
528 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartError {
529 #[inline]
530 unsafe fn encode(
531 self,
532 encoder: &mut fidl::encoding::Encoder<'_, D>,
533 offset: usize,
534 _depth: fidl::encoding::Depth,
535 ) -> fidl::Result<()> {
536 encoder.debug_check_bounds::<Self>(offset);
537 encoder.write_num(self.into_primitive(), offset);
538 Ok(())
539 }
540 }
541
542 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartError {
543 #[inline(always)]
544 fn new_empty() -> Self {
545 Self::unknown()
546 }
547
548 #[inline]
549 unsafe fn decode(
550 &mut self,
551 decoder: &mut fidl::encoding::Decoder<'_, D>,
552 offset: usize,
553 _depth: fidl::encoding::Depth,
554 ) -> fidl::Result<()> {
555 decoder.debug_check_bounds::<Self>(offset);
556 let prim = decoder.read_num::<u32>(offset);
557
558 *self = Self::from_primitive_allow_unknown(prim);
559 Ok(())
560 }
561 }
562 unsafe impl fidl::encoding::TypeMarker for StopError {
563 type Owned = Self;
564
565 #[inline(always)]
566 fn inline_align(_context: fidl::encoding::Context) -> usize {
567 std::mem::align_of::<u32>()
568 }
569
570 #[inline(always)]
571 fn inline_size(_context: fidl::encoding::Context) -> usize {
572 std::mem::size_of::<u32>()
573 }
574
575 #[inline(always)]
576 fn encode_is_copy() -> bool {
577 false
578 }
579
580 #[inline(always)]
581 fn decode_is_copy() -> bool {
582 false
583 }
584 }
585
586 impl fidl::encoding::ValueTypeMarker for StopError {
587 type Borrowed<'a> = Self;
588 #[inline(always)]
589 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
590 *value
591 }
592 }
593
594 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopError {
595 #[inline]
596 unsafe fn encode(
597 self,
598 encoder: &mut fidl::encoding::Encoder<'_, D>,
599 offset: usize,
600 _depth: fidl::encoding::Depth,
601 ) -> fidl::Result<()> {
602 encoder.debug_check_bounds::<Self>(offset);
603 encoder.write_num(self.into_primitive(), offset);
604 Ok(())
605 }
606 }
607
608 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopError {
609 #[inline(always)]
610 fn new_empty() -> Self {
611 Self::unknown()
612 }
613
614 #[inline]
615 unsafe fn decode(
616 &mut self,
617 decoder: &mut fidl::encoding::Decoder<'_, D>,
618 offset: usize,
619 _depth: fidl::encoding::Depth,
620 ) -> fidl::Result<()> {
621 decoder.debug_check_bounds::<Self>(offset);
622 let prim = decoder.read_num::<u32>(offset);
623
624 *self = Self::from_primitive_allow_unknown(prim);
625 Ok(())
626 }
627 }
628
629 impl fidl::encoding::ValueTypeMarker for ProvisionerGetKnownCategoriesResponse {
630 type Borrowed<'a> = &'a Self;
631 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
632 value
633 }
634 }
635
636 unsafe impl fidl::encoding::TypeMarker for ProvisionerGetKnownCategoriesResponse {
637 type Owned = Self;
638
639 #[inline(always)]
640 fn inline_align(_context: fidl::encoding::Context) -> usize {
641 8
642 }
643
644 #[inline(always)]
645 fn inline_size(_context: fidl::encoding::Context) -> usize {
646 16
647 }
648 }
649
650 unsafe impl<D: fidl::encoding::ResourceDialect>
651 fidl::encoding::Encode<ProvisionerGetKnownCategoriesResponse, D>
652 for &ProvisionerGetKnownCategoriesResponse
653 {
654 #[inline]
655 unsafe fn encode(
656 self,
657 encoder: &mut fidl::encoding::Encoder<'_, D>,
658 offset: usize,
659 _depth: fidl::encoding::Depth,
660 ) -> fidl::Result<()> {
661 encoder.debug_check_bounds::<ProvisionerGetKnownCategoriesResponse>(offset);
662 fidl::encoding::Encode::<ProvisionerGetKnownCategoriesResponse, D>::encode(
664 (
665 <fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000> as fidl::encoding::ValueTypeMarker>::borrow(&self.categories),
666 ),
667 encoder, offset, _depth
668 )
669 }
670 }
671 unsafe impl<
672 D: fidl::encoding::ResourceDialect,
673 T0: fidl::encoding::Encode<
674 fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000>,
675 D,
676 >,
677 > fidl::encoding::Encode<ProvisionerGetKnownCategoriesResponse, D> for (T0,)
678 {
679 #[inline]
680 unsafe fn encode(
681 self,
682 encoder: &mut fidl::encoding::Encoder<'_, D>,
683 offset: usize,
684 depth: fidl::encoding::Depth,
685 ) -> fidl::Result<()> {
686 encoder.debug_check_bounds::<ProvisionerGetKnownCategoriesResponse>(offset);
687 self.0.encode(encoder, offset + 0, depth)?;
691 Ok(())
692 }
693 }
694
695 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
696 for ProvisionerGetKnownCategoriesResponse
697 {
698 #[inline(always)]
699 fn new_empty() -> Self {
700 Self {
701 categories: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000>, D),
702 }
703 }
704
705 #[inline]
706 unsafe fn decode(
707 &mut self,
708 decoder: &mut fidl::encoding::Decoder<'_, D>,
709 offset: usize,
710 _depth: fidl::encoding::Depth,
711 ) -> fidl::Result<()> {
712 decoder.debug_check_bounds::<Self>(offset);
713 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_tracing__common::KnownCategory, 5000>, D, &mut self.categories, decoder, offset + 0, _depth)?;
715 Ok(())
716 }
717 }
718
719 impl fidl::encoding::ValueTypeMarker for ProvisionerGetProvidersResponse {
720 type Borrowed<'a> = &'a Self;
721 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
722 value
723 }
724 }
725
726 unsafe impl fidl::encoding::TypeMarker for ProvisionerGetProvidersResponse {
727 type Owned = Self;
728
729 #[inline(always)]
730 fn inline_align(_context: fidl::encoding::Context) -> usize {
731 8
732 }
733
734 #[inline(always)]
735 fn inline_size(_context: fidl::encoding::Context) -> usize {
736 16
737 }
738 }
739
740 unsafe impl<D: fidl::encoding::ResourceDialect>
741 fidl::encoding::Encode<ProvisionerGetProvidersResponse, D>
742 for &ProvisionerGetProvidersResponse
743 {
744 #[inline]
745 unsafe fn encode(
746 self,
747 encoder: &mut fidl::encoding::Encoder<'_, D>,
748 offset: usize,
749 _depth: fidl::encoding::Depth,
750 ) -> fidl::Result<()> {
751 encoder.debug_check_bounds::<ProvisionerGetProvidersResponse>(offset);
752 fidl::encoding::Encode::<ProvisionerGetProvidersResponse, D>::encode(
754 (
755 <fidl::encoding::Vector<ProviderInfo, 100> as fidl::encoding::ValueTypeMarker>::borrow(&self.providers),
756 ),
757 encoder, offset, _depth
758 )
759 }
760 }
761 unsafe impl<
762 D: fidl::encoding::ResourceDialect,
763 T0: fidl::encoding::Encode<fidl::encoding::Vector<ProviderInfo, 100>, D>,
764 > fidl::encoding::Encode<ProvisionerGetProvidersResponse, D> for (T0,)
765 {
766 #[inline]
767 unsafe fn encode(
768 self,
769 encoder: &mut fidl::encoding::Encoder<'_, D>,
770 offset: usize,
771 depth: fidl::encoding::Depth,
772 ) -> fidl::Result<()> {
773 encoder.debug_check_bounds::<ProvisionerGetProvidersResponse>(offset);
774 self.0.encode(encoder, offset + 0, depth)?;
778 Ok(())
779 }
780 }
781
782 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
783 for ProvisionerGetProvidersResponse
784 {
785 #[inline(always)]
786 fn new_empty() -> Self {
787 Self { providers: fidl::new_empty!(fidl::encoding::Vector<ProviderInfo, 100>, D) }
788 }
789
790 #[inline]
791 unsafe fn decode(
792 &mut self,
793 decoder: &mut fidl::encoding::Decoder<'_, D>,
794 offset: usize,
795 _depth: fidl::encoding::Depth,
796 ) -> fidl::Result<()> {
797 decoder.debug_check_bounds::<Self>(offset);
798 fidl::decode!(fidl::encoding::Vector<ProviderInfo, 100>, D, &mut self.providers, decoder, offset + 0, _depth)?;
800 Ok(())
801 }
802 }
803
804 impl fidl::encoding::ValueTypeMarker for SessionOnSessionStateChangeRequest {
805 type Borrowed<'a> = &'a Self;
806 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
807 value
808 }
809 }
810
811 unsafe impl fidl::encoding::TypeMarker for SessionOnSessionStateChangeRequest {
812 type Owned = Self;
813
814 #[inline(always)]
815 fn inline_align(_context: fidl::encoding::Context) -> usize {
816 4
817 }
818
819 #[inline(always)]
820 fn inline_size(_context: fidl::encoding::Context) -> usize {
821 4
822 }
823 }
824
825 unsafe impl<D: fidl::encoding::ResourceDialect>
826 fidl::encoding::Encode<SessionOnSessionStateChangeRequest, D>
827 for &SessionOnSessionStateChangeRequest
828 {
829 #[inline]
830 unsafe fn encode(
831 self,
832 encoder: &mut fidl::encoding::Encoder<'_, D>,
833 offset: usize,
834 _depth: fidl::encoding::Depth,
835 ) -> fidl::Result<()> {
836 encoder.debug_check_bounds::<SessionOnSessionStateChangeRequest>(offset);
837 fidl::encoding::Encode::<SessionOnSessionStateChangeRequest, D>::encode(
839 (<SessionState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
840 encoder,
841 offset,
842 _depth,
843 )
844 }
845 }
846 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SessionState, D>>
847 fidl::encoding::Encode<SessionOnSessionStateChangeRequest, D> for (T0,)
848 {
849 #[inline]
850 unsafe fn encode(
851 self,
852 encoder: &mut fidl::encoding::Encoder<'_, D>,
853 offset: usize,
854 depth: fidl::encoding::Depth,
855 ) -> fidl::Result<()> {
856 encoder.debug_check_bounds::<SessionOnSessionStateChangeRequest>(offset);
857 self.0.encode(encoder, offset + 0, depth)?;
861 Ok(())
862 }
863 }
864
865 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
866 for SessionOnSessionStateChangeRequest
867 {
868 #[inline(always)]
869 fn new_empty() -> Self {
870 Self { state: fidl::new_empty!(SessionState, D) }
871 }
872
873 #[inline]
874 unsafe fn decode(
875 &mut self,
876 decoder: &mut fidl::encoding::Decoder<'_, D>,
877 offset: usize,
878 _depth: fidl::encoding::Depth,
879 ) -> fidl::Result<()> {
880 decoder.debug_check_bounds::<Self>(offset);
881 fidl::decode!(SessionState, D, &mut self.state, decoder, offset + 0, _depth)?;
883 Ok(())
884 }
885 }
886
887 impl fidl::encoding::ValueTypeMarker for SessionWatchAlertResponse {
888 type Borrowed<'a> = &'a Self;
889 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
890 value
891 }
892 }
893
894 unsafe impl fidl::encoding::TypeMarker for SessionWatchAlertResponse {
895 type Owned = Self;
896
897 #[inline(always)]
898 fn inline_align(_context: fidl::encoding::Context) -> usize {
899 8
900 }
901
902 #[inline(always)]
903 fn inline_size(_context: fidl::encoding::Context) -> usize {
904 16
905 }
906 }
907
908 unsafe impl<D: fidl::encoding::ResourceDialect>
909 fidl::encoding::Encode<SessionWatchAlertResponse, D> for &SessionWatchAlertResponse
910 {
911 #[inline]
912 unsafe fn encode(
913 self,
914 encoder: &mut fidl::encoding::Encoder<'_, D>,
915 offset: usize,
916 _depth: fidl::encoding::Depth,
917 ) -> fidl::Result<()> {
918 encoder.debug_check_bounds::<SessionWatchAlertResponse>(offset);
919 fidl::encoding::Encode::<SessionWatchAlertResponse, D>::encode(
921 (<fidl::encoding::BoundedString<14> as fidl::encoding::ValueTypeMarker>::borrow(
922 &self.alert_name,
923 ),),
924 encoder,
925 offset,
926 _depth,
927 )
928 }
929 }
930 unsafe impl<
931 D: fidl::encoding::ResourceDialect,
932 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<14>, D>,
933 > fidl::encoding::Encode<SessionWatchAlertResponse, D> for (T0,)
934 {
935 #[inline]
936 unsafe fn encode(
937 self,
938 encoder: &mut fidl::encoding::Encoder<'_, D>,
939 offset: usize,
940 depth: fidl::encoding::Depth,
941 ) -> fidl::Result<()> {
942 encoder.debug_check_bounds::<SessionWatchAlertResponse>(offset);
943 self.0.encode(encoder, offset + 0, depth)?;
947 Ok(())
948 }
949 }
950
951 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
952 for SessionWatchAlertResponse
953 {
954 #[inline(always)]
955 fn new_empty() -> Self {
956 Self { alert_name: fidl::new_empty!(fidl::encoding::BoundedString<14>, D) }
957 }
958
959 #[inline]
960 unsafe fn decode(
961 &mut self,
962 decoder: &mut fidl::encoding::Decoder<'_, D>,
963 offset: usize,
964 _depth: fidl::encoding::Depth,
965 ) -> fidl::Result<()> {
966 decoder.debug_check_bounds::<Self>(offset);
967 fidl::decode!(
969 fidl::encoding::BoundedString<14>,
970 D,
971 &mut self.alert_name,
972 decoder,
973 offset + 0,
974 _depth
975 )?;
976 Ok(())
977 }
978 }
979
980 impl FxtVersion {
981 #[inline(always)]
982 fn max_ordinal_present(&self) -> u64 {
983 if let Some(_) = self.minor {
984 return 2;
985 }
986 if let Some(_) = self.major {
987 return 1;
988 }
989 0
990 }
991 }
992
993 impl fidl::encoding::ValueTypeMarker for FxtVersion {
994 type Borrowed<'a> = &'a Self;
995 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
996 value
997 }
998 }
999
1000 unsafe impl fidl::encoding::TypeMarker for FxtVersion {
1001 type Owned = Self;
1002
1003 #[inline(always)]
1004 fn inline_align(_context: fidl::encoding::Context) -> usize {
1005 8
1006 }
1007
1008 #[inline(always)]
1009 fn inline_size(_context: fidl::encoding::Context) -> usize {
1010 16
1011 }
1012 }
1013
1014 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FxtVersion, D>
1015 for &FxtVersion
1016 {
1017 unsafe fn encode(
1018 self,
1019 encoder: &mut fidl::encoding::Encoder<'_, D>,
1020 offset: usize,
1021 mut depth: fidl::encoding::Depth,
1022 ) -> fidl::Result<()> {
1023 encoder.debug_check_bounds::<FxtVersion>(offset);
1024 let max_ordinal: u64 = self.max_ordinal_present();
1026 encoder.write_num(max_ordinal, offset);
1027 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1028 if max_ordinal == 0 {
1030 return Ok(());
1031 }
1032 depth.increment()?;
1033 let envelope_size = 8;
1034 let bytes_len = max_ordinal as usize * envelope_size;
1035 #[allow(unused_variables)]
1036 let offset = encoder.out_of_line_offset(bytes_len);
1037 let mut _prev_end_offset: usize = 0;
1038 if 1 > max_ordinal {
1039 return Ok(());
1040 }
1041
1042 let cur_offset: usize = (1 - 1) * envelope_size;
1045
1046 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1048
1049 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1054 self.major.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1055 encoder,
1056 offset + cur_offset,
1057 depth,
1058 )?;
1059
1060 _prev_end_offset = cur_offset + envelope_size;
1061 if 2 > max_ordinal {
1062 return Ok(());
1063 }
1064
1065 let cur_offset: usize = (2 - 1) * envelope_size;
1068
1069 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1071
1072 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1077 self.minor.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1078 encoder,
1079 offset + cur_offset,
1080 depth,
1081 )?;
1082
1083 _prev_end_offset = cur_offset + envelope_size;
1084
1085 Ok(())
1086 }
1087 }
1088
1089 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FxtVersion {
1090 #[inline(always)]
1091 fn new_empty() -> Self {
1092 Self::default()
1093 }
1094
1095 unsafe fn decode(
1096 &mut self,
1097 decoder: &mut fidl::encoding::Decoder<'_, D>,
1098 offset: usize,
1099 mut depth: fidl::encoding::Depth,
1100 ) -> fidl::Result<()> {
1101 decoder.debug_check_bounds::<Self>(offset);
1102 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1103 None => return Err(fidl::Error::NotNullable),
1104 Some(len) => len,
1105 };
1106 if len == 0 {
1108 return Ok(());
1109 };
1110 depth.increment()?;
1111 let envelope_size = 8;
1112 let bytes_len = len * envelope_size;
1113 let offset = decoder.out_of_line_offset(bytes_len)?;
1114 let mut _next_ordinal_to_read = 0;
1116 let mut next_offset = offset;
1117 let end_offset = offset + bytes_len;
1118 _next_ordinal_to_read += 1;
1119 if next_offset >= end_offset {
1120 return Ok(());
1121 }
1122
1123 while _next_ordinal_to_read < 1 {
1125 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1126 _next_ordinal_to_read += 1;
1127 next_offset += envelope_size;
1128 }
1129
1130 let next_out_of_line = decoder.next_out_of_line();
1131 let handles_before = decoder.remaining_handles();
1132 if let Some((inlined, num_bytes, num_handles)) =
1133 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1134 {
1135 let member_inline_size =
1136 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1137 if inlined != (member_inline_size <= 4) {
1138 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1139 }
1140 let inner_offset;
1141 let mut inner_depth = depth.clone();
1142 if inlined {
1143 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1144 inner_offset = next_offset;
1145 } else {
1146 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1147 inner_depth.increment()?;
1148 }
1149 let val_ref = self.major.get_or_insert_with(|| fidl::new_empty!(u32, D));
1150 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1151 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1152 {
1153 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1154 }
1155 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1156 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1157 }
1158 }
1159
1160 next_offset += envelope_size;
1161 _next_ordinal_to_read += 1;
1162 if next_offset >= end_offset {
1163 return Ok(());
1164 }
1165
1166 while _next_ordinal_to_read < 2 {
1168 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1169 _next_ordinal_to_read += 1;
1170 next_offset += envelope_size;
1171 }
1172
1173 let next_out_of_line = decoder.next_out_of_line();
1174 let handles_before = decoder.remaining_handles();
1175 if let Some((inlined, num_bytes, num_handles)) =
1176 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1177 {
1178 let member_inline_size =
1179 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1180 if inlined != (member_inline_size <= 4) {
1181 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1182 }
1183 let inner_offset;
1184 let mut inner_depth = depth.clone();
1185 if inlined {
1186 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1187 inner_offset = next_offset;
1188 } else {
1189 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1190 inner_depth.increment()?;
1191 }
1192 let val_ref = self.minor.get_or_insert_with(|| fidl::new_empty!(u32, D));
1193 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1194 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1195 {
1196 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1197 }
1198 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1199 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1200 }
1201 }
1202
1203 next_offset += envelope_size;
1204
1205 while next_offset < end_offset {
1207 _next_ordinal_to_read += 1;
1208 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1209 next_offset += envelope_size;
1210 }
1211
1212 Ok(())
1213 }
1214 }
1215
1216 impl ProviderInfo {
1217 #[inline(always)]
1218 fn max_ordinal_present(&self) -> u64 {
1219 if let Some(_) = self.name {
1220 return 3;
1221 }
1222 if let Some(_) = self.pid {
1223 return 2;
1224 }
1225 if let Some(_) = self.id {
1226 return 1;
1227 }
1228 0
1229 }
1230 }
1231
1232 impl fidl::encoding::ValueTypeMarker for ProviderInfo {
1233 type Borrowed<'a> = &'a Self;
1234 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1235 value
1236 }
1237 }
1238
1239 unsafe impl fidl::encoding::TypeMarker for ProviderInfo {
1240 type Owned = Self;
1241
1242 #[inline(always)]
1243 fn inline_align(_context: fidl::encoding::Context) -> usize {
1244 8
1245 }
1246
1247 #[inline(always)]
1248 fn inline_size(_context: fidl::encoding::Context) -> usize {
1249 16
1250 }
1251 }
1252
1253 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderInfo, D>
1254 for &ProviderInfo
1255 {
1256 unsafe fn encode(
1257 self,
1258 encoder: &mut fidl::encoding::Encoder<'_, D>,
1259 offset: usize,
1260 mut depth: fidl::encoding::Depth,
1261 ) -> fidl::Result<()> {
1262 encoder.debug_check_bounds::<ProviderInfo>(offset);
1263 let max_ordinal: u64 = self.max_ordinal_present();
1265 encoder.write_num(max_ordinal, offset);
1266 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1267 if max_ordinal == 0 {
1269 return Ok(());
1270 }
1271 depth.increment()?;
1272 let envelope_size = 8;
1273 let bytes_len = max_ordinal as usize * envelope_size;
1274 #[allow(unused_variables)]
1275 let offset = encoder.out_of_line_offset(bytes_len);
1276 let mut _prev_end_offset: usize = 0;
1277 if 1 > max_ordinal {
1278 return Ok(());
1279 }
1280
1281 let cur_offset: usize = (1 - 1) * envelope_size;
1284
1285 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1287
1288 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1293 self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1294 encoder,
1295 offset + cur_offset,
1296 depth,
1297 )?;
1298
1299 _prev_end_offset = cur_offset + envelope_size;
1300 if 2 > max_ordinal {
1301 return Ok(());
1302 }
1303
1304 let cur_offset: usize = (2 - 1) * envelope_size;
1307
1308 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1310
1311 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1316 self.pid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1317 encoder,
1318 offset + cur_offset,
1319 depth,
1320 )?;
1321
1322 _prev_end_offset = cur_offset + envelope_size;
1323 if 3 > max_ordinal {
1324 return Ok(());
1325 }
1326
1327 let cur_offset: usize = (3 - 1) * envelope_size;
1330
1331 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1333
1334 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1339 self.name.as_ref().map(
1340 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1341 ),
1342 encoder,
1343 offset + cur_offset,
1344 depth,
1345 )?;
1346
1347 _prev_end_offset = cur_offset + envelope_size;
1348
1349 Ok(())
1350 }
1351 }
1352
1353 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderInfo {
1354 #[inline(always)]
1355 fn new_empty() -> Self {
1356 Self::default()
1357 }
1358
1359 unsafe fn decode(
1360 &mut self,
1361 decoder: &mut fidl::encoding::Decoder<'_, D>,
1362 offset: usize,
1363 mut depth: fidl::encoding::Depth,
1364 ) -> fidl::Result<()> {
1365 decoder.debug_check_bounds::<Self>(offset);
1366 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1367 None => return Err(fidl::Error::NotNullable),
1368 Some(len) => len,
1369 };
1370 if len == 0 {
1372 return Ok(());
1373 };
1374 depth.increment()?;
1375 let envelope_size = 8;
1376 let bytes_len = len * envelope_size;
1377 let offset = decoder.out_of_line_offset(bytes_len)?;
1378 let mut _next_ordinal_to_read = 0;
1380 let mut next_offset = offset;
1381 let end_offset = offset + bytes_len;
1382 _next_ordinal_to_read += 1;
1383 if next_offset >= end_offset {
1384 return Ok(());
1385 }
1386
1387 while _next_ordinal_to_read < 1 {
1389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1390 _next_ordinal_to_read += 1;
1391 next_offset += envelope_size;
1392 }
1393
1394 let next_out_of_line = decoder.next_out_of_line();
1395 let handles_before = decoder.remaining_handles();
1396 if let Some((inlined, num_bytes, num_handles)) =
1397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1398 {
1399 let member_inline_size =
1400 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1401 if inlined != (member_inline_size <= 4) {
1402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1403 }
1404 let inner_offset;
1405 let mut inner_depth = depth.clone();
1406 if inlined {
1407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1408 inner_offset = next_offset;
1409 } else {
1410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1411 inner_depth.increment()?;
1412 }
1413 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1414 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1415 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1416 {
1417 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1418 }
1419 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1420 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1421 }
1422 }
1423
1424 next_offset += envelope_size;
1425 _next_ordinal_to_read += 1;
1426 if next_offset >= end_offset {
1427 return Ok(());
1428 }
1429
1430 while _next_ordinal_to_read < 2 {
1432 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1433 _next_ordinal_to_read += 1;
1434 next_offset += envelope_size;
1435 }
1436
1437 let next_out_of_line = decoder.next_out_of_line();
1438 let handles_before = decoder.remaining_handles();
1439 if let Some((inlined, num_bytes, num_handles)) =
1440 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1441 {
1442 let member_inline_size =
1443 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1444 if inlined != (member_inline_size <= 4) {
1445 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1446 }
1447 let inner_offset;
1448 let mut inner_depth = depth.clone();
1449 if inlined {
1450 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1451 inner_offset = next_offset;
1452 } else {
1453 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1454 inner_depth.increment()?;
1455 }
1456 let val_ref = self.pid.get_or_insert_with(|| fidl::new_empty!(u64, D));
1457 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1458 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1459 {
1460 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1461 }
1462 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1463 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1464 }
1465 }
1466
1467 next_offset += envelope_size;
1468 _next_ordinal_to_read += 1;
1469 if next_offset >= end_offset {
1470 return Ok(());
1471 }
1472
1473 while _next_ordinal_to_read < 3 {
1475 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1476 _next_ordinal_to_read += 1;
1477 next_offset += envelope_size;
1478 }
1479
1480 let next_out_of_line = decoder.next_out_of_line();
1481 let handles_before = decoder.remaining_handles();
1482 if let Some((inlined, num_bytes, num_handles)) =
1483 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1484 {
1485 let member_inline_size =
1486 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1487 decoder.context,
1488 );
1489 if inlined != (member_inline_size <= 4) {
1490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1491 }
1492 let inner_offset;
1493 let mut inner_depth = depth.clone();
1494 if inlined {
1495 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1496 inner_offset = next_offset;
1497 } else {
1498 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1499 inner_depth.increment()?;
1500 }
1501 let val_ref = self
1502 .name
1503 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1504 fidl::decode!(
1505 fidl::encoding::BoundedString<100>,
1506 D,
1507 val_ref,
1508 decoder,
1509 inner_offset,
1510 inner_depth
1511 )?;
1512 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1513 {
1514 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1515 }
1516 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1517 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1518 }
1519 }
1520
1521 next_offset += envelope_size;
1522
1523 while next_offset < end_offset {
1525 _next_ordinal_to_read += 1;
1526 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1527 next_offset += envelope_size;
1528 }
1529
1530 Ok(())
1531 }
1532 }
1533
1534 impl ProviderSpec {
1535 #[inline(always)]
1536 fn max_ordinal_present(&self) -> u64 {
1537 if let Some(_) = self.categories {
1538 return 3;
1539 }
1540 if let Some(_) = self.buffer_size_megabytes_hint {
1541 return 2;
1542 }
1543 if let Some(_) = self.name {
1544 return 1;
1545 }
1546 0
1547 }
1548 }
1549
1550 impl fidl::encoding::ValueTypeMarker for ProviderSpec {
1551 type Borrowed<'a> = &'a Self;
1552 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1553 value
1554 }
1555 }
1556
1557 unsafe impl fidl::encoding::TypeMarker for ProviderSpec {
1558 type Owned = Self;
1559
1560 #[inline(always)]
1561 fn inline_align(_context: fidl::encoding::Context) -> usize {
1562 8
1563 }
1564
1565 #[inline(always)]
1566 fn inline_size(_context: fidl::encoding::Context) -> usize {
1567 16
1568 }
1569 }
1570
1571 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderSpec, D>
1572 for &ProviderSpec
1573 {
1574 unsafe fn encode(
1575 self,
1576 encoder: &mut fidl::encoding::Encoder<'_, D>,
1577 offset: usize,
1578 mut depth: fidl::encoding::Depth,
1579 ) -> fidl::Result<()> {
1580 encoder.debug_check_bounds::<ProviderSpec>(offset);
1581 let max_ordinal: u64 = self.max_ordinal_present();
1583 encoder.write_num(max_ordinal, offset);
1584 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1585 if max_ordinal == 0 {
1587 return Ok(());
1588 }
1589 depth.increment()?;
1590 let envelope_size = 8;
1591 let bytes_len = max_ordinal as usize * envelope_size;
1592 #[allow(unused_variables)]
1593 let offset = encoder.out_of_line_offset(bytes_len);
1594 let mut _prev_end_offset: usize = 0;
1595 if 1 > max_ordinal {
1596 return Ok(());
1597 }
1598
1599 let cur_offset: usize = (1 - 1) * envelope_size;
1602
1603 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1605
1606 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1611 self.name.as_ref().map(
1612 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1613 ),
1614 encoder,
1615 offset + cur_offset,
1616 depth,
1617 )?;
1618
1619 _prev_end_offset = cur_offset + envelope_size;
1620 if 2 > max_ordinal {
1621 return Ok(());
1622 }
1623
1624 let cur_offset: usize = (2 - 1) * envelope_size;
1627
1628 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1630
1631 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1636 self.buffer_size_megabytes_hint
1637 .as_ref()
1638 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1639 encoder,
1640 offset + cur_offset,
1641 depth,
1642 )?;
1643
1644 _prev_end_offset = cur_offset + envelope_size;
1645 if 3 > max_ordinal {
1646 return Ok(());
1647 }
1648
1649 let cur_offset: usize = (3 - 1) * envelope_size;
1652
1653 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1655
1656 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>, D>(
1661 self.categories.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000> as fidl::encoding::ValueTypeMarker>::borrow),
1662 encoder, offset + cur_offset, depth
1663 )?;
1664
1665 _prev_end_offset = cur_offset + envelope_size;
1666
1667 Ok(())
1668 }
1669 }
1670
1671 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderSpec {
1672 #[inline(always)]
1673 fn new_empty() -> Self {
1674 Self::default()
1675 }
1676
1677 unsafe fn decode(
1678 &mut self,
1679 decoder: &mut fidl::encoding::Decoder<'_, D>,
1680 offset: usize,
1681 mut depth: fidl::encoding::Depth,
1682 ) -> fidl::Result<()> {
1683 decoder.debug_check_bounds::<Self>(offset);
1684 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1685 None => return Err(fidl::Error::NotNullable),
1686 Some(len) => len,
1687 };
1688 if len == 0 {
1690 return Ok(());
1691 };
1692 depth.increment()?;
1693 let envelope_size = 8;
1694 let bytes_len = len * envelope_size;
1695 let offset = decoder.out_of_line_offset(bytes_len)?;
1696 let mut _next_ordinal_to_read = 0;
1698 let mut next_offset = offset;
1699 let end_offset = offset + bytes_len;
1700 _next_ordinal_to_read += 1;
1701 if next_offset >= end_offset {
1702 return Ok(());
1703 }
1704
1705 while _next_ordinal_to_read < 1 {
1707 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1708 _next_ordinal_to_read += 1;
1709 next_offset += envelope_size;
1710 }
1711
1712 let next_out_of_line = decoder.next_out_of_line();
1713 let handles_before = decoder.remaining_handles();
1714 if let Some((inlined, num_bytes, num_handles)) =
1715 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1716 {
1717 let member_inline_size =
1718 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1719 decoder.context,
1720 );
1721 if inlined != (member_inline_size <= 4) {
1722 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1723 }
1724 let inner_offset;
1725 let mut inner_depth = depth.clone();
1726 if inlined {
1727 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1728 inner_offset = next_offset;
1729 } else {
1730 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1731 inner_depth.increment()?;
1732 }
1733 let val_ref = self
1734 .name
1735 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1736 fidl::decode!(
1737 fidl::encoding::BoundedString<100>,
1738 D,
1739 val_ref,
1740 decoder,
1741 inner_offset,
1742 inner_depth
1743 )?;
1744 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1745 {
1746 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1747 }
1748 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1749 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1750 }
1751 }
1752
1753 next_offset += envelope_size;
1754 _next_ordinal_to_read += 1;
1755 if next_offset >= end_offset {
1756 return Ok(());
1757 }
1758
1759 while _next_ordinal_to_read < 2 {
1761 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1762 _next_ordinal_to_read += 1;
1763 next_offset += envelope_size;
1764 }
1765
1766 let next_out_of_line = decoder.next_out_of_line();
1767 let handles_before = decoder.remaining_handles();
1768 if let Some((inlined, num_bytes, num_handles)) =
1769 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1770 {
1771 let member_inline_size =
1772 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1773 if inlined != (member_inline_size <= 4) {
1774 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1775 }
1776 let inner_offset;
1777 let mut inner_depth = depth.clone();
1778 if inlined {
1779 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1780 inner_offset = next_offset;
1781 } else {
1782 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1783 inner_depth.increment()?;
1784 }
1785 let val_ref =
1786 self.buffer_size_megabytes_hint.get_or_insert_with(|| fidl::new_empty!(u32, D));
1787 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1788 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1789 {
1790 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1791 }
1792 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1793 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1794 }
1795 }
1796
1797 next_offset += envelope_size;
1798 _next_ordinal_to_read += 1;
1799 if next_offset >= end_offset {
1800 return Ok(());
1801 }
1802
1803 while _next_ordinal_to_read < 3 {
1805 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1806 _next_ordinal_to_read += 1;
1807 next_offset += envelope_size;
1808 }
1809
1810 let next_out_of_line = decoder.next_out_of_line();
1811 let handles_before = decoder.remaining_handles();
1812 if let Some((inlined, num_bytes, num_handles)) =
1813 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1814 {
1815 let member_inline_size = <fidl::encoding::Vector<
1816 fidl::encoding::BoundedString<100>,
1817 5000,
1818 > as fidl::encoding::TypeMarker>::inline_size(
1819 decoder.context
1820 );
1821 if inlined != (member_inline_size <= 4) {
1822 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1823 }
1824 let inner_offset;
1825 let mut inner_depth = depth.clone();
1826 if inlined {
1827 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1828 inner_offset = next_offset;
1829 } else {
1830 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1831 inner_depth.increment()?;
1832 }
1833 let val_ref = self.categories.get_or_insert_with(|| {
1834 fidl::new_empty!(
1835 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
1836 D
1837 )
1838 });
1839 fidl::decode!(
1840 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
1841 D,
1842 val_ref,
1843 decoder,
1844 inner_offset,
1845 inner_depth
1846 )?;
1847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1848 {
1849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1850 }
1851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1853 }
1854 }
1855
1856 next_offset += envelope_size;
1857
1858 while next_offset < end_offset {
1860 _next_ordinal_to_read += 1;
1861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1862 next_offset += envelope_size;
1863 }
1864
1865 Ok(())
1866 }
1867 }
1868
1869 impl ProviderStats {
1870 #[inline(always)]
1871 fn max_ordinal_present(&self) -> u64 {
1872 if let Some(_) = self.non_durable_bytes_written {
1873 return 7;
1874 }
1875 if let Some(_) = self.percentage_durable_buffer_used {
1876 return 6;
1877 }
1878 if let Some(_) = self.records_dropped {
1879 return 5;
1880 }
1881 if let Some(_) = self.buffer_wrapped_count {
1882 return 4;
1883 }
1884 if let Some(_) = self.buffering_mode {
1885 return 3;
1886 }
1887 if let Some(_) = self.pid {
1888 return 2;
1889 }
1890 if let Some(_) = self.name {
1891 return 1;
1892 }
1893 0
1894 }
1895 }
1896
1897 impl fidl::encoding::ValueTypeMarker for ProviderStats {
1898 type Borrowed<'a> = &'a Self;
1899 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1900 value
1901 }
1902 }
1903
1904 unsafe impl fidl::encoding::TypeMarker for ProviderStats {
1905 type Owned = Self;
1906
1907 #[inline(always)]
1908 fn inline_align(_context: fidl::encoding::Context) -> usize {
1909 8
1910 }
1911
1912 #[inline(always)]
1913 fn inline_size(_context: fidl::encoding::Context) -> usize {
1914 16
1915 }
1916 }
1917
1918 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderStats, D>
1919 for &ProviderStats
1920 {
1921 unsafe fn encode(
1922 self,
1923 encoder: &mut fidl::encoding::Encoder<'_, D>,
1924 offset: usize,
1925 mut depth: fidl::encoding::Depth,
1926 ) -> fidl::Result<()> {
1927 encoder.debug_check_bounds::<ProviderStats>(offset);
1928 let max_ordinal: u64 = self.max_ordinal_present();
1930 encoder.write_num(max_ordinal, offset);
1931 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1932 if max_ordinal == 0 {
1934 return Ok(());
1935 }
1936 depth.increment()?;
1937 let envelope_size = 8;
1938 let bytes_len = max_ordinal as usize * envelope_size;
1939 #[allow(unused_variables)]
1940 let offset = encoder.out_of_line_offset(bytes_len);
1941 let mut _prev_end_offset: usize = 0;
1942 if 1 > max_ordinal {
1943 return Ok(());
1944 }
1945
1946 let cur_offset: usize = (1 - 1) * envelope_size;
1949
1950 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1952
1953 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1958 self.name.as_ref().map(
1959 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1960 ),
1961 encoder,
1962 offset + cur_offset,
1963 depth,
1964 )?;
1965
1966 _prev_end_offset = cur_offset + envelope_size;
1967 if 2 > max_ordinal {
1968 return Ok(());
1969 }
1970
1971 let cur_offset: usize = (2 - 1) * envelope_size;
1974
1975 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1977
1978 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1983 self.pid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1984 encoder,
1985 offset + cur_offset,
1986 depth,
1987 )?;
1988
1989 _prev_end_offset = cur_offset + envelope_size;
1990 if 3 > max_ordinal {
1991 return Ok(());
1992 }
1993
1994 let cur_offset: usize = (3 - 1) * envelope_size;
1997
1998 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2000
2001 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_tracing__common::BufferingMode, D>(
2006 self.buffering_mode.as_ref().map(<fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::ValueTypeMarker>::borrow),
2007 encoder, offset + cur_offset, depth
2008 )?;
2009
2010 _prev_end_offset = cur_offset + envelope_size;
2011 if 4 > max_ordinal {
2012 return Ok(());
2013 }
2014
2015 let cur_offset: usize = (4 - 1) * envelope_size;
2018
2019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2021
2022 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2027 self.buffer_wrapped_count
2028 .as_ref()
2029 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2030 encoder,
2031 offset + cur_offset,
2032 depth,
2033 )?;
2034
2035 _prev_end_offset = cur_offset + envelope_size;
2036 if 5 > max_ordinal {
2037 return Ok(());
2038 }
2039
2040 let cur_offset: usize = (5 - 1) * envelope_size;
2043
2044 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2046
2047 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2052 self.records_dropped.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2053 encoder,
2054 offset + cur_offset,
2055 depth,
2056 )?;
2057
2058 _prev_end_offset = cur_offset + envelope_size;
2059 if 6 > max_ordinal {
2060 return Ok(());
2061 }
2062
2063 let cur_offset: usize = (6 - 1) * envelope_size;
2066
2067 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2069
2070 fidl::encoding::encode_in_envelope_optional::<f32, D>(
2075 self.percentage_durable_buffer_used
2076 .as_ref()
2077 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
2078 encoder,
2079 offset + cur_offset,
2080 depth,
2081 )?;
2082
2083 _prev_end_offset = cur_offset + envelope_size;
2084 if 7 > max_ordinal {
2085 return Ok(());
2086 }
2087
2088 let cur_offset: usize = (7 - 1) * envelope_size;
2091
2092 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2094
2095 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2100 self.non_durable_bytes_written
2101 .as_ref()
2102 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2103 encoder,
2104 offset + cur_offset,
2105 depth,
2106 )?;
2107
2108 _prev_end_offset = cur_offset + envelope_size;
2109
2110 Ok(())
2111 }
2112 }
2113
2114 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderStats {
2115 #[inline(always)]
2116 fn new_empty() -> Self {
2117 Self::default()
2118 }
2119
2120 unsafe fn decode(
2121 &mut self,
2122 decoder: &mut fidl::encoding::Decoder<'_, D>,
2123 offset: usize,
2124 mut depth: fidl::encoding::Depth,
2125 ) -> fidl::Result<()> {
2126 decoder.debug_check_bounds::<Self>(offset);
2127 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2128 None => return Err(fidl::Error::NotNullable),
2129 Some(len) => len,
2130 };
2131 if len == 0 {
2133 return Ok(());
2134 };
2135 depth.increment()?;
2136 let envelope_size = 8;
2137 let bytes_len = len * envelope_size;
2138 let offset = decoder.out_of_line_offset(bytes_len)?;
2139 let mut _next_ordinal_to_read = 0;
2141 let mut next_offset = offset;
2142 let end_offset = offset + bytes_len;
2143 _next_ordinal_to_read += 1;
2144 if next_offset >= end_offset {
2145 return Ok(());
2146 }
2147
2148 while _next_ordinal_to_read < 1 {
2150 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2151 _next_ordinal_to_read += 1;
2152 next_offset += envelope_size;
2153 }
2154
2155 let next_out_of_line = decoder.next_out_of_line();
2156 let handles_before = decoder.remaining_handles();
2157 if let Some((inlined, num_bytes, num_handles)) =
2158 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2159 {
2160 let member_inline_size =
2161 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
2162 decoder.context,
2163 );
2164 if inlined != (member_inline_size <= 4) {
2165 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2166 }
2167 let inner_offset;
2168 let mut inner_depth = depth.clone();
2169 if inlined {
2170 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2171 inner_offset = next_offset;
2172 } else {
2173 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2174 inner_depth.increment()?;
2175 }
2176 let val_ref = self
2177 .name
2178 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
2179 fidl::decode!(
2180 fidl::encoding::BoundedString<100>,
2181 D,
2182 val_ref,
2183 decoder,
2184 inner_offset,
2185 inner_depth
2186 )?;
2187 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2188 {
2189 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2190 }
2191 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2192 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2193 }
2194 }
2195
2196 next_offset += envelope_size;
2197 _next_ordinal_to_read += 1;
2198 if next_offset >= end_offset {
2199 return Ok(());
2200 }
2201
2202 while _next_ordinal_to_read < 2 {
2204 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2205 _next_ordinal_to_read += 1;
2206 next_offset += envelope_size;
2207 }
2208
2209 let next_out_of_line = decoder.next_out_of_line();
2210 let handles_before = decoder.remaining_handles();
2211 if let Some((inlined, num_bytes, num_handles)) =
2212 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2213 {
2214 let member_inline_size =
2215 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2216 if inlined != (member_inline_size <= 4) {
2217 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2218 }
2219 let inner_offset;
2220 let mut inner_depth = depth.clone();
2221 if inlined {
2222 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2223 inner_offset = next_offset;
2224 } else {
2225 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2226 inner_depth.increment()?;
2227 }
2228 let val_ref = self.pid.get_or_insert_with(|| fidl::new_empty!(u64, D));
2229 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2230 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2231 {
2232 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2233 }
2234 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2235 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2236 }
2237 }
2238
2239 next_offset += envelope_size;
2240 _next_ordinal_to_read += 1;
2241 if next_offset >= end_offset {
2242 return Ok(());
2243 }
2244
2245 while _next_ordinal_to_read < 3 {
2247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2248 _next_ordinal_to_read += 1;
2249 next_offset += envelope_size;
2250 }
2251
2252 let next_out_of_line = decoder.next_out_of_line();
2253 let handles_before = decoder.remaining_handles();
2254 if let Some((inlined, num_bytes, num_handles)) =
2255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2256 {
2257 let member_inline_size = <fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2258 if inlined != (member_inline_size <= 4) {
2259 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2260 }
2261 let inner_offset;
2262 let mut inner_depth = depth.clone();
2263 if inlined {
2264 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2265 inner_offset = next_offset;
2266 } else {
2267 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2268 inner_depth.increment()?;
2269 }
2270 let val_ref = self.buffering_mode.get_or_insert_with(|| {
2271 fidl::new_empty!(fidl_fuchsia_tracing__common::BufferingMode, D)
2272 });
2273 fidl::decode!(
2274 fidl_fuchsia_tracing__common::BufferingMode,
2275 D,
2276 val_ref,
2277 decoder,
2278 inner_offset,
2279 inner_depth
2280 )?;
2281 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2282 {
2283 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2284 }
2285 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2286 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2287 }
2288 }
2289
2290 next_offset += envelope_size;
2291 _next_ordinal_to_read += 1;
2292 if next_offset >= end_offset {
2293 return Ok(());
2294 }
2295
2296 while _next_ordinal_to_read < 4 {
2298 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2299 _next_ordinal_to_read += 1;
2300 next_offset += envelope_size;
2301 }
2302
2303 let next_out_of_line = decoder.next_out_of_line();
2304 let handles_before = decoder.remaining_handles();
2305 if let Some((inlined, num_bytes, num_handles)) =
2306 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2307 {
2308 let member_inline_size =
2309 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2310 if inlined != (member_inline_size <= 4) {
2311 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2312 }
2313 let inner_offset;
2314 let mut inner_depth = depth.clone();
2315 if inlined {
2316 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2317 inner_offset = next_offset;
2318 } else {
2319 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2320 inner_depth.increment()?;
2321 }
2322 let val_ref =
2323 self.buffer_wrapped_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
2324 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2325 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2326 {
2327 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2328 }
2329 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2330 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2331 }
2332 }
2333
2334 next_offset += envelope_size;
2335 _next_ordinal_to_read += 1;
2336 if next_offset >= end_offset {
2337 return Ok(());
2338 }
2339
2340 while _next_ordinal_to_read < 5 {
2342 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2343 _next_ordinal_to_read += 1;
2344 next_offset += envelope_size;
2345 }
2346
2347 let next_out_of_line = decoder.next_out_of_line();
2348 let handles_before = decoder.remaining_handles();
2349 if let Some((inlined, num_bytes, num_handles)) =
2350 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2351 {
2352 let member_inline_size =
2353 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2354 if inlined != (member_inline_size <= 4) {
2355 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2356 }
2357 let inner_offset;
2358 let mut inner_depth = depth.clone();
2359 if inlined {
2360 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2361 inner_offset = next_offset;
2362 } else {
2363 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2364 inner_depth.increment()?;
2365 }
2366 let val_ref = self.records_dropped.get_or_insert_with(|| fidl::new_empty!(u64, D));
2367 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2368 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2369 {
2370 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2371 }
2372 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2373 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2374 }
2375 }
2376
2377 next_offset += envelope_size;
2378 _next_ordinal_to_read += 1;
2379 if next_offset >= end_offset {
2380 return Ok(());
2381 }
2382
2383 while _next_ordinal_to_read < 6 {
2385 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2386 _next_ordinal_to_read += 1;
2387 next_offset += envelope_size;
2388 }
2389
2390 let next_out_of_line = decoder.next_out_of_line();
2391 let handles_before = decoder.remaining_handles();
2392 if let Some((inlined, num_bytes, num_handles)) =
2393 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2394 {
2395 let member_inline_size =
2396 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2397 if inlined != (member_inline_size <= 4) {
2398 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2399 }
2400 let inner_offset;
2401 let mut inner_depth = depth.clone();
2402 if inlined {
2403 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2404 inner_offset = next_offset;
2405 } else {
2406 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2407 inner_depth.increment()?;
2408 }
2409 let val_ref = self
2410 .percentage_durable_buffer_used
2411 .get_or_insert_with(|| fidl::new_empty!(f32, D));
2412 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
2413 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2414 {
2415 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2416 }
2417 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2418 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2419 }
2420 }
2421
2422 next_offset += envelope_size;
2423 _next_ordinal_to_read += 1;
2424 if next_offset >= end_offset {
2425 return Ok(());
2426 }
2427
2428 while _next_ordinal_to_read < 7 {
2430 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2431 _next_ordinal_to_read += 1;
2432 next_offset += envelope_size;
2433 }
2434
2435 let next_out_of_line = decoder.next_out_of_line();
2436 let handles_before = decoder.remaining_handles();
2437 if let Some((inlined, num_bytes, num_handles)) =
2438 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2439 {
2440 let member_inline_size =
2441 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2442 if inlined != (member_inline_size <= 4) {
2443 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2444 }
2445 let inner_offset;
2446 let mut inner_depth = depth.clone();
2447 if inlined {
2448 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2449 inner_offset = next_offset;
2450 } else {
2451 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2452 inner_depth.increment()?;
2453 }
2454 let val_ref =
2455 self.non_durable_bytes_written.get_or_insert_with(|| fidl::new_empty!(u64, D));
2456 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2457 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2458 {
2459 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2460 }
2461 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2462 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2463 }
2464 }
2465
2466 next_offset += envelope_size;
2467
2468 while next_offset < end_offset {
2470 _next_ordinal_to_read += 1;
2471 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2472 next_offset += envelope_size;
2473 }
2474
2475 Ok(())
2476 }
2477 }
2478
2479 impl StartOptions {
2480 #[inline(always)]
2481 fn max_ordinal_present(&self) -> u64 {
2482 if let Some(_) = self.additional_categories {
2483 return 2;
2484 }
2485 if let Some(_) = self.buffer_disposition {
2486 return 1;
2487 }
2488 0
2489 }
2490 }
2491
2492 impl fidl::encoding::ValueTypeMarker for StartOptions {
2493 type Borrowed<'a> = &'a Self;
2494 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2495 value
2496 }
2497 }
2498
2499 unsafe impl fidl::encoding::TypeMarker for StartOptions {
2500 type Owned = Self;
2501
2502 #[inline(always)]
2503 fn inline_align(_context: fidl::encoding::Context) -> usize {
2504 8
2505 }
2506
2507 #[inline(always)]
2508 fn inline_size(_context: fidl::encoding::Context) -> usize {
2509 16
2510 }
2511 }
2512
2513 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartOptions, D>
2514 for &StartOptions
2515 {
2516 unsafe fn encode(
2517 self,
2518 encoder: &mut fidl::encoding::Encoder<'_, D>,
2519 offset: usize,
2520 mut depth: fidl::encoding::Depth,
2521 ) -> fidl::Result<()> {
2522 encoder.debug_check_bounds::<StartOptions>(offset);
2523 let max_ordinal: u64 = self.max_ordinal_present();
2525 encoder.write_num(max_ordinal, offset);
2526 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2527 if max_ordinal == 0 {
2529 return Ok(());
2530 }
2531 depth.increment()?;
2532 let envelope_size = 8;
2533 let bytes_len = max_ordinal as usize * envelope_size;
2534 #[allow(unused_variables)]
2535 let offset = encoder.out_of_line_offset(bytes_len);
2536 let mut _prev_end_offset: usize = 0;
2537 if 1 > max_ordinal {
2538 return Ok(());
2539 }
2540
2541 let cur_offset: usize = (1 - 1) * envelope_size;
2544
2545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2547
2548 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_tracing__common::BufferDisposition, D>(
2553 self.buffer_disposition.as_ref().map(<fidl_fuchsia_tracing__common::BufferDisposition as fidl::encoding::ValueTypeMarker>::borrow),
2554 encoder, offset + cur_offset, depth
2555 )?;
2556
2557 _prev_end_offset = cur_offset + envelope_size;
2558 if 2 > max_ordinal {
2559 return Ok(());
2560 }
2561
2562 let cur_offset: usize = (2 - 1) * envelope_size;
2565
2566 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2568
2569 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>, D>(
2574 self.additional_categories.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000> as fidl::encoding::ValueTypeMarker>::borrow),
2575 encoder, offset + cur_offset, depth
2576 )?;
2577
2578 _prev_end_offset = cur_offset + envelope_size;
2579
2580 Ok(())
2581 }
2582 }
2583
2584 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartOptions {
2585 #[inline(always)]
2586 fn new_empty() -> Self {
2587 Self::default()
2588 }
2589
2590 unsafe fn decode(
2591 &mut self,
2592 decoder: &mut fidl::encoding::Decoder<'_, D>,
2593 offset: usize,
2594 mut depth: fidl::encoding::Depth,
2595 ) -> fidl::Result<()> {
2596 decoder.debug_check_bounds::<Self>(offset);
2597 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2598 None => return Err(fidl::Error::NotNullable),
2599 Some(len) => len,
2600 };
2601 if len == 0 {
2603 return Ok(());
2604 };
2605 depth.increment()?;
2606 let envelope_size = 8;
2607 let bytes_len = len * envelope_size;
2608 let offset = decoder.out_of_line_offset(bytes_len)?;
2609 let mut _next_ordinal_to_read = 0;
2611 let mut next_offset = offset;
2612 let end_offset = offset + bytes_len;
2613 _next_ordinal_to_read += 1;
2614 if next_offset >= end_offset {
2615 return Ok(());
2616 }
2617
2618 while _next_ordinal_to_read < 1 {
2620 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2621 _next_ordinal_to_read += 1;
2622 next_offset += envelope_size;
2623 }
2624
2625 let next_out_of_line = decoder.next_out_of_line();
2626 let handles_before = decoder.remaining_handles();
2627 if let Some((inlined, num_bytes, num_handles)) =
2628 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2629 {
2630 let member_inline_size = <fidl_fuchsia_tracing__common::BufferDisposition as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2631 if inlined != (member_inline_size <= 4) {
2632 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2633 }
2634 let inner_offset;
2635 let mut inner_depth = depth.clone();
2636 if inlined {
2637 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2638 inner_offset = next_offset;
2639 } else {
2640 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2641 inner_depth.increment()?;
2642 }
2643 let val_ref = self.buffer_disposition.get_or_insert_with(|| {
2644 fidl::new_empty!(fidl_fuchsia_tracing__common::BufferDisposition, D)
2645 });
2646 fidl::decode!(
2647 fidl_fuchsia_tracing__common::BufferDisposition,
2648 D,
2649 val_ref,
2650 decoder,
2651 inner_offset,
2652 inner_depth
2653 )?;
2654 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2655 {
2656 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2657 }
2658 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2659 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2660 }
2661 }
2662
2663 next_offset += envelope_size;
2664 _next_ordinal_to_read += 1;
2665 if next_offset >= end_offset {
2666 return Ok(());
2667 }
2668
2669 while _next_ordinal_to_read < 2 {
2671 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2672 _next_ordinal_to_read += 1;
2673 next_offset += envelope_size;
2674 }
2675
2676 let next_out_of_line = decoder.next_out_of_line();
2677 let handles_before = decoder.remaining_handles();
2678 if let Some((inlined, num_bytes, num_handles)) =
2679 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2680 {
2681 let member_inline_size = <fidl::encoding::Vector<
2682 fidl::encoding::BoundedString<100>,
2683 5000,
2684 > as fidl::encoding::TypeMarker>::inline_size(
2685 decoder.context
2686 );
2687 if inlined != (member_inline_size <= 4) {
2688 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2689 }
2690 let inner_offset;
2691 let mut inner_depth = depth.clone();
2692 if inlined {
2693 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2694 inner_offset = next_offset;
2695 } else {
2696 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2697 inner_depth.increment()?;
2698 }
2699 let val_ref = self.additional_categories.get_or_insert_with(|| {
2700 fidl::new_empty!(
2701 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
2702 D
2703 )
2704 });
2705 fidl::decode!(
2706 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
2707 D,
2708 val_ref,
2709 decoder,
2710 inner_offset,
2711 inner_depth
2712 )?;
2713 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2714 {
2715 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2716 }
2717 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2718 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2719 }
2720 }
2721
2722 next_offset += envelope_size;
2723
2724 while next_offset < end_offset {
2726 _next_ordinal_to_read += 1;
2727 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2728 next_offset += envelope_size;
2729 }
2730
2731 Ok(())
2732 }
2733 }
2734
2735 impl StopOptions {
2736 #[inline(always)]
2737 fn max_ordinal_present(&self) -> u64 {
2738 if let Some(_) = self.write_results {
2739 return 1;
2740 }
2741 0
2742 }
2743 }
2744
2745 impl fidl::encoding::ValueTypeMarker for StopOptions {
2746 type Borrowed<'a> = &'a Self;
2747 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2748 value
2749 }
2750 }
2751
2752 unsafe impl fidl::encoding::TypeMarker for StopOptions {
2753 type Owned = Self;
2754
2755 #[inline(always)]
2756 fn inline_align(_context: fidl::encoding::Context) -> usize {
2757 8
2758 }
2759
2760 #[inline(always)]
2761 fn inline_size(_context: fidl::encoding::Context) -> usize {
2762 16
2763 }
2764 }
2765
2766 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopOptions, D>
2767 for &StopOptions
2768 {
2769 unsafe fn encode(
2770 self,
2771 encoder: &mut fidl::encoding::Encoder<'_, D>,
2772 offset: usize,
2773 mut depth: fidl::encoding::Depth,
2774 ) -> fidl::Result<()> {
2775 encoder.debug_check_bounds::<StopOptions>(offset);
2776 let max_ordinal: u64 = self.max_ordinal_present();
2778 encoder.write_num(max_ordinal, offset);
2779 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2780 if max_ordinal == 0 {
2782 return Ok(());
2783 }
2784 depth.increment()?;
2785 let envelope_size = 8;
2786 let bytes_len = max_ordinal as usize * envelope_size;
2787 #[allow(unused_variables)]
2788 let offset = encoder.out_of_line_offset(bytes_len);
2789 let mut _prev_end_offset: usize = 0;
2790 if 1 > max_ordinal {
2791 return Ok(());
2792 }
2793
2794 let cur_offset: usize = (1 - 1) * envelope_size;
2797
2798 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2800
2801 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2806 self.write_results.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2807 encoder,
2808 offset + cur_offset,
2809 depth,
2810 )?;
2811
2812 _prev_end_offset = cur_offset + envelope_size;
2813
2814 Ok(())
2815 }
2816 }
2817
2818 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopOptions {
2819 #[inline(always)]
2820 fn new_empty() -> Self {
2821 Self::default()
2822 }
2823
2824 unsafe fn decode(
2825 &mut self,
2826 decoder: &mut fidl::encoding::Decoder<'_, D>,
2827 offset: usize,
2828 mut depth: fidl::encoding::Depth,
2829 ) -> fidl::Result<()> {
2830 decoder.debug_check_bounds::<Self>(offset);
2831 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2832 None => return Err(fidl::Error::NotNullable),
2833 Some(len) => len,
2834 };
2835 if len == 0 {
2837 return Ok(());
2838 };
2839 depth.increment()?;
2840 let envelope_size = 8;
2841 let bytes_len = len * envelope_size;
2842 let offset = decoder.out_of_line_offset(bytes_len)?;
2843 let mut _next_ordinal_to_read = 0;
2845 let mut next_offset = offset;
2846 let end_offset = offset + bytes_len;
2847 _next_ordinal_to_read += 1;
2848 if next_offset >= end_offset {
2849 return Ok(());
2850 }
2851
2852 while _next_ordinal_to_read < 1 {
2854 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2855 _next_ordinal_to_read += 1;
2856 next_offset += envelope_size;
2857 }
2858
2859 let next_out_of_line = decoder.next_out_of_line();
2860 let handles_before = decoder.remaining_handles();
2861 if let Some((inlined, num_bytes, num_handles)) =
2862 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2863 {
2864 let member_inline_size =
2865 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2866 if inlined != (member_inline_size <= 4) {
2867 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2868 }
2869 let inner_offset;
2870 let mut inner_depth = depth.clone();
2871 if inlined {
2872 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2873 inner_offset = next_offset;
2874 } else {
2875 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2876 inner_depth.increment()?;
2877 }
2878 let val_ref = self.write_results.get_or_insert_with(|| fidl::new_empty!(bool, D));
2879 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2880 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2881 {
2882 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2883 }
2884 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2885 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2886 }
2887 }
2888
2889 next_offset += envelope_size;
2890
2891 while next_offset < end_offset {
2893 _next_ordinal_to_read += 1;
2894 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2895 next_offset += envelope_size;
2896 }
2897
2898 Ok(())
2899 }
2900 }
2901
2902 impl StopResult {
2903 #[inline(always)]
2904 fn max_ordinal_present(&self) -> u64 {
2905 if let Some(_) = self.provider_stats {
2906 return 1;
2907 }
2908 0
2909 }
2910 }
2911
2912 impl fidl::encoding::ValueTypeMarker for StopResult {
2913 type Borrowed<'a> = &'a Self;
2914 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2915 value
2916 }
2917 }
2918
2919 unsafe impl fidl::encoding::TypeMarker for StopResult {
2920 type Owned = Self;
2921
2922 #[inline(always)]
2923 fn inline_align(_context: fidl::encoding::Context) -> usize {
2924 8
2925 }
2926
2927 #[inline(always)]
2928 fn inline_size(_context: fidl::encoding::Context) -> usize {
2929 16
2930 }
2931 }
2932
2933 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopResult, D>
2934 for &StopResult
2935 {
2936 unsafe fn encode(
2937 self,
2938 encoder: &mut fidl::encoding::Encoder<'_, D>,
2939 offset: usize,
2940 mut depth: fidl::encoding::Depth,
2941 ) -> fidl::Result<()> {
2942 encoder.debug_check_bounds::<StopResult>(offset);
2943 let max_ordinal: u64 = self.max_ordinal_present();
2945 encoder.write_num(max_ordinal, offset);
2946 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2947 if max_ordinal == 0 {
2949 return Ok(());
2950 }
2951 depth.increment()?;
2952 let envelope_size = 8;
2953 let bytes_len = max_ordinal as usize * envelope_size;
2954 #[allow(unused_variables)]
2955 let offset = encoder.out_of_line_offset(bytes_len);
2956 let mut _prev_end_offset: usize = 0;
2957 if 1 > max_ordinal {
2958 return Ok(());
2959 }
2960
2961 let cur_offset: usize = (1 - 1) * envelope_size;
2964
2965 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2967
2968 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProviderStats, 100>, D>(
2973 self.provider_stats.as_ref().map(<fidl::encoding::Vector<ProviderStats, 100> as fidl::encoding::ValueTypeMarker>::borrow),
2974 encoder, offset + cur_offset, depth
2975 )?;
2976
2977 _prev_end_offset = cur_offset + envelope_size;
2978
2979 Ok(())
2980 }
2981 }
2982
2983 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResult {
2984 #[inline(always)]
2985 fn new_empty() -> Self {
2986 Self::default()
2987 }
2988
2989 unsafe fn decode(
2990 &mut self,
2991 decoder: &mut fidl::encoding::Decoder<'_, D>,
2992 offset: usize,
2993 mut depth: fidl::encoding::Depth,
2994 ) -> fidl::Result<()> {
2995 decoder.debug_check_bounds::<Self>(offset);
2996 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2997 None => return Err(fidl::Error::NotNullable),
2998 Some(len) => len,
2999 };
3000 if len == 0 {
3002 return Ok(());
3003 };
3004 depth.increment()?;
3005 let envelope_size = 8;
3006 let bytes_len = len * envelope_size;
3007 let offset = decoder.out_of_line_offset(bytes_len)?;
3008 let mut _next_ordinal_to_read = 0;
3010 let mut next_offset = offset;
3011 let end_offset = offset + bytes_len;
3012 _next_ordinal_to_read += 1;
3013 if next_offset >= end_offset {
3014 return Ok(());
3015 }
3016
3017 while _next_ordinal_to_read < 1 {
3019 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3020 _next_ordinal_to_read += 1;
3021 next_offset += envelope_size;
3022 }
3023
3024 let next_out_of_line = decoder.next_out_of_line();
3025 let handles_before = decoder.remaining_handles();
3026 if let Some((inlined, num_bytes, num_handles)) =
3027 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3028 {
3029 let member_inline_size = <fidl::encoding::Vector<ProviderStats, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3030 if inlined != (member_inline_size <= 4) {
3031 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3032 }
3033 let inner_offset;
3034 let mut inner_depth = depth.clone();
3035 if inlined {
3036 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3037 inner_offset = next_offset;
3038 } else {
3039 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3040 inner_depth.increment()?;
3041 }
3042 let val_ref = self.provider_stats.get_or_insert_with(
3043 || fidl::new_empty!(fidl::encoding::Vector<ProviderStats, 100>, D),
3044 );
3045 fidl::decode!(fidl::encoding::Vector<ProviderStats, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
3046 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3047 {
3048 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3049 }
3050 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3051 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3052 }
3053 }
3054
3055 next_offset += envelope_size;
3056
3057 while next_offset < end_offset {
3059 _next_ordinal_to_read += 1;
3060 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3061 next_offset += envelope_size;
3062 }
3063
3064 Ok(())
3065 }
3066 }
3067
3068 impl TraceConfig {
3069 #[inline(always)]
3070 fn max_ordinal_present(&self) -> u64 {
3071 if let Some(_) = self.defer_transfer {
3072 return 7;
3073 }
3074 if let Some(_) = self.version {
3075 return 6;
3076 }
3077 if let Some(_) = self.provider_specs {
3078 return 5;
3079 }
3080 if let Some(_) = self.buffering_mode {
3081 return 4;
3082 }
3083 if let Some(_) = self.start_timeout_milliseconds {
3084 return 3;
3085 }
3086 if let Some(_) = self.buffer_size_megabytes_hint {
3087 return 2;
3088 }
3089 if let Some(_) = self.categories {
3090 return 1;
3091 }
3092 0
3093 }
3094 }
3095
3096 impl fidl::encoding::ValueTypeMarker for TraceConfig {
3097 type Borrowed<'a> = &'a Self;
3098 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3099 value
3100 }
3101 }
3102
3103 unsafe impl fidl::encoding::TypeMarker for TraceConfig {
3104 type Owned = Self;
3105
3106 #[inline(always)]
3107 fn inline_align(_context: fidl::encoding::Context) -> usize {
3108 8
3109 }
3110
3111 #[inline(always)]
3112 fn inline_size(_context: fidl::encoding::Context) -> usize {
3113 16
3114 }
3115 }
3116
3117 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TraceConfig, D>
3118 for &TraceConfig
3119 {
3120 unsafe fn encode(
3121 self,
3122 encoder: &mut fidl::encoding::Encoder<'_, D>,
3123 offset: usize,
3124 mut depth: fidl::encoding::Depth,
3125 ) -> fidl::Result<()> {
3126 encoder.debug_check_bounds::<TraceConfig>(offset);
3127 let max_ordinal: u64 = self.max_ordinal_present();
3129 encoder.write_num(max_ordinal, offset);
3130 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3131 if max_ordinal == 0 {
3133 return Ok(());
3134 }
3135 depth.increment()?;
3136 let envelope_size = 8;
3137 let bytes_len = max_ordinal as usize * envelope_size;
3138 #[allow(unused_variables)]
3139 let offset = encoder.out_of_line_offset(bytes_len);
3140 let mut _prev_end_offset: usize = 0;
3141 if 1 > max_ordinal {
3142 return Ok(());
3143 }
3144
3145 let cur_offset: usize = (1 - 1) * envelope_size;
3148
3149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3151
3152 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>, D>(
3157 self.categories.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000> as fidl::encoding::ValueTypeMarker>::borrow),
3158 encoder, offset + cur_offset, depth
3159 )?;
3160
3161 _prev_end_offset = cur_offset + envelope_size;
3162 if 2 > max_ordinal {
3163 return Ok(());
3164 }
3165
3166 let cur_offset: usize = (2 - 1) * envelope_size;
3169
3170 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3172
3173 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3178 self.buffer_size_megabytes_hint
3179 .as_ref()
3180 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3181 encoder,
3182 offset + cur_offset,
3183 depth,
3184 )?;
3185
3186 _prev_end_offset = cur_offset + envelope_size;
3187 if 3 > max_ordinal {
3188 return Ok(());
3189 }
3190
3191 let cur_offset: usize = (3 - 1) * envelope_size;
3194
3195 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3197
3198 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3203 self.start_timeout_milliseconds
3204 .as_ref()
3205 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3206 encoder,
3207 offset + cur_offset,
3208 depth,
3209 )?;
3210
3211 _prev_end_offset = cur_offset + envelope_size;
3212 if 4 > max_ordinal {
3213 return Ok(());
3214 }
3215
3216 let cur_offset: usize = (4 - 1) * envelope_size;
3219
3220 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3222
3223 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_tracing__common::BufferingMode, D>(
3228 self.buffering_mode.as_ref().map(<fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::ValueTypeMarker>::borrow),
3229 encoder, offset + cur_offset, depth
3230 )?;
3231
3232 _prev_end_offset = cur_offset + envelope_size;
3233 if 5 > max_ordinal {
3234 return Ok(());
3235 }
3236
3237 let cur_offset: usize = (5 - 1) * envelope_size;
3240
3241 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3243
3244 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProviderSpec, 100>, D>(
3249 self.provider_specs.as_ref().map(<fidl::encoding::Vector<ProviderSpec, 100> as fidl::encoding::ValueTypeMarker>::borrow),
3250 encoder, offset + cur_offset, depth
3251 )?;
3252
3253 _prev_end_offset = cur_offset + envelope_size;
3254 if 6 > max_ordinal {
3255 return Ok(());
3256 }
3257
3258 let cur_offset: usize = (6 - 1) * envelope_size;
3261
3262 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3264
3265 fidl::encoding::encode_in_envelope_optional::<FxtVersion, D>(
3270 self.version.as_ref().map(<FxtVersion as fidl::encoding::ValueTypeMarker>::borrow),
3271 encoder,
3272 offset + cur_offset,
3273 depth,
3274 )?;
3275
3276 _prev_end_offset = cur_offset + envelope_size;
3277 if 7 > max_ordinal {
3278 return Ok(());
3279 }
3280
3281 let cur_offset: usize = (7 - 1) * envelope_size;
3284
3285 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3287
3288 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3293 self.defer_transfer.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3294 encoder,
3295 offset + cur_offset,
3296 depth,
3297 )?;
3298
3299 _prev_end_offset = cur_offset + envelope_size;
3300
3301 Ok(())
3302 }
3303 }
3304
3305 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TraceConfig {
3306 #[inline(always)]
3307 fn new_empty() -> Self {
3308 Self::default()
3309 }
3310
3311 unsafe fn decode(
3312 &mut self,
3313 decoder: &mut fidl::encoding::Decoder<'_, D>,
3314 offset: usize,
3315 mut depth: fidl::encoding::Depth,
3316 ) -> fidl::Result<()> {
3317 decoder.debug_check_bounds::<Self>(offset);
3318 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3319 None => return Err(fidl::Error::NotNullable),
3320 Some(len) => len,
3321 };
3322 if len == 0 {
3324 return Ok(());
3325 };
3326 depth.increment()?;
3327 let envelope_size = 8;
3328 let bytes_len = len * envelope_size;
3329 let offset = decoder.out_of_line_offset(bytes_len)?;
3330 let mut _next_ordinal_to_read = 0;
3332 let mut next_offset = offset;
3333 let end_offset = offset + bytes_len;
3334 _next_ordinal_to_read += 1;
3335 if next_offset >= end_offset {
3336 return Ok(());
3337 }
3338
3339 while _next_ordinal_to_read < 1 {
3341 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3342 _next_ordinal_to_read += 1;
3343 next_offset += envelope_size;
3344 }
3345
3346 let next_out_of_line = decoder.next_out_of_line();
3347 let handles_before = decoder.remaining_handles();
3348 if let Some((inlined, num_bytes, num_handles)) =
3349 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3350 {
3351 let member_inline_size = <fidl::encoding::Vector<
3352 fidl::encoding::BoundedString<100>,
3353 5000,
3354 > as fidl::encoding::TypeMarker>::inline_size(
3355 decoder.context
3356 );
3357 if inlined != (member_inline_size <= 4) {
3358 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3359 }
3360 let inner_offset;
3361 let mut inner_depth = depth.clone();
3362 if inlined {
3363 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3364 inner_offset = next_offset;
3365 } else {
3366 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3367 inner_depth.increment()?;
3368 }
3369 let val_ref = self.categories.get_or_insert_with(|| {
3370 fidl::new_empty!(
3371 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
3372 D
3373 )
3374 });
3375 fidl::decode!(
3376 fidl::encoding::Vector<fidl::encoding::BoundedString<100>, 5000>,
3377 D,
3378 val_ref,
3379 decoder,
3380 inner_offset,
3381 inner_depth
3382 )?;
3383 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3384 {
3385 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3386 }
3387 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3388 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3389 }
3390 }
3391
3392 next_offset += envelope_size;
3393 _next_ordinal_to_read += 1;
3394 if next_offset >= end_offset {
3395 return Ok(());
3396 }
3397
3398 while _next_ordinal_to_read < 2 {
3400 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3401 _next_ordinal_to_read += 1;
3402 next_offset += envelope_size;
3403 }
3404
3405 let next_out_of_line = decoder.next_out_of_line();
3406 let handles_before = decoder.remaining_handles();
3407 if let Some((inlined, num_bytes, num_handles)) =
3408 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3409 {
3410 let member_inline_size =
3411 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3412 if inlined != (member_inline_size <= 4) {
3413 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3414 }
3415 let inner_offset;
3416 let mut inner_depth = depth.clone();
3417 if inlined {
3418 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3419 inner_offset = next_offset;
3420 } else {
3421 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3422 inner_depth.increment()?;
3423 }
3424 let val_ref =
3425 self.buffer_size_megabytes_hint.get_or_insert_with(|| fidl::new_empty!(u32, D));
3426 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3427 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3428 {
3429 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3430 }
3431 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3432 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3433 }
3434 }
3435
3436 next_offset += envelope_size;
3437 _next_ordinal_to_read += 1;
3438 if next_offset >= end_offset {
3439 return Ok(());
3440 }
3441
3442 while _next_ordinal_to_read < 3 {
3444 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3445 _next_ordinal_to_read += 1;
3446 next_offset += envelope_size;
3447 }
3448
3449 let next_out_of_line = decoder.next_out_of_line();
3450 let handles_before = decoder.remaining_handles();
3451 if let Some((inlined, num_bytes, num_handles)) =
3452 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3453 {
3454 let member_inline_size =
3455 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3456 if inlined != (member_inline_size <= 4) {
3457 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3458 }
3459 let inner_offset;
3460 let mut inner_depth = depth.clone();
3461 if inlined {
3462 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3463 inner_offset = next_offset;
3464 } else {
3465 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3466 inner_depth.increment()?;
3467 }
3468 let val_ref =
3469 self.start_timeout_milliseconds.get_or_insert_with(|| fidl::new_empty!(u64, D));
3470 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3471 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3472 {
3473 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3474 }
3475 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3476 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3477 }
3478 }
3479
3480 next_offset += envelope_size;
3481 _next_ordinal_to_read += 1;
3482 if next_offset >= end_offset {
3483 return Ok(());
3484 }
3485
3486 while _next_ordinal_to_read < 4 {
3488 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3489 _next_ordinal_to_read += 1;
3490 next_offset += envelope_size;
3491 }
3492
3493 let next_out_of_line = decoder.next_out_of_line();
3494 let handles_before = decoder.remaining_handles();
3495 if let Some((inlined, num_bytes, num_handles)) =
3496 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3497 {
3498 let member_inline_size = <fidl_fuchsia_tracing__common::BufferingMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3499 if inlined != (member_inline_size <= 4) {
3500 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3501 }
3502 let inner_offset;
3503 let mut inner_depth = depth.clone();
3504 if inlined {
3505 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3506 inner_offset = next_offset;
3507 } else {
3508 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3509 inner_depth.increment()?;
3510 }
3511 let val_ref = self.buffering_mode.get_or_insert_with(|| {
3512 fidl::new_empty!(fidl_fuchsia_tracing__common::BufferingMode, D)
3513 });
3514 fidl::decode!(
3515 fidl_fuchsia_tracing__common::BufferingMode,
3516 D,
3517 val_ref,
3518 decoder,
3519 inner_offset,
3520 inner_depth
3521 )?;
3522 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3523 {
3524 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3525 }
3526 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3527 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3528 }
3529 }
3530
3531 next_offset += envelope_size;
3532 _next_ordinal_to_read += 1;
3533 if next_offset >= end_offset {
3534 return Ok(());
3535 }
3536
3537 while _next_ordinal_to_read < 5 {
3539 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3540 _next_ordinal_to_read += 1;
3541 next_offset += envelope_size;
3542 }
3543
3544 let next_out_of_line = decoder.next_out_of_line();
3545 let handles_before = decoder.remaining_handles();
3546 if let Some((inlined, num_bytes, num_handles)) =
3547 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3548 {
3549 let member_inline_size = <fidl::encoding::Vector<ProviderSpec, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3550 if inlined != (member_inline_size <= 4) {
3551 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3552 }
3553 let inner_offset;
3554 let mut inner_depth = depth.clone();
3555 if inlined {
3556 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3557 inner_offset = next_offset;
3558 } else {
3559 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3560 inner_depth.increment()?;
3561 }
3562 let val_ref = self.provider_specs.get_or_insert_with(
3563 || fidl::new_empty!(fidl::encoding::Vector<ProviderSpec, 100>, D),
3564 );
3565 fidl::decode!(fidl::encoding::Vector<ProviderSpec, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
3566 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3567 {
3568 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3569 }
3570 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3571 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3572 }
3573 }
3574
3575 next_offset += envelope_size;
3576 _next_ordinal_to_read += 1;
3577 if next_offset >= end_offset {
3578 return Ok(());
3579 }
3580
3581 while _next_ordinal_to_read < 6 {
3583 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3584 _next_ordinal_to_read += 1;
3585 next_offset += envelope_size;
3586 }
3587
3588 let next_out_of_line = decoder.next_out_of_line();
3589 let handles_before = decoder.remaining_handles();
3590 if let Some((inlined, num_bytes, num_handles)) =
3591 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3592 {
3593 let member_inline_size =
3594 <FxtVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3595 if inlined != (member_inline_size <= 4) {
3596 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3597 }
3598 let inner_offset;
3599 let mut inner_depth = depth.clone();
3600 if inlined {
3601 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3602 inner_offset = next_offset;
3603 } else {
3604 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3605 inner_depth.increment()?;
3606 }
3607 let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(FxtVersion, D));
3608 fidl::decode!(FxtVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
3609 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3610 {
3611 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3612 }
3613 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3614 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3615 }
3616 }
3617
3618 next_offset += envelope_size;
3619 _next_ordinal_to_read += 1;
3620 if next_offset >= end_offset {
3621 return Ok(());
3622 }
3623
3624 while _next_ordinal_to_read < 7 {
3626 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3627 _next_ordinal_to_read += 1;
3628 next_offset += envelope_size;
3629 }
3630
3631 let next_out_of_line = decoder.next_out_of_line();
3632 let handles_before = decoder.remaining_handles();
3633 if let Some((inlined, num_bytes, num_handles)) =
3634 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3635 {
3636 let member_inline_size =
3637 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3638 if inlined != (member_inline_size <= 4) {
3639 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3640 }
3641 let inner_offset;
3642 let mut inner_depth = depth.clone();
3643 if inlined {
3644 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3645 inner_offset = next_offset;
3646 } else {
3647 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3648 inner_depth.increment()?;
3649 }
3650 let val_ref = self.defer_transfer.get_or_insert_with(|| fidl::new_empty!(bool, D));
3651 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3652 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3653 {
3654 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3655 }
3656 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3657 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3658 }
3659 }
3660
3661 next_offset += envelope_size;
3662
3663 while next_offset < end_offset {
3665 _next_ordinal_to_read += 1;
3666 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3667 next_offset += envelope_size;
3668 }
3669
3670 Ok(())
3671 }
3672 }
3673}