fidl_fuchsia_validate_logs_common/

fidl_fuchsia_validate_logs_common.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// Maximum number of arguments that can be encoded per record, as specified by the tracing format:
///
/// https://fuchsia.dev/fuchsia-src/development/tracing/trace-format#arguments
pub const MAX_ARGS: u32 = 15;

/// A small(ish) limit on the length of argument names is used because argument names are expected
/// to be used repeatedly, many times.
pub const MAX_ARG_NAME_LENGTH: u32 = 256;

/// The maximum string length which we can encode into the tracing format.
pub const MAX_TEXT_ARG_LENGTH: u32 = 32768;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum PuppetError {
    UnsupportedRecord = 1,
}

impl PuppetError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::UnsupportedRecord),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// A named key-value pair in the diagnostic record.
#[derive(Clone, Debug, PartialEq)]
pub struct Argument {
    /// The name of the argument.
    pub name: String,
    /// The value of the argument.
    pub value: Value,
}

impl fidl::Persistable for Argument {}

#[derive(Clone, Debug, PartialEq)]
pub struct EncodingPuppetEncodeRequest {
    pub record: Record,
}

impl fidl::Persistable for EncodingPuppetEncodeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct LogSinkPuppetEmitLogRequest {
    pub spec: RecordSpec,
}

impl fidl::Persistable for LogSinkPuppetEmitLogRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LogSinkPuppetGetInfoResponse {
    pub info: PuppetInfo,
}

