fidl_fuchsia_wlan_internal/
fidl_fuchsia_wlan_internal.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::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub const MAX_ASSOC_BASIC_RATES: u8 = 14;

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ChannelSwitchInfo {
    pub new_channel: u8,
}

impl fidl::Persistable for ChannelSwitchInfo {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SignalReportIndication {
    pub rssi_dbm: i8,
    pub snr_db: i8,
}

impl fidl::Persistable for SignalReportIndication {}

/// WFA WMM v1.2, 2.2.2
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WmmAcParams {
    /// Lower bound of contention window in exponential form
    /// `cw_min = 2^(ecw_min) - 1`. The unit for contention window is "slot time", which
    /// is different for each standard (e.g. 9 microseconds, 13 microseconds, etc.)
    pub ecw_min: u8,
    /// Upper bound of contention window in exponential form
    /// `cw_max = 2^(ecw_max) - 1`. The unit for contention window is "slot time", which
    /// is different for each standard (e.g. 9 microseconds, 13 microseconds, etc.)
    pub ecw_max: u8,
    /// Arbitration Interframe Spacing Number (control wait time between sending each frame)
    pub aifsn: u8,
    /// TXOP limit in unit of 32 microseconds
    pub txop_limit: u16,
    /// Whether admission control is mandatory
    pub acm: bool,
}

impl fidl::Persistable for WmmAcParams {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WmmStatusResponse {
    pub apsd: bool,
    pub ac_be_params: WmmAcParams,
    pub ac_bk_params: WmmAcParams,
    pub ac_vi_params: WmmAcParams,
    pub ac_vo_params: WmmAcParams,
}

impl fidl::Persistable for WmmStatusResponse {}

mod internal {
    use super::*;

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

    unsafe impl fidl::encoding::TypeMarker for ChannelSwitchInfo {
        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
        }
        #[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<ChannelSwitchInfo, D>
        for &ChannelSwitchInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ChannelSwitchInfo>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ChannelSwitchInfo)
                    .write_unaligned((self as *const ChannelSwitchInfo).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<u8, D>>
        fidl::encoding::Encode<ChannelSwitchInfo, 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::<ChannelSwitchInfo>(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 ChannelSwitchInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { new_channel: fidl::new_empty!(u8, 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, 1);
            }
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            2
        }
        #[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<SignalReportIndication, D> for &SignalReportIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SignalReportIndication>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut SignalReportIndication)
                    .write_unaligned((self as *const SignalReportIndication).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<i8, D>,
            T1: fidl::encoding::Encode<i8, D>,
        > fidl::encoding::Encode<SignalReportIndication, 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::<SignalReportIndication>(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 + 1, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for SignalReportIndication
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { rssi_dbm: fidl::new_empty!(i8, D), snr_db: fidl::new_empty!(i8, 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, 2);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WmmAcParams, D>
        for &WmmAcParams
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WmmAcParams>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<WmmAcParams, D>::encode(
                (
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.ecw_min),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.ecw_max),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.aifsn),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.txop_limit),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.acm),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<u8, D>,
            T1: fidl::encoding::Encode<u8, D>,
            T2: fidl::encoding::Encode<u8, D>,
            T3: fidl::encoding::Encode<u16, D>,
            T4: fidl::encoding::Encode<bool, D>,
        > fidl::encoding::Encode<WmmAcParams, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WmmAcParams>(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(2);
                (ptr as *mut u16).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(6);
                (ptr as *mut u16).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 1, depth)?;
            self.2.encode(encoder, offset + 2, depth)?;
            self.3.encode(encoder, offset + 4, depth)?;
            self.4.encode(encoder, offset + 6, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WmmAcParams {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                ecw_min: fidl::new_empty!(u8, D),
                ecw_max: fidl::new_empty!(u8, D),
                aifsn: fidl::new_empty!(u8, D),
                txop_limit: fidl::new_empty!(u16, D),
                acm: fidl::new_empty!(bool, 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(2) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let mask = 0xff00u16;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 2 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(6) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let mask = 0xff00u16;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 6 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u8, D, &mut self.ecw_min, decoder, offset + 0, _depth)?;
            fidl::decode!(u8, D, &mut self.ecw_max, decoder, offset + 1, _depth)?;
            fidl::decode!(u8, D, &mut self.aifsn, decoder, offset + 2, _depth)?;
            fidl::decode!(u16, D, &mut self.txop_limit, decoder, offset + 4, _depth)?;
            fidl::decode!(bool, D, &mut self.acm, decoder, offset + 6, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WmmStatusResponse, D>
        for &WmmStatusResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WmmStatusResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<WmmStatusResponse, D>::encode(
                (
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.apsd),
                    <WmmAcParams as fidl::encoding::ValueTypeMarker>::borrow(&self.ac_be_params),
                    <WmmAcParams as fidl::encoding::ValueTypeMarker>::borrow(&self.ac_bk_params),
                    <WmmAcParams as fidl::encoding::ValueTypeMarker>::borrow(&self.ac_vi_params),
                    <WmmAcParams as fidl::encoding::ValueTypeMarker>::borrow(&self.ac_vo_params),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<bool, D>,
            T1: fidl::encoding::Encode<WmmAcParams, D>,
            T2: fidl::encoding::Encode<WmmAcParams, D>,
            T3: fidl::encoding::Encode<WmmAcParams, D>,
            T4: fidl::encoding::Encode<WmmAcParams, D>,
        > fidl::encoding::Encode<WmmStatusResponse, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WmmStatusResponse>(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 u16).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 2, depth)?;
            self.2.encode(encoder, offset + 10, depth)?;
            self.3.encode(encoder, offset + 18, depth)?;
            self.4.encode(encoder, offset + 26, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WmmStatusResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                apsd: fidl::new_empty!(bool, D),
                ac_be_params: fidl::new_empty!(WmmAcParams, D),
                ac_bk_params: fidl::new_empty!(WmmAcParams, D),
                ac_vi_params: fidl::new_empty!(WmmAcParams, D),
                ac_vo_params: fidl::new_empty!(WmmAcParams, 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 u16).read_unaligned() };
            let mask = 0xff00u16;
            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!(bool, D, &mut self.apsd, decoder, offset + 0, _depth)?;
            fidl::decode!(WmmAcParams, D, &mut self.ac_be_params, decoder, offset + 2, _depth)?;
            fidl::decode!(WmmAcParams, D, &mut self.ac_bk_params, decoder, offset + 10, _depth)?;
            fidl::decode!(WmmAcParams, D, &mut self.ac_vi_params, decoder, offset + 18, _depth)?;
            fidl::decode!(WmmAcParams, D, &mut self.ac_vo_params, decoder, offset + 26, _depth)?;
            Ok(())
        }
    }
}
fidl_fuchsia_wlan_internal/fidl_fuchsia_wlan_internal.rs

fidl_fuchsia_wlan_internal/
fidl_fuchsia_wlan_internal.rs
