fidl_fuchsia_tracing_controller__common/
fidl_fuchsia_tracing_controller__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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
11/// aliases
12pub type AlertName = String;
13
14/// The maximum length of an alert name.
15pub const MAX_ALERT_NAME_LENGTH: u32 = 14;
16
17/// The maximum number of providers supported.
18pub const MAX_NUM_PROVIDERS: u32 = 100;
19
20/// The state of the tracing session.
21/// A "session" is everything between `Initialize` and `Terminate`.
22#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
23pub enum SessionState {
24    /// The tracing system is ready for a new session.
25    /// There can be only one session at a time.
26    Ready,
27    /// A new tracing session has been initialized.
28    Initialized,
29    /// Tracing is in the midst of starting.
30    Starting,
31    /// Tracing has started.
32    Started,
33    /// Tracing is in the midst of being stopped.
34    Stopping,
35    /// Tracing has fully stopped.
36    Stopped,
37    /// Tracing is in the midst of being terminated.
38    /// Once the system has completely terminated the session it goes back
39    /// to the READY state.
40    Terminating,
41    #[doc(hidden)]
42    __SourceBreaking { unknown_ordinal: u32 },
43}
44
45/// Pattern that matches an unknown `SessionState` member.
46#[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/// Error codes from Start operations.
111#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112pub enum StartError {
113    /// Tracing hasn't been initialized, not ready to start.
114    NotInitialized,
115    /// Tracing has already been started.
116    AlreadyStarted,
117    /// Tracing is currently being stopped.
118    Stopping,
119    /// Tracing is currently being terminated.
120    Terminating,
121    #[doc(hidden)]
122    __SourceBreaking { unknown_ordinal: u32 },
123}
124
125/// Pattern that matches an unknown `StartError` member.
126#[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/// Error codes from Stop operations.
182#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
183pub enum StopError {
184    /// Trace controller is unavailable. Nothing to stop.
185    NotInitialized,
186    /// Tracing has not started or is currently stoppped.
187    NotStarted,
188    /// Tracing aborted due to error.
189    Aborted,
190    #[doc(hidden)]
191    __SourceBreaking { unknown_ordinal: u32 },
192}
193
194/// Pattern that matches an unknown `StopError` member.
195#[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/// Version of trace record format.
276///
277/// Default to the latest available version, which is currently 0.1.
278///
279/// More information about the format of trace records can be found here:
280/// https://fuchsia.dev/fuchsia-src/reference/tracing/trace-format
281#[derive(Clone, Debug, Default, PartialEq)]
282pub struct FxtVersion {
283    /// Defaults to 0.
284    pub major: Option<u32>,
285    /// Defaults to 1
286    pub minor: Option<u32>,
287    #[doc(hidden)]
288    pub __source_breaking: fidl::marker::SourceBreaking,
289}
290
291impl fidl::Persistable for FxtVersion {}
292
293/// Result of `GetProviders`.
294#[derive(Clone, Debug, Default, PartialEq)]
295pub struct ProviderInfo {
296    /// The provider's ID, assigned by trace-manager.
297    pub id: Option<u32>,
298    /// The provider's pid.
299    pub pid: Option<u64>,
300    /// The name of the provider.
301    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/// Statistics data per provider collected over the course of the tracing session
320#[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/// Additional options to control trace data collection.
336#[derive(Clone, Debug, Default, PartialEq)]
337pub struct StartOptions {
338    /// Whether and how to clear the buffer when starting data collection.
339    /// This allows, for example, multiple Start/Stop trace runs to be
340    /// collected in the same buffer.
341    ///
342    /// If the preceding `Stop()` request had `save_after_stopped=true`
343    /// then this value is overridden to CLEAR_ENTIRE_BUFFER to avoid
344    /// duplicate data being saved.
345    pub buffer_disposition: Option<fidl_fuchsia_tracing__common::BufferDisposition>,
346    /// The trace categories to add to the initial set provided in
347    /// `TraceConfig`. If the combined number of categories goes over the
348    /// limit then the extra categories past the limit are discarded.
349    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/// Additional options to control stopping of a trace.
357#[derive(Clone, Debug, Default, PartialEq)]
358pub struct StopOptions {
359    /// If true then write all collected data after tracing has stopped.
360    /// This is useful in situations where one wants to clear the buffer
361    /// before starting the next trace, without having to first terminate the
362    /// trace and start a new one.
363    pub write_results: Option<bool>,
364    #[doc(hidden)]
365    pub __source_breaking: fidl::marker::SourceBreaking,
366}
367
368impl fidl::Persistable for StopOptions {}
369
370/// Result of a terminate request.
371#[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/// Provides options for the trace.
381#[derive(Clone, Debug, Default, PartialEq)]
382pub struct TraceConfig {
383    /// The trace categories to record, or an empty array for all.
384    pub categories: Option<Vec<String>>,
385    /// Suggested size of trace buffer which each provider should receive.
386    pub buffer_size_megabytes_hint: Option<u32>,
387    /// Acknowledge start request after at most `start_timeout_milliseconds`.
388    pub start_timeout_milliseconds: Option<u64>,
389    pub buffering_mode: Option<fidl_fuchsia_tracing__common::BufferingMode>,
390    /// Overrides for particular providers.
391    pub provider_specs: Option<Vec<ProviderSpec>>,
392    /// Maximum trace format version supported byt the client.
393    /// If not set, this defaults to the latest available trace format version.
394    pub version: Option<FxtVersion>,
395    /// When true, the session will buffer the trace within the
396    /// fuchsia.tracing.controller server and only send the trace over the
397    /// output socket to the client once the trace completes.
398    ///
399    /// It is recommended that defering the trace transfer be set to true when
400    /// using streaming mode and the fuchsia.tracing.controller client is across
401    /// the host-device boundary, such as with ffx. In this, or other cases
402    /// where sending the trace data could cause exess cpu overhead, the disk
403    /// writing cost is preferrable to the cost of sending to the client.
404    ///
405    /// NOTE: defer_transfer only has effect during BufferingMode.STREAMING as
406    /// other modes don't otherwise send trace data to the client during a
407    /// trace.
408    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            // Delegate to tuple encoding.
663            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            // Zero out padding regions. There's no need to apply masks
688            // because the unmasked parts will be overwritten by fields.
689            // Write the fields.
690            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            // Verify that padding bytes are zero.
714            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            // Delegate to tuple encoding.
753            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            // Zero out padding regions. There's no need to apply masks
775            // because the unmasked parts will be overwritten by fields.
776            // Write the fields.
777            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            // Verify that padding bytes are zero.
799            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            // Delegate to tuple encoding.
838            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            // Zero out padding regions. There's no need to apply masks
858            // because the unmasked parts will be overwritten by fields.
859            // Write the fields.
860            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            // Verify that padding bytes are zero.
882            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            // Delegate to tuple encoding.
920            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            // Zero out padding regions. There's no need to apply masks
944            // because the unmasked parts will be overwritten by fields.
945            // Write the fields.
946            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            // Verify that padding bytes are zero.
968            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            // Vector header
1025            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1029            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1043            // are envelope_size bytes.
1044            let cur_offset: usize = (1 - 1) * envelope_size;
1045
1046            // Zero reserved fields.
1047            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1048
1049            // Safety:
1050            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1051            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1052            //   envelope_size bytes, there is always sufficient room.
1053            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1066            // are envelope_size bytes.
1067            let cur_offset: usize = (2 - 1) * envelope_size;
1068
1069            // Zero reserved fields.
1070            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1071
1072            // Safety:
1073            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1074            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1075            //   envelope_size bytes, there is always sufficient room.
1076            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1107            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            // Decode the envelope for each type.
1115            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            // Decode unknown envelopes for gaps in ordinals.
1124            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            // Decode unknown envelopes for gaps in ordinals.
1167            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            // Decode the remaining unknown envelopes.
1206            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            // Vector header
1264            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1268            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1282            // are envelope_size bytes.
1283            let cur_offset: usize = (1 - 1) * envelope_size;
1284
1285            // Zero reserved fields.
1286            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1287
1288            // Safety:
1289            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1290            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1291            //   envelope_size bytes, there is always sufficient room.
1292            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1305            // are envelope_size bytes.
1306            let cur_offset: usize = (2 - 1) * envelope_size;
1307
1308            // Zero reserved fields.
1309            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1310
1311            // Safety:
1312            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1313            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1314            //   envelope_size bytes, there is always sufficient room.
1315            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1328            // are envelope_size bytes.
1329            let cur_offset: usize = (3 - 1) * envelope_size;
1330
1331            // Zero reserved fields.
1332            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1333
1334            // Safety:
1335            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1336            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1337            //   envelope_size bytes, there is always sufficient room.
1338            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1371            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            // Decode the envelope for each type.
1379            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            // Decode unknown envelopes for gaps in ordinals.
1388            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            // Decode unknown envelopes for gaps in ordinals.
1431            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            // Decode unknown envelopes for gaps in ordinals.
1474            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            // Decode the remaining unknown envelopes.
1524            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            // Vector header
1582            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1586            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1600            // are envelope_size bytes.
1601            let cur_offset: usize = (1 - 1) * envelope_size;
1602
1603            // Zero reserved fields.
1604            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1605
1606            // Safety:
1607            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1608            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1609            //   envelope_size bytes, there is always sufficient room.
1610            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1625            // are envelope_size bytes.
1626            let cur_offset: usize = (2 - 1) * envelope_size;
1627
1628            // Zero reserved fields.
1629            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1630
1631            // Safety:
1632            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1633            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1634            //   envelope_size bytes, there is always sufficient room.
1635            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1650            // are envelope_size bytes.
1651            let cur_offset: usize = (3 - 1) * envelope_size;
1652
1653            // Zero reserved fields.
1654            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1655
1656            // Safety:
1657            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1658            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1659            //   envelope_size bytes, there is always sufficient room.
1660            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1689            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            // Decode the envelope for each type.
1697            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            // Decode unknown envelopes for gaps in ordinals.
1706            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            // Decode unknown envelopes for gaps in ordinals.
1760            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            // Decode unknown envelopes for gaps in ordinals.
1804            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            // Decode the remaining unknown envelopes.
1859            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            // Vector header
1929            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1933            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1947            // are envelope_size bytes.
1948            let cur_offset: usize = (1 - 1) * envelope_size;
1949
1950            // Zero reserved fields.
1951            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1952
1953            // Safety:
1954            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1955            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1956            //   envelope_size bytes, there is always sufficient room.
1957            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1972            // are envelope_size bytes.
1973            let cur_offset: usize = (2 - 1) * envelope_size;
1974
1975            // Zero reserved fields.
1976            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1977
1978            // Safety:
1979            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1980            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1981            //   envelope_size bytes, there is always sufficient room.
1982            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1995            // are envelope_size bytes.
1996            let cur_offset: usize = (3 - 1) * envelope_size;
1997
1998            // Zero reserved fields.
1999            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2000
2001            // Safety:
2002            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2003            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2004            //   envelope_size bytes, there is always sufficient room.
2005            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2016            // are envelope_size bytes.
2017            let cur_offset: usize = (4 - 1) * envelope_size;
2018
2019            // Zero reserved fields.
2020            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2021
2022            // Safety:
2023            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2024            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2025            //   envelope_size bytes, there is always sufficient room.
2026            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2041            // are envelope_size bytes.
2042            let cur_offset: usize = (5 - 1) * envelope_size;
2043
2044            // Zero reserved fields.
2045            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2046
2047            // Safety:
2048            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2049            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2050            //   envelope_size bytes, there is always sufficient room.
2051            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2064            // are envelope_size bytes.
2065            let cur_offset: usize = (6 - 1) * envelope_size;
2066
2067            // Zero reserved fields.
2068            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2069
2070            // Safety:
2071            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2072            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2073            //   envelope_size bytes, there is always sufficient room.
2074            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2089            // are envelope_size bytes.
2090            let cur_offset: usize = (7 - 1) * envelope_size;
2091
2092            // Zero reserved fields.
2093            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2094
2095            // Safety:
2096            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2097            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2098            //   envelope_size bytes, there is always sufficient room.
2099            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2132            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            // Decode the envelope for each type.
2140            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            // Decode unknown envelopes for gaps in ordinals.
2149            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            // Decode unknown envelopes for gaps in ordinals.
2203            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            // Decode unknown envelopes for gaps in ordinals.
2246            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            // Decode unknown envelopes for gaps in ordinals.
2297            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            // Decode unknown envelopes for gaps in ordinals.
2341            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            // Decode unknown envelopes for gaps in ordinals.
2384            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            // Decode unknown envelopes for gaps in ordinals.
2429            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            // Decode the remaining unknown envelopes.
2469            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            // Vector header
2524            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2528            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2542            // are envelope_size bytes.
2543            let cur_offset: usize = (1 - 1) * envelope_size;
2544
2545            // Zero reserved fields.
2546            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2547
2548            // Safety:
2549            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2550            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2551            //   envelope_size bytes, there is always sufficient room.
2552            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2563            // are envelope_size bytes.
2564            let cur_offset: usize = (2 - 1) * envelope_size;
2565
2566            // Zero reserved fields.
2567            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2568
2569            // Safety:
2570            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2571            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2572            //   envelope_size bytes, there is always sufficient room.
2573            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2602            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            // Decode the envelope for each type.
2610            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            // Decode unknown envelopes for gaps in ordinals.
2619            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            // Decode unknown envelopes for gaps in ordinals.
2670            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            // Decode the remaining unknown envelopes.
2725            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            // Vector header
2777            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2781            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2795            // are envelope_size bytes.
2796            let cur_offset: usize = (1 - 1) * envelope_size;
2797
2798            // Zero reserved fields.
2799            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2800
2801            // Safety:
2802            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2803            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2804            //   envelope_size bytes, there is always sufficient room.
2805            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2836            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            // Decode the envelope for each type.
2844            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            // Decode unknown envelopes for gaps in ordinals.
2853            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            // Decode the remaining unknown envelopes.
2892            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            // Vector header
2944            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2948            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2962            // are envelope_size bytes.
2963            let cur_offset: usize = (1 - 1) * envelope_size;
2964
2965            // Zero reserved fields.
2966            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2967
2968            // Safety:
2969            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2970            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2971            //   envelope_size bytes, there is always sufficient room.
2972            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3001            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            // Decode the envelope for each type.
3009            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            // Decode unknown envelopes for gaps in ordinals.
3018            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            // Decode the remaining unknown envelopes.
3058            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            // Vector header
3128            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            // Calling encoder.out_of_line_offset(0) is not allowed.
3132            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3146            // are envelope_size bytes.
3147            let cur_offset: usize = (1 - 1) * envelope_size;
3148
3149            // Zero reserved fields.
3150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3151
3152            // Safety:
3153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3155            //   envelope_size bytes, there is always sufficient room.
3156            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3167            // are envelope_size bytes.
3168            let cur_offset: usize = (2 - 1) * envelope_size;
3169
3170            // Zero reserved fields.
3171            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3172
3173            // Safety:
3174            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3175            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3176            //   envelope_size bytes, there is always sufficient room.
3177            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3192            // are envelope_size bytes.
3193            let cur_offset: usize = (3 - 1) * envelope_size;
3194
3195            // Zero reserved fields.
3196            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3197
3198            // Safety:
3199            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3200            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3201            //   envelope_size bytes, there is always sufficient room.
3202            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3217            // are envelope_size bytes.
3218            let cur_offset: usize = (4 - 1) * envelope_size;
3219
3220            // Zero reserved fields.
3221            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3222
3223            // Safety:
3224            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3225            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3226            //   envelope_size bytes, there is always sufficient room.
3227            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3238            // are envelope_size bytes.
3239            let cur_offset: usize = (5 - 1) * envelope_size;
3240
3241            // Zero reserved fields.
3242            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3243
3244            // Safety:
3245            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3246            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3247            //   envelope_size bytes, there is always sufficient room.
3248            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3259            // are envelope_size bytes.
3260            let cur_offset: usize = (6 - 1) * envelope_size;
3261
3262            // Zero reserved fields.
3263            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3264
3265            // Safety:
3266            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3267            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3268            //   envelope_size bytes, there is always sufficient room.
3269            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3282            // are envelope_size bytes.
3283            let cur_offset: usize = (7 - 1) * envelope_size;
3284
3285            // Zero reserved fields.
3286            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3287
3288            // Safety:
3289            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3290            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3291            //   envelope_size bytes, there is always sufficient room.
3292            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            // Calling decoder.out_of_line_offset(0) is not allowed.
3323            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            // Decode the envelope for each type.
3331            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            // Decode unknown envelopes for gaps in ordinals.
3340            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            // Decode unknown envelopes for gaps in ordinals.
3399            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            // Decode unknown envelopes for gaps in ordinals.
3443            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            // Decode unknown envelopes for gaps in ordinals.
3487            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            // Decode unknown envelopes for gaps in ordinals.
3538            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            // Decode unknown envelopes for gaps in ordinals.
3582            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            // Decode unknown envelopes for gaps in ordinals.
3625            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            // Decode the remaining unknown envelopes.
3664            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}