impl fidl::Persistable for LogSinkPuppetGetInfoResponse {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PuppetInfo {
    pub tag: Option<String>,
    pub pid: u64,
    pub tid: u64,
}

impl fidl::Persistable for PuppetInfo {}

/// A record in the diagnostic stream.
#[derive(Clone, Debug, PartialEq)]
pub struct Record {
    /// The time at which the record was generated measured in nanoseconds since
    /// boot.
    pub timestamp: fidl::BootInstant,
    /// Severity of the record.
    pub severity: fidl_fuchsia_diagnostics_types::Severity,
    /// The key-value pairs which make up this record.
    pub arguments: Vec<Argument>,
}

impl fidl::Persistable for Record {}

#[derive(Clone, Debug, PartialEq)]
pub struct RecordSpec {
    pub file: String,
    pub line: u32,
    pub record: Record,
}

impl fidl::Persistable for RecordSpec {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TestFailure {
    /// The name of the test case.
    pub test_name: String,
    /// The reason the test case failed.
    pub reason: String,
}

impl fidl::Persistable for TestFailure {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TestSuccess {
    /// The name of the test case.
    pub test_name: String,
}

impl fidl::Persistable for TestSuccess {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ValidateResult {
    /// Set when the test case passed.
    Success(TestSuccess),
    /// Set when the test case failed.
    Failure(TestFailure),
}

impl ValidateResult {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::Failure(_) => 2,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Persistable for ValidateResult {}

/// An argument value which can be one of several types.
#[derive(Clone, Debug)]
pub enum Value {
    /// A signed integral argument.
    SignedInt(i64),
    /// An unsigned integral argument.
    UnsignedInt(u64),
    /// A double-precision floating-point argument.
    Floating(f64),
    /// A UTF8 text argument.
    Text(String),
    /// A boolean argument.
    Boolean(bool),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `Value` member.
#[macro_export]
macro_rules! ValueUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for Value {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::SignedInt(x), Self::SignedInt(y)) => *x == *y,
            (Self::UnsignedInt(x), Self::UnsignedInt(y)) => *x == *y,
            (Self::Floating(x), Self::Floating(y)) => *x == *y,
            (Self::Text(x), Self::Text(y)) => *x == *y,
            (Self::Boolean(x), Self::Boolean(y)) => *x == *y,
            _ => false,
        }
    }
}

impl Value {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::SignedInt(_) => 1,
            Self::UnsignedInt(_) => 2,
            Self::Floating(_) => 3,
            Self::Text(_) => 4,
            Self::Boolean(_) => 5,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Persistable for Value {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for PuppetError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for PuppetError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PuppetError {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PuppetError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::UnsupportedRecord
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Argument {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Argument {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Argument, D> for &Argument {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Argument>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Argument, D>::encode(
                (
                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <Value as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
            T1: fidl::encoding::Encode<Value, D>,
        > fidl::encoding::Encode<Argument, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Argument>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Argument {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
                value: fidl::new_empty!(Value, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<256>,
                D,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(Value, D, &mut self.value, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for EncodingPuppetEncodeRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EncodingPuppetEncodeRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<EncodingPuppetEncodeRequest, D> for &EncodingPuppetEncodeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EncodingPuppetEncodeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EncodingPuppetEncodeRequest, D>::encode(
                (<Record as fidl::encoding::ValueTypeMarker>::borrow(&self.record),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Record, D>>
        fidl::encoding::Encode<EncodingPuppetEncodeRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EncodingPuppetEncodeRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for EncodingPuppetEncodeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { record: fidl::new_empty!(Record, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Record, D, &mut self.record, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for LogSinkPuppetEmitLogRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LogSinkPuppetEmitLogRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            56
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<LogSinkPuppetEmitLogRequest, D> for &LogSinkPuppetEmitLogRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogSinkPuppetEmitLogRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LogSinkPuppetEmitLogRequest, D>::encode(
                (<RecordSpec as fidl::encoding::ValueTypeMarker>::borrow(&self.spec),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RecordSpec, D>>
        fidl::encoding::Encode<LogSinkPuppetEmitLogRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogSinkPuppetEmitLogRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for LogSinkPuppetEmitLogRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { spec: fidl::new_empty!(RecordSpec, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(RecordSpec, D, &mut self.spec, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for LogSinkPuppetGetInfoResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LogSinkPuppetGetInfoResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<LogSinkPuppetGetInfoResponse, D> for &LogSinkPuppetGetInfoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogSinkPuppetGetInfoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LogSinkPuppetGetInfoResponse, D>::encode(
                (<PuppetInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PuppetInfo, D>>
        fidl::encoding::Encode<LogSinkPuppetGetInfoResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogSinkPuppetGetInfoResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for LogSinkPuppetGetInfoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { info: fidl::new_empty!(PuppetInfo, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(PuppetInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for PuppetInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PuppetInfo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PuppetInfo, D>
        for &PuppetInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PuppetInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PuppetInfo, D>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.tag),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.pid),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.tid),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::UnboundedString>, D>,
            T1: fidl::encoding::Encode<u64, D>,
            T2: fidl::encoding::Encode<u64, D>,
        > fidl::encoding::Encode<PuppetInfo, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PuppetInfo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PuppetInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                tag: fidl::new_empty!(fidl::encoding::Optional<fidl::encoding::UnboundedString>, D),
                pid: fidl::new_empty!(u64, D),
                tid: fidl::new_empty!(u64, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                D,
                &mut self.tag,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u64, D, &mut self.pid, decoder, offset + 16, _depth)?;
            fidl::decode!(u64, D, &mut self.tid, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Record {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Record {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Record, D> for &Record {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Record>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Record, D>::encode(
                (
                    <fidl::BootInstant as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp),
                    <fidl_fuchsia_diagnostics_types::Severity as fidl::encoding::ValueTypeMarker>::borrow(&self.severity),
                    <fidl::encoding::Vector<Argument, 15> as fidl::encoding::ValueTypeMarker>::borrow(&self.arguments),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::BootInstant, D>,
            T1: fidl::encoding::Encode<fidl_fuchsia_diagnostics_types::Severity, D>,
            T2: fidl::encoding::Encode<fidl::encoding::Vector<Argument, 15>, D>,
        > fidl::encoding::Encode<Record, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Record>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Record {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                timestamp: fidl::new_empty!(fidl::BootInstant, D),
                severity: fidl::new_empty!(fidl_fuchsia_diagnostics_types::Severity, D),
                arguments: fidl::new_empty!(fidl::encoding::Vector<Argument, 15>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::BootInstant, D, &mut self.timestamp, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_diagnostics_types::Severity,
                D,
                &mut self.severity,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<Argument, 15>, D, &mut self.arguments, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for RecordSpec {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RecordSpec {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            56
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RecordSpec, D>
        for &RecordSpec
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RecordSpec>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RecordSpec, D>::encode(
                (
                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.file,
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.line),
                    <Record as fidl::encoding::ValueTypeMarker>::borrow(&self.record),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
            T1: fidl::encoding::Encode<u32, D>,
            T2: fidl::encoding::Encode<Record, D>,
        > fidl::encoding::Encode<RecordSpec, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RecordSpec>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RecordSpec {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                file: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
                line: fidl::new_empty!(u32, D),
                record: fidl::new_empty!(Record, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<256>,
                D,
                &mut self.file,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.line, decoder, offset + 16, _depth)?;
            fidl::decode!(Record, D, &mut self.record, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for TestFailure {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestFailure {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TestFailure, D>
        for &TestFailure
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestFailure>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TestFailure, D>::encode(
                (
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.test_name,
                    ),
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.reason,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
        > fidl::encoding::Encode<TestFailure, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestFailure>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TestFailure {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
                reason: fidl::new_empty!(fidl::encoding::UnboundedString, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedString,
                D,
                &mut self.test_name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedString,
                D,
                &mut self.reason,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for TestSuccess {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestSuccess {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TestSuccess, D>
        for &TestSuccess
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestSuccess>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TestSuccess, D>::encode(
                (<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.test_name,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
        > fidl::encoding::Encode<TestSuccess, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestSuccess>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TestSuccess {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { test_name: fidl::new_empty!(fidl::encoding::UnboundedString, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedString,
                D,
                &mut self.test_name,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ValidateResult {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ValidateResult {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ValidateResult, D>
        for &ValidateResult
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ValidateResult>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ValidateResult::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<TestSuccess, D>(
                        <TestSuccess as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ValidateResult::Failure(ref val) => {
                    fidl::encoding::encode_in_envelope::<TestFailure, D>(
                        <TestFailure as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ValidateResult {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Success(fidl::new_empty!(TestSuccess, D))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <TestSuccess as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <TestFailure as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ValidateResult::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ValidateResult::Success(fidl::new_empty!(TestSuccess, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ValidateResult::Success(ref mut val) = self {
                        fidl::decode!(TestSuccess, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ValidateResult::Failure(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ValidateResult::Failure(fidl::new_empty!(TestFailure, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ValidateResult::Failure(ref mut val) = self {
                        fidl::decode!(TestFailure, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Value {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Value {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Value, D> for &Value {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Value>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            Value::SignedInt(ref val) => {
                fidl::encoding::encode_in_envelope::<i64, D>(
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Value::UnsignedInt(ref val) => {
                fidl::encoding::encode_in_envelope::<u64, D>(
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Value::Floating(ref val) => {
                fidl::encoding::encode_in_envelope::<f64, D>(
                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Value::Text(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<32768>, D>(
                    <fidl::encoding::BoundedString<32768> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Value::Boolean(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Value::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Value {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            3 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            4 => <fidl::encoding::BoundedString<32768> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            5 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Value::SignedInt(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Value::SignedInt(fidl::new_empty!(i64, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Value::SignedInt(ref mut val) = self {
                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Value::UnsignedInt(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Value::UnsignedInt(fidl::new_empty!(u64, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Value::UnsignedInt(ref mut val) = self {
                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Value::Floating(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Value::Floating(fidl::new_empty!(f64, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Value::Floating(ref mut val) = self {
                        fidl::decode!(f64, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Value::Text(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            Value::Text(fidl::new_empty!(fidl::encoding::BoundedString<32768>, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Value::Text(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<32768>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Value::Boolean(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Value::Boolean(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Value::Boolean(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = Value::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}