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