fidl_fuchsia_hardware_trippoint__common/

fidl_fuchsia_hardware_trippoint__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;

/// Denotes the type of a particular trip point.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum TripPointType {
    /// This type of trip point is denoted by a critical temperature at which
    /// the trip point triggers and a direction. Once the trip point fires it is
    /// no longer configured and must be rearmed before it can fire again.
    OneshotTempAbove,
    OneshotTempBelow,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u16,
    },
}

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

impl TripPointType {
    #[inline]
    pub fn from_primitive(prim: u16) -> Option<Self> {
        match prim {
            1 => Some(Self::OneshotTempAbove),
            2 => Some(Self::OneshotTempBelow),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u16) -> Self {
        match prim {
            1 => Self::OneshotTempAbove,
            2 => Self::OneshotTempBelow,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u16 {
        match self {
            Self::OneshotTempAbove => 1,
            Self::OneshotTempBelow => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClearedTripPoint;

impl fidl::Persistable for ClearedTripPoint {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DebugTripRequest {
    pub index: u32,
}

impl fidl::Persistable for DebugTripRequest {}

/// See the comment in TripPointType for more information.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct OneshotTempAboveTripPoint {
    /// The temperature at which the trip point activates.
    pub critical_temperature_celsius: f32,
}

impl fidl::Persistable for OneshotTempAboveTripPoint {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct OneshotTempBelowTripPoint {
    /// The temperature at which the trip point activates.
    pub critical_temperature_celsius: f32,
}

impl fidl::Persistable for OneshotTempBelowTripPoint {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct TripDeviceMetadata {
    /// Critical temperature in degrees Celsius.
    pub critical_temp_celsius: f32,
}

impl fidl::Persistable for TripDeviceMetadata {}
impl fidl::Serializable for TripDeviceMetadata {
    const SERIALIZABLE_NAME: &'static str = "fuchsia.hardware.trippoint.TripDeviceMetadata";
}

#[derive(Clone, Debug, PartialEq)]
pub struct TripPointDescriptor {
    /// The type of this trip point as defined by the hardware.
    pub type_: TripPointType,
    /// The index of the trip point being configured. Trip points are always
    /// numbered 0 to N-1 where N is the number of available hardware trip
    /// points.
    pub index: u32,
    /// If unset the type of this configuration will be `cleared_trip_point`
    /// otherwise it will be a TripPointValue that corresponds to the type
    /// defined by `type`.
    pub configuration: TripPointValue,
}

impl fidl::Persistable for TripPointDescriptor {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct TripPointResult {
    /// The temperature measured by the sensor. NaN if a measurement was not
    /// performed.
    pub measured_temperature_celsius: f32,
    /// The index of the trip point that was configured.
    pub index: u32,
}

impl fidl::Persistable for TripPointResult {}

#[derive(Clone, Debug, PartialEq)]
pub struct TripPointSetTripPointsRequest {
    /// The type of this configuration must correspond to the type of the
    /// trip point returned by GetTripPointDescriptors. The type of the
    /// configuration field must either be `ClearedTripPoint` if the trip
    /// point is being cleared or it must correspond to the type defined by
    /// `GetTripPointDescriptors`. If these arguments do not match
    /// `ZX_ERR_INVALID_ARGS` is returned.
    /// If the index field is larger than the number of descriptors returned
    /// by GetTripPointDescriptors then `ZX_ERR_OUT_OF_RANGE` is returned.
    /// Configuring a trip point that is already configured will cause the
    /// previous configuration to be overwritten and any pending trip
    /// interrupts to be cleared.
    pub descriptors: Vec<TripPointDescriptor>,
}

impl fidl::Persistable for TripPointSetTripPointsRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct TripPointGetTripPointDescriptorsResponse {
    pub descriptors: Vec<TripPointDescriptor>,
}

impl fidl::Persistable for TripPointGetTripPointDescriptorsResponse {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct TripPointWaitForAnyTripPointResponse {
    pub result: TripPointResult,
}

impl fidl::Persistable for TripPointWaitForAnyTripPointResponse {}

/// A union that defines all the possible types of trip points.
#[derive(Clone, Debug)]
pub enum TripPointValue {
    /// This is a special reserved type of trip point that can be used by
    /// clients to clear previously configured trip point.
    ClearedTripPoint(ClearedTripPoint),
    OneshotTempAboveTripPoint(OneshotTempAboveTripPoint),
    OneshotTempBelowTripPoint(OneshotTempBelowTripPoint),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for TripPointValue {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::ClearedTripPoint(x), Self::ClearedTripPoint(y)) => *x == *y,
            (Self::OneshotTempAboveTripPoint(x), Self::OneshotTempAboveTripPoint(y)) => *x == *y,
            (Self::OneshotTempBelowTripPoint(x), Self::OneshotTempBelowTripPoint(y)) => *x == *y,
            _ => false,
        }
    }
}

impl TripPointValue {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::ClearedTripPoint(_) => 1,
            Self::OneshotTempAboveTripPoint(_) => 2,
            Self::OneshotTempBelowTripPoint(_) => 3,
            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 TripPointValue {}

pub mod debug_ordinals {
    pub const TRIP: u64 = 0x2785e550debdf5a;
}

pub mod trip_point_ordinals {
    pub const GET_TRIP_POINT_DESCRIPTORS: u64 = 0xbbc73e208bf4875;
    pub const SET_TRIP_POINTS: u64 = 0x8e768ac1e677593;
    pub const WAIT_FOR_ANY_TRIP_POINT: u64 = 0x66b959b54d27ce45;
}

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

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for TripPointType {
        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 TripPointType {
        #[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 TripPointType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[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::<u16>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

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

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

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

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

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

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

        #[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);
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DebugTripRequest, D>
        for &DebugTripRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DebugTripRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DebugTripRequest)
                    .write_unaligned((self as *const DebugTripRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
        fidl::encoding::Encode<DebugTripRequest, 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::<DebugTripRequest>(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 DebugTripRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { index: fidl::new_empty!(u32, 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);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<OneshotTempAboveTripPoint, D> for &OneshotTempAboveTripPoint
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OneshotTempAboveTripPoint>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<OneshotTempAboveTripPoint, D>::encode(
                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.critical_temperature_celsius,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
        fidl::encoding::Encode<OneshotTempAboveTripPoint, 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::<OneshotTempAboveTripPoint>(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 OneshotTempAboveTripPoint
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { critical_temperature_celsius: fidl::new_empty!(f32, 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!(
                f32,
                D,
                &mut self.critical_temperature_celsius,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<OneshotTempBelowTripPoint, D> for &OneshotTempBelowTripPoint
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OneshotTempBelowTripPoint>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<OneshotTempBelowTripPoint, D>::encode(
                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.critical_temperature_celsius,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
        fidl::encoding::Encode<OneshotTempBelowTripPoint, 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::<OneshotTempBelowTripPoint>(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 OneshotTempBelowTripPoint
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { critical_temperature_celsius: fidl::new_empty!(f32, 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!(
                f32,
                D,
                &mut self.critical_temperature_celsius,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TripDeviceMetadata, D>
        for &TripDeviceMetadata
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripDeviceMetadata>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TripDeviceMetadata, D>::encode(
                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.critical_temp_celsius),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
        fidl::encoding::Encode<TripDeviceMetadata, 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::<TripDeviceMetadata>(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 TripDeviceMetadata {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { critical_temp_celsius: fidl::new_empty!(f32, 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!(f32, D, &mut self.critical_temp_celsius, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TripPointDescriptor, D>
        for &TripPointDescriptor
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripPointDescriptor>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TripPointDescriptor, D>::encode(
                (
                    <TripPointType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
                    <TripPointValue as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.configuration,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TripPointType, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<TripPointValue, D>,
    > fidl::encoding::Encode<TripPointDescriptor, 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::<TripPointDescriptor>(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(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TripPointDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                type_: fidl::new_empty!(TripPointType, D),
                index: fidl::new_empty!(u32, D),
                configuration: fidl::new_empty!(TripPointValue, 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(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(TripPointType, D, &mut self.type_, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, D, &mut self.index, decoder, offset + 4, _depth)?;
            fidl::decode!(TripPointValue, D, &mut self.configuration, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TripPointResult, D>
        for &TripPointResult
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripPointResult>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TripPointResult, D>::encode(
                (
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.measured_temperature_celsius,
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<f32, D>,
        T1: fidl::encoding::Encode<u32, D>,
    > fidl::encoding::Encode<TripPointResult, 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::<TripPointResult>(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 + 4, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TripPointResult {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                measured_temperature_celsius: fidl::new_empty!(f32, D),
                index: fidl::new_empty!(u32, 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!(
                f32,
                D,
                &mut self.measured_temperature_celsius,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.index, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for TripPointSetTripPointsRequest {
        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<TripPointSetTripPointsRequest, D>
        for &TripPointSetTripPointsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripPointSetTripPointsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TripPointSetTripPointsRequest, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<TripPointDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.descriptors),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<TripPointDescriptor>, D>,
    > fidl::encoding::Encode<TripPointSetTripPointsRequest, 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::<TripPointSetTripPointsRequest>(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 TripPointSetTripPointsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                descriptors: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<TripPointDescriptor>,
                    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::UnboundedVector<TripPointDescriptor>,
                D,
                &mut self.descriptors,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for TripPointGetTripPointDescriptorsResponse {
        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<TripPointGetTripPointDescriptorsResponse, D>
        for &TripPointGetTripPointDescriptorsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripPointGetTripPointDescriptorsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TripPointGetTripPointDescriptorsResponse, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<TripPointDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.descriptors),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<TripPointDescriptor>, D>,
    > fidl::encoding::Encode<TripPointGetTripPointDescriptorsResponse, 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::<TripPointGetTripPointDescriptorsResponse>(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 TripPointGetTripPointDescriptorsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                descriptors: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<TripPointDescriptor>,
                    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::UnboundedVector<TripPointDescriptor>,
                D,
                &mut self.descriptors,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<TripPointWaitForAnyTripPointResponse, D>
        for &TripPointWaitForAnyTripPointResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripPointWaitForAnyTripPointResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TripPointWaitForAnyTripPointResponse, D>::encode(
                (<TripPointResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<TripPointResult, D>>
        fidl::encoding::Encode<TripPointWaitForAnyTripPointResponse, 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::<TripPointWaitForAnyTripPointResponse>(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 TripPointWaitForAnyTripPointResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { result: fidl::new_empty!(TripPointResult, 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!(TripPointResult, D, &mut self.result, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for TripPointValue {
        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<TripPointValue, D>
        for &TripPointValue
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TripPointValue>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                TripPointValue::ClearedTripPoint(ref val) => {
                    fidl::encoding::encode_in_envelope::<ClearedTripPoint, D>(
                        <ClearedTripPoint as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                TripPointValue::OneshotTempAboveTripPoint(ref val) => {
                    fidl::encoding::encode_in_envelope::<OneshotTempAboveTripPoint, D>(
                        <OneshotTempAboveTripPoint as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                TripPointValue::OneshotTempBelowTripPoint(ref val) => {
                    fidl::encoding::encode_in_envelope::<OneshotTempBelowTripPoint, D>(
                        <OneshotTempBelowTripPoint as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                TripPointValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TripPointValue {
        #[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 => <ClearedTripPoint as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <OneshotTempAboveTripPoint as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                3 => <OneshotTempBelowTripPoint 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 TripPointValue::ClearedTripPoint(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            TripPointValue::ClearedTripPoint(fidl::new_empty!(ClearedTripPoint, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let TripPointValue::ClearedTripPoint(ref mut val) = self {
                        fidl::decode!(ClearedTripPoint, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let TripPointValue::OneshotTempAboveTripPoint(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = TripPointValue::OneshotTempAboveTripPoint(fidl::new_empty!(
                            OneshotTempAboveTripPoint,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let TripPointValue::OneshotTempAboveTripPoint(ref mut val) = self {
                        fidl::decode!(
                            OneshotTempAboveTripPoint,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let TripPointValue::OneshotTempBelowTripPoint(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = TripPointValue::OneshotTempBelowTripPoint(fidl::new_empty!(
                            OneshotTempBelowTripPoint,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let TripPointValue::OneshotTempBelowTripPoint(ref mut val) = self {
                        fidl::decode!(
                            OneshotTempBelowTripPoint,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = TripPointValue::__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(())
        }
    }
}