#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
use {
bitflags::bitflags,
fidl::{
client::QueryResponseFut,
endpoints::{ControlHandle as _, Responder as _},
},
fuchsia_zircon_status as zx_status,
futures::future::{self, MaybeDone, TryFutureExt},
};
#[cfg(target_os = "fuchsia")]
use fuchsia_zircon as zx;
pub const WLAN_FULLMAC_MAX_HISTOGRAMS_PER_TYPE: u8 = 8;
pub const WLAN_FULLMAC_MAX_NOISE_FLOOR_SAMPLES: u8 = 255;
pub const WLAN_FULLMAC_MAX_RSSI_SAMPLES: u8 = 255;
pub const WLAN_FULLMAC_MAX_RX_RATE_INDEX_SAMPLES: u8 = 196;
pub const WLAN_FULLMAC_MAX_SNR_SAMPLES: u16 = 256;
pub const WLAN_FULLMAC_NUM_RATES_AC: u8 = 120;
pub const WLAN_FULLMAC_NUM_RATES_B: u8 = 4;
pub const WLAN_FULLMAC_NUM_RATES_G: u8 = 8;
pub const WLAN_FULLMAC_NUM_RATES_N: u8 = 64;
pub const WLAN_MAX_KEYLIST_SIZE: u32 = 4;
pub const WLAN_VIE_MAX_LEN: u32 = 514;
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanAssocResult {
Success,
RefusedReasonUnspecified,
RefusedNotAuthenticated,
RefusedCapabilitiesMismatch,
RefusedExternalReason,
RefusedApOutOfMemory,
RefusedBasicRatesMismatch,
RejectedEmergencyServicesNotSupported,
RefusedTemporarily,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanAssocResultUnknown {
() => {
_
};
}
impl WlanAssocResult {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
0 => Some(Self::Success),
1 => Some(Self::RefusedReasonUnspecified),
2 => Some(Self::RefusedNotAuthenticated),
3 => Some(Self::RefusedCapabilitiesMismatch),
4 => Some(Self::RefusedExternalReason),
5 => Some(Self::RefusedApOutOfMemory),
6 => Some(Self::RefusedBasicRatesMismatch),
7 => Some(Self::RejectedEmergencyServicesNotSupported),
8 => Some(Self::RefusedTemporarily),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
0 => Self::Success,
1 => Self::RefusedReasonUnspecified,
2 => Self::RefusedNotAuthenticated,
3 => Self::RefusedCapabilitiesMismatch,
4 => Self::RefusedExternalReason,
5 => Self::RefusedApOutOfMemory,
6 => Self::RefusedBasicRatesMismatch,
7 => Self::RejectedEmergencyServicesNotSupported,
8 => Self::RefusedTemporarily,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Success => 0,
Self::RefusedReasonUnspecified => 1,
Self::RefusedNotAuthenticated => 2,
Self::RefusedCapabilitiesMismatch => 3,
Self::RefusedExternalReason => 4,
Self::RefusedApOutOfMemory => 5,
Self::RefusedBasicRatesMismatch => 6,
Self::RejectedEmergencyServicesNotSupported => 7,
Self::RefusedTemporarily => 8,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanAuthResult {
Success,
Refused,
AntiCloggingTokenRequired,
FiniteCyclicGroupNotSupported,
Rejected,
FailureTimeout,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanAuthResultUnknown {
() => {
_
};
}
impl WlanAuthResult {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
0 => Some(Self::Success),
1 => Some(Self::Refused),
2 => Some(Self::AntiCloggingTokenRequired),
3 => Some(Self::FiniteCyclicGroupNotSupported),
4 => Some(Self::Rejected),
5 => Some(Self::FailureTimeout),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
0 => Self::Success,
1 => Self::Refused,
2 => Self::AntiCloggingTokenRequired,
3 => Self::FiniteCyclicGroupNotSupported,
4 => Self::Rejected,
5 => Self::FailureTimeout,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Success => 0,
Self::Refused => 1,
Self::AntiCloggingTokenRequired => 2,
Self::FiniteCyclicGroupNotSupported => 3,
Self::Rejected => 4,
Self::FailureTimeout => 5,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanAuthType {
OpenSystem,
SharedKey,
FastBssTransition,
Sae,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanAuthTypeUnknown {
() => {
_
};
}
impl WlanAuthType {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
1 => Some(Self::OpenSystem),
2 => Some(Self::SharedKey),
3 => Some(Self::FastBssTransition),
4 => Some(Self::Sae),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
1 => Self::OpenSystem,
2 => Self::SharedKey,
3 => Self::FastBssTransition,
4 => Self::Sae,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::OpenSystem => 1,
Self::SharedKey => 2,
Self::FastBssTransition => 3,
Self::Sae => 4,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanEapolResult {
Success,
TransmissionFailure,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanEapolResultUnknown {
() => {
_
};
}
impl WlanEapolResult {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
0 => Some(Self::Success),
1 => Some(Self::TransmissionFailure),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
0 => Self::Success,
1 => Self::TransmissionFailure,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Success => 0,
Self::TransmissionFailure => 1,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum WlanFullmacAntennaFreq {
Antenna2G = 1,
Antenna5G = 2,
}
impl WlanFullmacAntennaFreq {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
1 => Some(Self::Antenna2G),
2 => Some(Self::Antenna5G),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u8 {
self as u8
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum WlanFullmacHistScope {
Station = 1,
PerAntenna = 2,
}
impl WlanFullmacHistScope {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
1 => Some(Self::Station),
2 => Some(Self::PerAntenna),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u8 {
self as u8
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanScanResult {
Success,
NotSupported,
InvalidArgs,
InternalError,
ShouldWait,
CanceledByDriverOrFirmware,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanScanResultUnknown {
() => {
_
};
}
impl WlanScanResult {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
0 => Some(Self::Success),
1 => Some(Self::NotSupported),
2 => Some(Self::InvalidArgs),
3 => Some(Self::InternalError),
4 => Some(Self::ShouldWait),
5 => Some(Self::CanceledByDriverOrFirmware),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
0 => Self::Success,
1 => Self::NotSupported,
2 => Self::InvalidArgs,
3 => Self::InternalError,
4 => Self::ShouldWait,
5 => Self::CanceledByDriverOrFirmware,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Success => 0,
Self::NotSupported => 1,
Self::InvalidArgs => 2,
Self::InternalError => 3,
Self::ShouldWait => 4,
Self::CanceledByDriverOrFirmware => 5,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanScanType {
Active,
Passive,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanScanTypeUnknown {
() => {
_
};
}
impl WlanScanType {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
1 => Some(Self::Active),
2 => Some(Self::Passive),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
1 => Self::Active,
2 => Self::Passive,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Active => 1,
Self::Passive => 2,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanStartResult {
Success,
BssAlreadyStartedOrJoined,
ResetRequiredBeforeStart,
NotSupported,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanStartResultUnknown {
() => {
_
};
}
impl WlanStartResult {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
0 => Some(Self::Success),
1 => Some(Self::BssAlreadyStartedOrJoined),
2 => Some(Self::ResetRequiredBeforeStart),
3 => Some(Self::NotSupported),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
0 => Self::Success,
1 => Self::BssAlreadyStartedOrJoined,
2 => Self::ResetRequiredBeforeStart,
3 => Self::NotSupported,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Success => 0,
Self::BssAlreadyStartedOrJoined => 1,
Self::ResetRequiredBeforeStart => 2,
Self::NotSupported => 3,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanStopResult {
Success,
BssAlreadyStopped,
InternalError,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u8,
},
}
#[macro_export]
macro_rules! WlanStopResultUnknown {
() => {
_
};
}
impl WlanStopResult {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
0 => Some(Self::Success),
1 => Some(Self::BssAlreadyStopped),
2 => Some(Self::InternalError),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u8) -> Self {
match prim {
0 => Self::Success,
1 => Self::BssAlreadyStopped,
2 => Self::InternalError,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xff }
}
#[inline]
pub const fn into_primitive(self) -> u8 {
match self {
Self::Success => 0,
Self::BssAlreadyStopped => 1,
Self::InternalError => 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 DeleteKeyDescriptor {
pub key_id: u16,
pub key_type: fidl_fuchsia_wlan_common::WlanKeyType,
pub address: [u8; 6],
}
impl fidl::Persistable for DeleteKeyDescriptor {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacAntennaId {
pub freq: WlanFullmacAntennaFreq,
pub index: u8,
}
impl fidl::Persistable for WlanFullmacAntennaId {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacAssocInd {
pub peer_sta_address: [u8; 6],
pub listen_interval: u16,
pub ssid: fidl_fuchsia_wlan_ieee80211::CSsid,
pub rsne_len: u64,
pub rsne: [u8; 257],
pub vendor_ie_len: u64,
pub vendor_ie: [u8; 514],
}
impl fidl::Persistable for WlanFullmacAssocInd {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacAuthInd {
pub peer_sta_address: [u8; 6],
pub auth_type: WlanAuthType,
}
impl fidl::Persistable for WlanFullmacAuthInd {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacBandCapability {
pub band: fidl_fuchsia_wlan_common::WlanBand,
pub basic_rate_count: u8,
pub basic_rate_list: [u8; 12],
pub ht_supported: bool,
pub ht_caps: fidl_fuchsia_wlan_ieee80211::HtCapabilities,
pub vht_supported: bool,
pub vht_caps: fidl_fuchsia_wlan_ieee80211::VhtCapabilities,
pub operating_channel_count: u16,
pub operating_channel_list: [u8; 256],
}
impl fidl::Persistable for WlanFullmacBandCapability {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacChannelSwitchInfo {
pub new_channel: u8,
}
impl fidl::Persistable for WlanFullmacChannelSwitchInfo {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacConnectConfirm {
pub peer_sta_address: [u8; 6],
pub result_code: fidl_fuchsia_wlan_ieee80211::StatusCode,
pub association_id: u16,
pub association_ies: Vec<u8>,
}
impl fidl::Persistable for WlanFullmacConnectConfirm {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacDeauthIndication {
pub peer_sta_address: [u8; 6],
pub reason_code: fidl_fuchsia_wlan_ieee80211::ReasonCode,
pub locally_initiated: bool,
}
impl fidl::Persistable for WlanFullmacDeauthIndication {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacDelKeysReq {
pub num_keys: u64,
pub keylist: [DeleteKeyDescriptor; 4],
}
impl fidl::Persistable for WlanFullmacDelKeysReq {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacDisassocConfirm {
pub status: i32,
}
impl fidl::Persistable for WlanFullmacDisassocConfirm {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacDisassocIndication {
pub peer_sta_address: [u8; 6],
pub reason_code: fidl_fuchsia_wlan_ieee80211::ReasonCode,
pub locally_initiated: bool,
}
impl fidl::Persistable for WlanFullmacDisassocIndication {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacEapolConfirm {
pub result_code: WlanEapolResult,
pub dst_addr: [u8; 6],
}
impl fidl::Persistable for WlanFullmacEapolConfirm {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacEapolIndication {
pub src_addr: [u8; 6],
pub dst_addr: [u8; 6],
pub data: Vec<u8>,
}
impl fidl::Persistable for WlanFullmacEapolIndication {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacHistBucket {
pub bucket_index: u16,
pub num_samples: u64,
}
impl fidl::Persistable for WlanFullmacHistBucket {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacIfaceCounterStats {
pub rx_unicast_total: u64,
pub rx_unicast_drop: u64,
pub rx_multicast: u64,
pub tx_total: u64,
pub tx_drop: u64,
}
impl fidl::Persistable for WlanFullmacIfaceCounterStats {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBaseDelKeysReqRequest {
pub req: WlanFullmacDelKeysReq,
}
impl fidl::Persistable for WlanFullmacImplBaseDelKeysReqRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBaseOnLinkStateChangedRequest {
pub online: bool,
}
impl fidl::Persistable for WlanFullmacImplBaseOnLinkStateChangedRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBaseSaeFrameTxRequest {
pub frame: WlanFullmacSaeFrame,
}
impl fidl::Persistable for WlanFullmacImplBaseSaeFrameTxRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBaseSaeHandshakeRespRequest {
pub resp: WlanFullmacSaeHandshakeResp,
}
impl fidl::Persistable for WlanFullmacImplBaseSaeHandshakeRespRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseSetKeysReqRequest {
pub req: WlanFullmacSetKeysReq,
}
impl fidl::Persistable for WlanFullmacImplBaseSetKeysReqRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacImplBaseSetKeysReqResponse {
pub resp: WlanFullmacSetKeysResp,
}
impl fidl::Persistable for WlanFullmacImplBaseSetKeysReqResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBaseSetMulticastPromiscRequest {
pub enable: bool,
}
impl fidl::Persistable for WlanFullmacImplBaseSetMulticastPromiscRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacImplBaseGetIfaceCounterStatsResponse {
pub stats: WlanFullmacIfaceCounterStats,
}
impl fidl::Persistable for WlanFullmacImplBaseGetIfaceCounterStatsResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseGetIfaceHistogramStatsResponse {
pub stats: WlanFullmacIfaceHistogramStats,
}
impl fidl::Persistable for WlanFullmacImplBaseGetIfaceHistogramStatsResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseQueryMacSublayerSupportResponse {
pub resp: fidl_fuchsia_wlan_common::MacSublayerSupport,
}
impl fidl::Persistable for WlanFullmacImplBaseQueryMacSublayerSupportResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseQuerySecuritySupportResponse {
pub resp: fidl_fuchsia_wlan_common::SecuritySupport,
}
impl fidl::Persistable for WlanFullmacImplBaseQuerySecuritySupportResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseQuerySpectrumManagementSupportResponse {
pub resp: fidl_fuchsia_wlan_common::SpectrumManagementSupport,
}
impl fidl::Persistable for WlanFullmacImplBaseQuerySpectrumManagementSupportResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseQueryResponse {
pub info: WlanFullmacQueryInfo,
}
impl fidl::Persistable for WlanFullmacImplBaseQueryResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBridgeStartRequest {
pub ifc: fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
}
impl fidl::Standalone for WlanFullmacImplBridgeStartRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplBridgeStartResponse {
pub sme_channel: fidl::Channel,
}
impl fidl::Standalone for WlanFullmacImplBridgeStartResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplIfcBaseAssocIndRequest {
pub resp: WlanFullmacAssocInd,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseAssocIndRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseAuthIndRequest {
pub resp: WlanFullmacAuthInd,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseAuthIndRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseConnectConfRequest {
pub resp: WlanFullmacConnectConfirm,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseConnectConfRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseDeauthIndRequest {
pub ind: WlanFullmacDeauthIndication,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseDeauthIndRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacImplIfcBaseDisassocConfRequest {
pub resp: WlanFullmacDisassocConfirm,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseDisassocConfRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseDisassocIndRequest {
pub ind: WlanFullmacDisassocIndication,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseDisassocIndRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseEapolConfRequest {
pub resp: WlanFullmacEapolConfirm,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseEapolConfRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseEapolIndRequest {
pub ind: WlanFullmacEapolIndication,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseEapolIndRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacImplIfcBaseOnChannelSwitchRequest {
pub ind: WlanFullmacChannelSwitchInfo,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseOnChannelSwitchRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseOnPmkAvailableRequest {
pub info: WlanFullmacPmkInfo,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseOnPmkAvailableRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseOnScanEndRequest {
pub end: WlanFullmacScanEnd,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseOnScanEndRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplIfcBaseOnScanResultRequest {
pub result: WlanFullmacScanResult,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseOnScanResultRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplIfcBaseOnWmmStatusRespRequest {
pub status: i32,
pub wmm_params: fidl_fuchsia_wlan_common::WlanWmmParameters,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseOnWmmStatusRespRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacImplIfcBaseRoamConfRequest {
pub resp: WlanFullmacRoamConfirm,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseRoamConfRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseSaeFrameRxRequest {
pub frame: WlanFullmacSaeFrame,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseSaeFrameRxRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacImplIfcBaseSaeHandshakeIndRequest {
pub ind: WlanFullmacSaeHandshakeInd,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseSaeHandshakeIndRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacImplIfcBaseSignalReportRequest {
pub ind: WlanFullmacSignalReportIndication,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseSignalReportRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseStartConfRequest {
pub resp: WlanFullmacStartConfirm,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseStartConfRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacImplIfcBaseStopConfRequest {
pub resp: WlanFullmacStopConfirm,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseStopConfRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacNoiseFloorHistogram {
pub hist_scope: WlanFullmacHistScope,
pub antenna_id: WlanFullmacAntennaId,
pub noise_floor_samples: Vec<WlanFullmacHistBucket>,
pub invalid_samples: u64,
}
impl fidl::Persistable for WlanFullmacNoiseFloorHistogram {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacPmkInfo {
pub pmk: Vec<u8>,
pub pmkid: Vec<u8>,
}
impl fidl::Persistable for WlanFullmacPmkInfo {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacQueryInfo {
pub sta_addr: [u8; 6],
pub role: fidl_fuchsia_wlan_common::WlanMacRole,
pub band_cap_list: [WlanFullmacBandCapability; 16],
pub band_cap_count: u8,
}
impl fidl::Persistable for WlanFullmacQueryInfo {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacRoamConfirm {
pub target_bssid: [u8; 6],
pub result_code: fidl_fuchsia_wlan_ieee80211::StatusCode,
pub selected_bss: fidl_fuchsia_wlan_internal::BssDescription,
}
impl fidl::Persistable for WlanFullmacRoamConfirm {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacRssiHistogram {
pub hist_scope: WlanFullmacHistScope,
pub antenna_id: WlanFullmacAntennaId,
pub rssi_samples: Vec<WlanFullmacHistBucket>,
pub invalid_samples: u64,
}
impl fidl::Persistable for WlanFullmacRssiHistogram {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacRssiStats {
pub hist: Vec<u64>,
}
impl fidl::Persistable for WlanFullmacRssiStats {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacRxRateIndexHistogram {
pub hist_scope: WlanFullmacHistScope,
pub antenna_id: WlanFullmacAntennaId,
pub rx_rate_index_samples: Vec<WlanFullmacHistBucket>,
pub invalid_samples: u64,
}
impl fidl::Persistable for WlanFullmacRxRateIndexHistogram {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacSaeFrame {
pub peer_sta_address: [u8; 6],
pub status_code: fidl_fuchsia_wlan_ieee80211::StatusCode,
pub seq_num: u16,
pub sae_fields: Vec<u8>,
}
impl fidl::Persistable for WlanFullmacSaeFrame {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacSaeHandshakeInd {
pub peer_sta_address: [u8; 6],
}
impl fidl::Persistable for WlanFullmacSaeHandshakeInd {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacSaeHandshakeResp {
pub peer_sta_address: [u8; 6],
pub status_code: fidl_fuchsia_wlan_ieee80211::StatusCode,
}
impl fidl::Persistable for WlanFullmacSaeHandshakeResp {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacScanEnd {
pub txn_id: u64,
pub code: WlanScanResult,
}
impl fidl::Persistable for WlanFullmacScanEnd {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacScanResult {
pub txn_id: u64,
pub timestamp_nanos: i64,
pub bss: fidl_fuchsia_wlan_internal::BssDescription,
}
impl fidl::Persistable for WlanFullmacScanResult {}
#[derive(Clone, Debug, PartialEq)]
pub struct WlanFullmacSetKeysReq {
pub num_keys: u64,
pub keylist: [fidl_fuchsia_wlan_common::WlanKeyConfig; 4],
}
impl fidl::Persistable for WlanFullmacSetKeysReq {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacSetKeysResp {
pub num_keys: u64,
pub statuslist: [i32; 4],
}
impl fidl::Persistable for WlanFullmacSetKeysResp {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WlanFullmacSignalReportIndication {
pub rssi_dbm: i8,
pub snr_db: i8,
}
impl fidl::Persistable for WlanFullmacSignalReportIndication {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacSnrHistogram {
pub hist_scope: WlanFullmacHistScope,
pub antenna_id: WlanFullmacAntennaId,
pub snr_samples: Vec<WlanFullmacHistBucket>,
pub invalid_samples: u64,
}
impl fidl::Persistable for WlanFullmacSnrHistogram {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacStartConfirm {
pub result_code: WlanStartResult,
}
impl fidl::Persistable for WlanFullmacStartConfirm {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanFullmacStopConfirm {
pub result_code: WlanStopResult,
}
impl fidl::Persistable for WlanFullmacStopConfirm {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacIfaceHistogramStats {
pub noise_floor_histograms: Option<Vec<WlanFullmacNoiseFloorHistogram>>,
pub rssi_histograms: Option<Vec<WlanFullmacRssiHistogram>>,
pub rx_rate_index_histograms: Option<Vec<WlanFullmacRxRateIndexHistogram>>,
pub snr_histograms: Option<Vec<WlanFullmacSnrHistogram>>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacIfaceHistogramStats {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseAssocRespRequest {
pub peer_sta_address: Option<[u8; 6]>,
pub result_code: Option<WlanAssocResult>,
pub association_id: Option<u16>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseAssocRespRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseAuthRespRequest {
pub peer_sta_address: Option<[u8; 6]>,
pub result_code: Option<WlanAuthResult>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseAuthRespRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseConnectRequest {
pub selected_bss: Option<fidl_fuchsia_wlan_internal::BssDescription>,
pub connect_failure_timeout: Option<u32>,
pub auth_type: Option<WlanAuthType>,
pub sae_password: Option<Vec<u8>>,
pub wep_key: Option<fidl_fuchsia_wlan_common::WlanKeyConfig>,
pub security_ie: Option<Vec<u8>>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseConnectRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseDeauthRequest {
pub peer_sta_address: Option<[u8; 6]>,
pub reason_code: Option<fidl_fuchsia_wlan_ieee80211::ReasonCode>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseDeauthRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseDisassocRequest {
pub peer_sta_address: Option<[u8; 6]>,
pub reason_code: Option<fidl_fuchsia_wlan_ieee80211::ReasonCode>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseDisassocRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseEapolTxRequest {
pub src_addr: Option<[u8; 6]>,
pub dst_addr: Option<[u8; 6]>,
pub data: Option<Vec<u8>>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseEapolTxRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseReconnectRequest {
pub peer_sta_address: Option<[u8; 6]>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseReconnectRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseResetRequest {
pub sta_address: Option<[u8; 6]>,
pub set_default_mib: Option<bool>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseResetRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseStartBssRequest {
pub ssid: Option<fidl_fuchsia_wlan_ieee80211::CSsid>,
pub bss_type: Option<fidl_fuchsia_wlan_common::BssType>,
pub beacon_period: Option<u32>,
pub dtim_period: Option<u32>,
pub channel: Option<u8>,
pub rsne: Option<Vec<u8>>,
pub vendor_ie: Option<Vec<u8>>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseStartBssRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseStartScanRequest {
pub txn_id: Option<u64>,
pub scan_type: Option<WlanScanType>,
pub channels: Option<Vec<u8>>,
pub ssids: Option<Vec<fidl_fuchsia_wlan_ieee80211::CSsid>>,
pub min_channel_time: Option<u32>,
pub max_channel_time: Option<u32>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseStartScanRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplBaseStopBssRequest {
pub ssid: Option<fidl_fuchsia_wlan_ieee80211::CSsid>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplBaseStopBssRequest {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct WlanFullmacImplIfcBaseDeauthConfRequest {
pub peer_sta_address: Option<[u8; 6]>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for WlanFullmacImplIfcBaseDeauthConfRequest {}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct WlanFullmacImplBaseMarker;
impl fidl::endpoints::ProtocolMarker for WlanFullmacImplBaseMarker {
type Proxy = WlanFullmacImplBaseProxy;
type RequestStream = WlanFullmacImplBaseRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = WlanFullmacImplBaseSynchronousProxy;
const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImplBase";
}
impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImplBaseMarker {}
pub type WlanFullmacImplBaseQueryResult = Result<WlanFullmacQueryInfo, i32>;
pub type WlanFullmacImplBaseQueryMacSublayerSupportResult =
Result<fidl_fuchsia_wlan_common::MacSublayerSupport, i32>;
pub type WlanFullmacImplBaseQuerySecuritySupportResult =
Result<fidl_fuchsia_wlan_common::SecuritySupport, i32>;
pub type WlanFullmacImplBaseQuerySpectrumManagementSupportResult =
Result<fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>;
pub type WlanFullmacImplBaseGetIfaceCounterStatsResult = Result<WlanFullmacIfaceCounterStats, i32>;
pub type WlanFullmacImplBaseGetIfaceHistogramStatsResult =
Result<WlanFullmacIfaceHistogramStats, i32>;
pub type WlanFullmacImplBaseSetMulticastPromiscResult = Result<(), i32>;
pub trait WlanFullmacImplBaseProxyInterface: Send + Sync {
type StopResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#stop(&self) -> Self::StopResponseFut;
type QueryResponseFut: std::future::Future<Output = Result<WlanFullmacImplBaseQueryResult, fidl::Error>>
+ Send;
fn r#query(&self) -> Self::QueryResponseFut;
type QueryMacSublayerSupportResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseQueryMacSublayerSupportResult, fidl::Error>,
> + Send;
fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut;
type QuerySecuritySupportResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseQuerySecuritySupportResult, fidl::Error>,
> + Send;
fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut;
type QuerySpectrumManagementSupportResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseQuerySpectrumManagementSupportResult, fidl::Error>,
> + Send;
fn r#query_spectrum_management_support(
&self,
) -> Self::QuerySpectrumManagementSupportResponseFut;
type StartScanResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#start_scan(
&self,
payload: &WlanFullmacImplBaseStartScanRequest,
) -> Self::StartScanResponseFut;
type ConnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#connect(&self, payload: &WlanFullmacImplBaseConnectRequest) -> Self::ConnectResponseFut;
type ReconnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#reconnect(
&self,
payload: &WlanFullmacImplBaseReconnectRequest,
) -> Self::ReconnectResponseFut;
type AuthRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#auth_resp(
&self,
payload: &WlanFullmacImplBaseAuthRespRequest,
) -> Self::AuthRespResponseFut;
type DeauthResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#deauth(&self, payload: &WlanFullmacImplBaseDeauthRequest) -> Self::DeauthResponseFut;
type AssocRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#assoc_resp(
&self,
payload: &WlanFullmacImplBaseAssocRespRequest,
) -> Self::AssocRespResponseFut;
type DisassocResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#disassoc(&self, payload: &WlanFullmacImplBaseDisassocRequest)
-> Self::DisassocResponseFut;
type ResetResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#reset(&self, payload: &WlanFullmacImplBaseResetRequest) -> Self::ResetResponseFut;
type StartBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#start_bss(
&self,
payload: &WlanFullmacImplBaseStartBssRequest,
) -> Self::StartBssResponseFut;
type StopBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#stop_bss(&self, payload: &WlanFullmacImplBaseStopBssRequest) -> Self::StopBssResponseFut;
type SetKeysReqResponseFut: std::future::Future<Output = Result<WlanFullmacSetKeysResp, fidl::Error>>
+ Send;
fn r#set_keys_req(&self, req: &WlanFullmacSetKeysReq) -> Self::SetKeysReqResponseFut;
type DelKeysReqResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#del_keys_req(&self, req: &WlanFullmacDelKeysReq) -> Self::DelKeysReqResponseFut;
type EapolTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#eapol_tx(&self, payload: &WlanFullmacImplBaseEapolTxRequest) -> Self::EapolTxResponseFut;
type GetIfaceCounterStatsResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseGetIfaceCounterStatsResult, fidl::Error>,
> + Send;
fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut;
type GetIfaceHistogramStatsResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseGetIfaceHistogramStatsResult, fidl::Error>,
> + Send;
fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut;
type SaeHandshakeRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_handshake_resp(
&self,
resp: &WlanFullmacSaeHandshakeResp,
) -> Self::SaeHandshakeRespResponseFut;
type SaeFrameTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_frame_tx(&self, frame: &WlanFullmacSaeFrame) -> Self::SaeFrameTxResponseFut;
type WmmStatusReqResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut;
type SetMulticastPromiscResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseSetMulticastPromiscResult, fidl::Error>,
> + Send;
fn r#set_multicast_promisc(&self, enable: bool) -> Self::SetMulticastPromiscResponseFut;
type OnLinkStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_link_state_changed(&self, online: bool) -> Self::OnLinkStateChangedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanFullmacImplBaseSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanFullmacImplBaseSynchronousProxy {
type Proxy = WlanFullmacImplBaseProxy;
type Protocol = WlanFullmacImplBaseMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl WlanFullmacImplBaseSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<WlanFullmacImplBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
pub fn wait_for_event(
&self,
deadline: zx::Time,
) -> Result<WlanFullmacImplBaseEvent, fidl::Error> {
WlanFullmacImplBaseEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#stop(&self, ___deadline: zx::Time) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x3f2685c8371251e6,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#query(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQueryResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<WlanFullmacImplBaseQueryResponse, i32>,
>(
(),
0x16b5144d67f27eb9,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.info))
}
pub fn r#query_mac_sublayer_support(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQueryMacSublayerSupportResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseQueryMacSublayerSupportResponse,
i32,
>>(
(),
0x209b5ff943ebf049,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.resp))
}
pub fn r#query_security_support(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQuerySecuritySupportResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySecuritySupportResponse,
i32,
>>(
(),
0x1a5d8312c882fcba,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.resp))
}
pub fn r#query_spectrum_management_support(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQuerySpectrumManagementSupportResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySpectrumManagementSupportResponse,
i32,
>>(
(), 0x4b9f43e3dfabee9e, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x.resp))
}
pub fn r#start_scan(
&self,
mut payload: &WlanFullmacImplBaseStartScanRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseStartScanRequest, fidl::encoding::EmptyPayload>(
payload,
0x3dc452902af23757,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#connect(
&self,
mut payload: &WlanFullmacImplBaseConnectRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseConnectRequest, fidl::encoding::EmptyPayload>(
payload,
0x684dd78a0c9ebd2a,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#reconnect(
&self,
mut payload: &WlanFullmacImplBaseReconnectRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseReconnectRequest, fidl::encoding::EmptyPayload>(
payload,
0x75259e6d9fa05df1,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#auth_resp(
&self,
mut payload: &WlanFullmacImplBaseAuthRespRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseAuthRespRequest, fidl::encoding::EmptyPayload>(
payload,
0x558fac0bd6e468bd,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#deauth(
&self,
mut payload: &WlanFullmacImplBaseDeauthRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseDeauthRequest, fidl::encoding::EmptyPayload>(
payload,
0x3e573f78a0343e2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#assoc_resp(
&self,
mut payload: &WlanFullmacImplBaseAssocRespRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseAssocRespRequest, fidl::encoding::EmptyPayload>(
payload,
0x7626d6d9e6fce311,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#disassoc(
&self,
mut payload: &WlanFullmacImplBaseDisassocRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseDisassocRequest, fidl::encoding::EmptyPayload>(
payload,
0x14b5190abdb17230,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#reset(
&self,
mut payload: &WlanFullmacImplBaseResetRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseResetRequest, fidl::encoding::EmptyPayload>(
payload,
0x37d8cfd378d3913a,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#start_bss(
&self,
mut payload: &WlanFullmacImplBaseStartBssRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseStartBssRequest, fidl::encoding::EmptyPayload>(
payload,
0x337435c3055da80f,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#stop_bss(
&self,
mut payload: &WlanFullmacImplBaseStopBssRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseStopBssRequest, fidl::encoding::EmptyPayload>(
payload,
0x61cf5a6b75a25189,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#set_keys_req(
&self,
mut req: &WlanFullmacSetKeysReq,
___deadline: zx::Time,
) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBaseSetKeysReqRequest,
WlanFullmacImplBaseSetKeysReqResponse,
>(
(req,),
0x6b96f84f264f3b4d,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.resp)
}
pub fn r#del_keys_req(
&self,
mut req: &WlanFullmacDelKeysReq,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseDelKeysReqRequest, fidl::encoding::EmptyPayload>(
(req,),
0x7e2981344e041440,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#eapol_tx(
&self,
mut payload: &WlanFullmacImplBaseEapolTxRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseEapolTxRequest, fidl::encoding::EmptyPayload>(
payload,
0x44b71768115d3494,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#get_iface_counter_stats(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseGetIfaceCounterStatsResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceCounterStatsResponse,
i32,
>>(
(),
0xe5e9c7bb1e7f576,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.stats))
}
pub fn r#get_iface_histogram_stats(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseGetIfaceHistogramStatsResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceHistogramStatsResponse,
i32,
>>(
(),
0x57cfab227d48967d,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.stats))
}
pub fn r#sae_handshake_resp(
&self,
mut resp: &WlanFullmacSaeHandshakeResp,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseSaeHandshakeRespRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x5be2c56442ea8a26,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#sae_frame_tx(
&self,
mut frame: &WlanFullmacSaeFrame,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseSaeFrameTxRequest, fidl::encoding::EmptyPayload>(
(frame,),
0x8e00b54858b3d26,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#wmm_status_req(&self, ___deadline: zx::Time) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x4361a32fb2c5f09,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#set_multicast_promisc(
&self,
mut enable: bool,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseSetMulticastPromiscResult, fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBaseSetMulticastPromiscRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(enable,),
0x13c926de05ad8101,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#on_link_state_changed(
&self,
mut online: bool,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBaseOnLinkStateChangedRequest,
fidl::encoding::EmptyPayload,
>(
(online,),
0x466007ff40a1efa2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplBaseProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for WlanFullmacImplBaseProxy {
type Protocol = WlanFullmacImplBaseMarker;
fn from_channel(inner: fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl WlanFullmacImplBaseProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<WlanFullmacImplBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> WlanFullmacImplBaseEventStream {
WlanFullmacImplBaseEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#stop(&self) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#stop(self)
}
pub fn r#query(&self) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryResult> {
WlanFullmacImplBaseProxyInterface::r#query(self)
}
pub fn r#query_mac_sublayer_support(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryMacSublayerSupportResult> {
WlanFullmacImplBaseProxyInterface::r#query_mac_sublayer_support(self)
}
pub fn r#query_security_support(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySecuritySupportResult> {
WlanFullmacImplBaseProxyInterface::r#query_security_support(self)
}
pub fn r#query_spectrum_management_support(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySpectrumManagementSupportResult>
{
WlanFullmacImplBaseProxyInterface::r#query_spectrum_management_support(self)
}
pub fn r#start_scan(
&self,
mut payload: &WlanFullmacImplBaseStartScanRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#start_scan(self, payload)
}
pub fn r#connect(
&self,
mut payload: &WlanFullmacImplBaseConnectRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#connect(self, payload)
}
pub fn r#reconnect(
&self,
mut payload: &WlanFullmacImplBaseReconnectRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#reconnect(self, payload)
}
pub fn r#auth_resp(
&self,
mut payload: &WlanFullmacImplBaseAuthRespRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#auth_resp(self, payload)
}
pub fn r#deauth(
&self,
mut payload: &WlanFullmacImplBaseDeauthRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#deauth(self, payload)
}
pub fn r#assoc_resp(
&self,
mut payload: &WlanFullmacImplBaseAssocRespRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#assoc_resp(self, payload)
}
pub fn r#disassoc(
&self,
mut payload: &WlanFullmacImplBaseDisassocRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#disassoc(self, payload)
}
pub fn r#reset(
&self,
mut payload: &WlanFullmacImplBaseResetRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#reset(self, payload)
}
pub fn r#start_bss(
&self,
mut payload: &WlanFullmacImplBaseStartBssRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#start_bss(self, payload)
}
pub fn r#stop_bss(
&self,
mut payload: &WlanFullmacImplBaseStopBssRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#stop_bss(self, payload)
}
pub fn r#set_keys_req(
&self,
mut req: &WlanFullmacSetKeysReq,
) -> fidl::client::QueryResponseFut<WlanFullmacSetKeysResp> {
WlanFullmacImplBaseProxyInterface::r#set_keys_req(self, req)
}
pub fn r#del_keys_req(
&self,
mut req: &WlanFullmacDelKeysReq,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#del_keys_req(self, req)
}
pub fn r#eapol_tx(
&self,
mut payload: &WlanFullmacImplBaseEapolTxRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#eapol_tx(self, payload)
}
pub fn r#get_iface_counter_stats(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceCounterStatsResult> {
WlanFullmacImplBaseProxyInterface::r#get_iface_counter_stats(self)
}
pub fn r#get_iface_histogram_stats(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceHistogramStatsResult> {
WlanFullmacImplBaseProxyInterface::r#get_iface_histogram_stats(self)
}
pub fn r#sae_handshake_resp(
&self,
mut resp: &WlanFullmacSaeHandshakeResp,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#sae_handshake_resp(self, resp)
}
pub fn r#sae_frame_tx(
&self,
mut frame: &WlanFullmacSaeFrame,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#sae_frame_tx(self, frame)
}
pub fn r#wmm_status_req(&self) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#wmm_status_req(self)
}
pub fn r#set_multicast_promisc(
&self,
mut enable: bool,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseSetMulticastPromiscResult> {
WlanFullmacImplBaseProxyInterface::r#set_multicast_promisc(self, enable)
}
pub fn r#on_link_state_changed(&self, mut online: bool) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBaseProxyInterface::r#on_link_state_changed(self, online)
}
}
impl WlanFullmacImplBaseProxyInterface for WlanFullmacImplBaseProxy {
type StopResponseFut = fidl::client::QueryResponseFut<()>;
fn r#stop(&self) -> Self::StopResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3f2685c8371251e6,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x3f2685c8371251e6,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QueryResponseFut = fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryResult>;
fn r#query(&self) -> Self::QueryResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQueryResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseQueryResponse, i32>,
0x16b5144d67f27eb9,
>(_buf?)?;
Ok(_response.map(|x| x.info))
}
self.client
.send_query_and_decode::<fidl::encoding::EmptyPayload, WlanFullmacImplBaseQueryResult>(
(),
0x16b5144d67f27eb9,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QueryMacSublayerSupportResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryMacSublayerSupportResult>;
fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQueryMacSublayerSupportResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseQueryMacSublayerSupportResponse, i32>,
0x209b5ff943ebf049,
>(_buf?)?;
Ok(_response.map(|x| x.resp))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseQueryMacSublayerSupportResult,
>(
(),
0x209b5ff943ebf049,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QuerySecuritySupportResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySecuritySupportResult>;
fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQuerySecuritySupportResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseQuerySecuritySupportResponse, i32>,
0x1a5d8312c882fcba,
>(_buf?)?;
Ok(_response.map(|x| x.resp))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseQuerySecuritySupportResult,
>(
(),
0x1a5d8312c882fcba,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QuerySpectrumManagementSupportResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySpectrumManagementSupportResult>;
fn r#query_spectrum_management_support(
&self,
) -> Self::QuerySpectrumManagementSupportResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQuerySpectrumManagementSupportResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySpectrumManagementSupportResponse,
i32,
>,
0x4b9f43e3dfabee9e,
>(_buf?)?;
Ok(_response.map(|x| x.resp))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseQuerySpectrumManagementSupportResult,
>(
(),
0x4b9f43e3dfabee9e,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartScanResponseFut = fidl::client::QueryResponseFut<()>;
fn r#start_scan(
&self,
mut payload: &WlanFullmacImplBaseStartScanRequest,
) -> Self::StartScanResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3dc452902af23757,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseStartScanRequest, ()>(
payload,
0x3dc452902af23757,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ConnectResponseFut = fidl::client::QueryResponseFut<()>;
fn r#connect(
&self,
mut payload: &WlanFullmacImplBaseConnectRequest,
) -> Self::ConnectResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x684dd78a0c9ebd2a,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseConnectRequest, ()>(
payload,
0x684dd78a0c9ebd2a,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ReconnectResponseFut = fidl::client::QueryResponseFut<()>;
fn r#reconnect(
&self,
mut payload: &WlanFullmacImplBaseReconnectRequest,
) -> Self::ReconnectResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x75259e6d9fa05df1,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseReconnectRequest, ()>(
payload,
0x75259e6d9fa05df1,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AuthRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#auth_resp(
&self,
mut payload: &WlanFullmacImplBaseAuthRespRequest,
) -> Self::AuthRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x558fac0bd6e468bd,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseAuthRespRequest, ()>(
payload,
0x558fac0bd6e468bd,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DeauthResponseFut = fidl::client::QueryResponseFut<()>;
fn r#deauth(&self, mut payload: &WlanFullmacImplBaseDeauthRequest) -> Self::DeauthResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3e573f78a0343e2,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseDeauthRequest, ()>(
payload,
0x3e573f78a0343e2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AssocRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#assoc_resp(
&self,
mut payload: &WlanFullmacImplBaseAssocRespRequest,
) -> Self::AssocRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x7626d6d9e6fce311,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseAssocRespRequest, ()>(
payload,
0x7626d6d9e6fce311,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisassocResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disassoc(
&self,
mut payload: &WlanFullmacImplBaseDisassocRequest,
) -> Self::DisassocResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x14b5190abdb17230,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseDisassocRequest, ()>(
payload,
0x14b5190abdb17230,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ResetResponseFut = fidl::client::QueryResponseFut<()>;
fn r#reset(&self, mut payload: &WlanFullmacImplBaseResetRequest) -> Self::ResetResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x37d8cfd378d3913a,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseResetRequest, ()>(
payload,
0x37d8cfd378d3913a,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartBssResponseFut = fidl::client::QueryResponseFut<()>;
fn r#start_bss(
&self,
mut payload: &WlanFullmacImplBaseStartBssRequest,
) -> Self::StartBssResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x337435c3055da80f,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseStartBssRequest, ()>(
payload,
0x337435c3055da80f,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StopBssResponseFut = fidl::client::QueryResponseFut<()>;
fn r#stop_bss(
&self,
mut payload: &WlanFullmacImplBaseStopBssRequest,
) -> Self::StopBssResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x61cf5a6b75a25189,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseStopBssRequest, ()>(
payload,
0x61cf5a6b75a25189,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SetKeysReqResponseFut = fidl::client::QueryResponseFut<WlanFullmacSetKeysResp>;
fn r#set_keys_req(&self, mut req: &WlanFullmacSetKeysReq) -> Self::SetKeysReqResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
WlanFullmacImplBaseSetKeysReqResponse,
0x6b96f84f264f3b4d,
>(_buf?)?;
Ok(_response.resp)
}
self.client
.send_query_and_decode::<WlanFullmacImplBaseSetKeysReqRequest, WlanFullmacSetKeysResp>(
(req,),
0x6b96f84f264f3b4d,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DelKeysReqResponseFut = fidl::client::QueryResponseFut<()>;
fn r#del_keys_req(&self, mut req: &WlanFullmacDelKeysReq) -> Self::DelKeysReqResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x7e2981344e041440,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseDelKeysReqRequest, ()>(
(req,),
0x7e2981344e041440,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type EapolTxResponseFut = fidl::client::QueryResponseFut<()>;
fn r#eapol_tx(
&self,
mut payload: &WlanFullmacImplBaseEapolTxRequest,
) -> Self::EapolTxResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x44b71768115d3494,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseEapolTxRequest, ()>(
payload,
0x44b71768115d3494,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetIfaceCounterStatsResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceCounterStatsResult>;
fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseGetIfaceCounterStatsResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseGetIfaceCounterStatsResponse, i32>,
0xe5e9c7bb1e7f576,
>(_buf?)?;
Ok(_response.map(|x| x.stats))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseGetIfaceCounterStatsResult,
>(
(),
0xe5e9c7bb1e7f576,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetIfaceHistogramStatsResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceHistogramStatsResult>;
fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseGetIfaceHistogramStatsResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseGetIfaceHistogramStatsResponse, i32>,
0x57cfab227d48967d,
>(_buf?)?;
Ok(_response.map(|x| x.stats))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseGetIfaceHistogramStatsResult,
>(
(),
0x57cfab227d48967d,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeHandshakeRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_handshake_resp(
&self,
mut resp: &WlanFullmacSaeHandshakeResp,
) -> Self::SaeHandshakeRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x5be2c56442ea8a26,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseSaeHandshakeRespRequest, ()>(
(resp,),
0x5be2c56442ea8a26,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeFrameTxResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_frame_tx(&self, mut frame: &WlanFullmacSaeFrame) -> Self::SaeFrameTxResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x8e00b54858b3d26,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseSaeFrameTxRequest, ()>(
(frame,),
0x8e00b54858b3d26,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type WmmStatusReqResponseFut = fidl::client::QueryResponseFut<()>;
fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x4361a32fb2c5f09,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x4361a32fb2c5f09,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SetMulticastPromiscResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseSetMulticastPromiscResult>;
fn r#set_multicast_promisc(&self, mut enable: bool) -> Self::SetMulticastPromiscResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseSetMulticastPromiscResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x13c926de05ad8101,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
WlanFullmacImplBaseSetMulticastPromiscRequest,
WlanFullmacImplBaseSetMulticastPromiscResult,
>(
(enable,),
0x13c926de05ad8101,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnLinkStateChangedResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_link_state_changed(&self, mut online: bool) -> Self::OnLinkStateChangedResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x466007ff40a1efa2,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseOnLinkStateChangedRequest, ()>(
(online,),
0x466007ff40a1efa2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct WlanFullmacImplBaseEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for WlanFullmacImplBaseEventStream {}
impl futures::stream::FusedStream for WlanFullmacImplBaseEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for WlanFullmacImplBaseEventStream {
type Item = Result<WlanFullmacImplBaseEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImplBaseEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum WlanFullmacImplBaseEvent {}
impl WlanFullmacImplBaseEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<WlanFullmacImplBaseEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<WlanFullmacImplBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct WlanFullmacImplBaseRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for WlanFullmacImplBaseRequestStream {}
impl futures::stream::FusedStream for WlanFullmacImplBaseRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for WlanFullmacImplBaseRequestStream {
type Protocol = WlanFullmacImplBaseMarker;
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn from_channel(channel: fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
WlanFullmacImplBaseControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for WlanFullmacImplBaseRequestStream {
type Item = Result<WlanFullmacImplBaseRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled WlanFullmacImplBaseRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x3f2685c8371251e6 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Stop {
responder: WlanFullmacImplBaseStopResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x16b5144d67f27eb9 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Query {
responder: WlanFullmacImplBaseQueryResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x209b5ff943ebf049 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::QueryMacSublayerSupport {
responder: WlanFullmacImplBaseQueryMacSublayerSupportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1a5d8312c882fcba => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::QuerySecuritySupport {
responder: WlanFullmacImplBaseQuerySecuritySupportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4b9f43e3dfabee9e => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::QuerySpectrumManagementSupport {
responder: WlanFullmacImplBaseQuerySpectrumManagementSupportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3dc452902af23757 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseStartScanRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseStartScanRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::StartScan {
payload: req,
responder: WlanFullmacImplBaseStartScanResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x684dd78a0c9ebd2a => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseConnectRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseConnectRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Connect {
payload: req,
responder: WlanFullmacImplBaseConnectResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x75259e6d9fa05df1 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseReconnectRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseReconnectRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Reconnect {
payload: req,
responder: WlanFullmacImplBaseReconnectResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x558fac0bd6e468bd => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseAuthRespRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseAuthRespRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::AuthResp {
payload: req,
responder: WlanFullmacImplBaseAuthRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3e573f78a0343e2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseDeauthRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseDeauthRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Deauth {
payload: req,
responder: WlanFullmacImplBaseDeauthResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7626d6d9e6fce311 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseAssocRespRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseAssocRespRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::AssocResp {
payload: req,
responder: WlanFullmacImplBaseAssocRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x14b5190abdb17230 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseDisassocRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseDisassocRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Disassoc {
payload: req,
responder: WlanFullmacImplBaseDisassocResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x37d8cfd378d3913a => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseResetRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseResetRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::Reset {
payload: req,
responder: WlanFullmacImplBaseResetResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x337435c3055da80f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseStartBssRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseStartBssRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::StartBss {
payload: req,
responder: WlanFullmacImplBaseStartBssResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x61cf5a6b75a25189 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseStopBssRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseStopBssRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::StopBss {
payload: req,
responder: WlanFullmacImplBaseStopBssResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6b96f84f264f3b4d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSetKeysReqRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseSetKeysReqRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::SetKeysReq {
req: req.req,
responder: WlanFullmacImplBaseSetKeysReqResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7e2981344e041440 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseDelKeysReqRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseDelKeysReqRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::DelKeysReq {
req: req.req,
responder: WlanFullmacImplBaseDelKeysReqResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x44b71768115d3494 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseEapolTxRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseEapolTxRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::EapolTx {
payload: req,
responder: WlanFullmacImplBaseEapolTxResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xe5e9c7bb1e7f576 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::GetIfaceCounterStats {
responder: WlanFullmacImplBaseGetIfaceCounterStatsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x57cfab227d48967d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::GetIfaceHistogramStats {
responder: WlanFullmacImplBaseGetIfaceHistogramStatsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5be2c56442ea8a26 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSaeHandshakeRespRequest);
fidl::encoding::Decoder::decode_into::<
WlanFullmacImplBaseSaeHandshakeRespRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::SaeHandshakeResp {
resp: req.resp,
responder: WlanFullmacImplBaseSaeHandshakeRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x8e00b54858b3d26 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSaeFrameTxRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseSaeFrameTxRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::SaeFrameTx {
frame: req.frame,
responder: WlanFullmacImplBaseSaeFrameTxResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4361a32fb2c5f09 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::WmmStatusReq {
responder: WlanFullmacImplBaseWmmStatusReqResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x13c926de05ad8101 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSetMulticastPromiscRequest);
fidl::encoding::Decoder::decode_into::<
WlanFullmacImplBaseSetMulticastPromiscRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::SetMulticastPromisc {
enable: req.enable,
responder: WlanFullmacImplBaseSetMulticastPromiscResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x466007ff40a1efa2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseOnLinkStateChangedRequest);
fidl::encoding::Decoder::decode_into::<
WlanFullmacImplBaseOnLinkStateChangedRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
WlanFullmacImplBaseControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBaseRequest::OnLinkStateChanged {
online: req.online,
responder: WlanFullmacImplBaseOnLinkStateChangedResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<WlanFullmacImplBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum WlanFullmacImplBaseRequest {
Stop {
responder: WlanFullmacImplBaseStopResponder,
},
Query {
responder: WlanFullmacImplBaseQueryResponder,
},
QueryMacSublayerSupport {
responder: WlanFullmacImplBaseQueryMacSublayerSupportResponder,
},
QuerySecuritySupport {
responder: WlanFullmacImplBaseQuerySecuritySupportResponder,
},
QuerySpectrumManagementSupport {
responder: WlanFullmacImplBaseQuerySpectrumManagementSupportResponder,
},
StartScan {
payload: WlanFullmacImplBaseStartScanRequest,
responder: WlanFullmacImplBaseStartScanResponder,
},
Connect {
payload: WlanFullmacImplBaseConnectRequest,
responder: WlanFullmacImplBaseConnectResponder,
},
Reconnect {
payload: WlanFullmacImplBaseReconnectRequest,
responder: WlanFullmacImplBaseReconnectResponder,
},
AuthResp {
payload: WlanFullmacImplBaseAuthRespRequest,
responder: WlanFullmacImplBaseAuthRespResponder,
},
Deauth {
payload: WlanFullmacImplBaseDeauthRequest,
responder: WlanFullmacImplBaseDeauthResponder,
},
AssocResp {
payload: WlanFullmacImplBaseAssocRespRequest,
responder: WlanFullmacImplBaseAssocRespResponder,
},
Disassoc {
payload: WlanFullmacImplBaseDisassocRequest,
responder: WlanFullmacImplBaseDisassocResponder,
},
Reset {
payload: WlanFullmacImplBaseResetRequest,
responder: WlanFullmacImplBaseResetResponder,
},
StartBss {
payload: WlanFullmacImplBaseStartBssRequest,
responder: WlanFullmacImplBaseStartBssResponder,
},
StopBss {
payload: WlanFullmacImplBaseStopBssRequest,
responder: WlanFullmacImplBaseStopBssResponder,
},
SetKeysReq {
req: WlanFullmacSetKeysReq,
responder: WlanFullmacImplBaseSetKeysReqResponder,
},
DelKeysReq {
req: WlanFullmacDelKeysReq,
responder: WlanFullmacImplBaseDelKeysReqResponder,
},
EapolTx {
payload: WlanFullmacImplBaseEapolTxRequest,
responder: WlanFullmacImplBaseEapolTxResponder,
},
GetIfaceCounterStats {
responder: WlanFullmacImplBaseGetIfaceCounterStatsResponder,
},
GetIfaceHistogramStats {
responder: WlanFullmacImplBaseGetIfaceHistogramStatsResponder,
},
SaeHandshakeResp {
resp: WlanFullmacSaeHandshakeResp,
responder: WlanFullmacImplBaseSaeHandshakeRespResponder,
},
SaeFrameTx {
frame: WlanFullmacSaeFrame,
responder: WlanFullmacImplBaseSaeFrameTxResponder,
},
WmmStatusReq {
responder: WlanFullmacImplBaseWmmStatusReqResponder,
},
SetMulticastPromisc {
enable: bool,
responder: WlanFullmacImplBaseSetMulticastPromiscResponder,
},
OnLinkStateChanged {
online: bool,
responder: WlanFullmacImplBaseOnLinkStateChangedResponder,
},
}
impl WlanFullmacImplBaseRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_stop(self) -> Option<(WlanFullmacImplBaseStopResponder)> {
if let WlanFullmacImplBaseRequest::Stop { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query(self) -> Option<(WlanFullmacImplBaseQueryResponder)> {
if let WlanFullmacImplBaseRequest::Query { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query_mac_sublayer_support(
self,
) -> Option<(WlanFullmacImplBaseQueryMacSublayerSupportResponder)> {
if let WlanFullmacImplBaseRequest::QueryMacSublayerSupport { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query_security_support(
self,
) -> Option<(WlanFullmacImplBaseQuerySecuritySupportResponder)> {
if let WlanFullmacImplBaseRequest::QuerySecuritySupport { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query_spectrum_management_support(
self,
) -> Option<(WlanFullmacImplBaseQuerySpectrumManagementSupportResponder)> {
if let WlanFullmacImplBaseRequest::QuerySpectrumManagementSupport { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start_scan(
self,
) -> Option<(WlanFullmacImplBaseStartScanRequest, WlanFullmacImplBaseStartScanResponder)> {
if let WlanFullmacImplBaseRequest::StartScan { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect(
self,
) -> Option<(WlanFullmacImplBaseConnectRequest, WlanFullmacImplBaseConnectResponder)> {
if let WlanFullmacImplBaseRequest::Connect { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_reconnect(
self,
) -> Option<(WlanFullmacImplBaseReconnectRequest, WlanFullmacImplBaseReconnectResponder)> {
if let WlanFullmacImplBaseRequest::Reconnect { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_auth_resp(
self,
) -> Option<(WlanFullmacImplBaseAuthRespRequest, WlanFullmacImplBaseAuthRespResponder)> {
if let WlanFullmacImplBaseRequest::AuthResp { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_deauth(
self,
) -> Option<(WlanFullmacImplBaseDeauthRequest, WlanFullmacImplBaseDeauthResponder)> {
if let WlanFullmacImplBaseRequest::Deauth { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_assoc_resp(
self,
) -> Option<(WlanFullmacImplBaseAssocRespRequest, WlanFullmacImplBaseAssocRespResponder)> {
if let WlanFullmacImplBaseRequest::AssocResp { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disassoc(
self,
) -> Option<(WlanFullmacImplBaseDisassocRequest, WlanFullmacImplBaseDisassocResponder)> {
if let WlanFullmacImplBaseRequest::Disassoc { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_reset(
self,
) -> Option<(WlanFullmacImplBaseResetRequest, WlanFullmacImplBaseResetResponder)> {
if let WlanFullmacImplBaseRequest::Reset { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start_bss(
self,
) -> Option<(WlanFullmacImplBaseStartBssRequest, WlanFullmacImplBaseStartBssResponder)> {
if let WlanFullmacImplBaseRequest::StartBss { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_stop_bss(
self,
) -> Option<(WlanFullmacImplBaseStopBssRequest, WlanFullmacImplBaseStopBssResponder)> {
if let WlanFullmacImplBaseRequest::StopBss { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_set_keys_req(
self,
) -> Option<(WlanFullmacSetKeysReq, WlanFullmacImplBaseSetKeysReqResponder)> {
if let WlanFullmacImplBaseRequest::SetKeysReq { req, responder } = self {
Some((req, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_del_keys_req(
self,
) -> Option<(WlanFullmacDelKeysReq, WlanFullmacImplBaseDelKeysReqResponder)> {
if let WlanFullmacImplBaseRequest::DelKeysReq { req, responder } = self {
Some((req, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_eapol_tx(
self,
) -> Option<(WlanFullmacImplBaseEapolTxRequest, WlanFullmacImplBaseEapolTxResponder)> {
if let WlanFullmacImplBaseRequest::EapolTx { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_iface_counter_stats(
self,
) -> Option<(WlanFullmacImplBaseGetIfaceCounterStatsResponder)> {
if let WlanFullmacImplBaseRequest::GetIfaceCounterStats { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_iface_histogram_stats(
self,
) -> Option<(WlanFullmacImplBaseGetIfaceHistogramStatsResponder)> {
if let WlanFullmacImplBaseRequest::GetIfaceHistogramStats { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_handshake_resp(
self,
) -> Option<(WlanFullmacSaeHandshakeResp, WlanFullmacImplBaseSaeHandshakeRespResponder)> {
if let WlanFullmacImplBaseRequest::SaeHandshakeResp { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_frame_tx(
self,
) -> Option<(WlanFullmacSaeFrame, WlanFullmacImplBaseSaeFrameTxResponder)> {
if let WlanFullmacImplBaseRequest::SaeFrameTx { frame, responder } = self {
Some((frame, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_wmm_status_req(self) -> Option<(WlanFullmacImplBaseWmmStatusReqResponder)> {
if let WlanFullmacImplBaseRequest::WmmStatusReq { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_set_multicast_promisc(
self,
) -> Option<(bool, WlanFullmacImplBaseSetMulticastPromiscResponder)> {
if let WlanFullmacImplBaseRequest::SetMulticastPromisc { enable, responder } = self {
Some((enable, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_link_state_changed(
self,
) -> Option<(bool, WlanFullmacImplBaseOnLinkStateChangedResponder)> {
if let WlanFullmacImplBaseRequest::OnLinkStateChanged { online, responder } = self {
Some((online, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
WlanFullmacImplBaseRequest::Stop { .. } => "stop",
WlanFullmacImplBaseRequest::Query { .. } => "query",
WlanFullmacImplBaseRequest::QueryMacSublayerSupport { .. } => {
"query_mac_sublayer_support"
}
WlanFullmacImplBaseRequest::QuerySecuritySupport { .. } => "query_security_support",
WlanFullmacImplBaseRequest::QuerySpectrumManagementSupport { .. } => {
"query_spectrum_management_support"
}
WlanFullmacImplBaseRequest::StartScan { .. } => "start_scan",
WlanFullmacImplBaseRequest::Connect { .. } => "connect",
WlanFullmacImplBaseRequest::Reconnect { .. } => "reconnect",
WlanFullmacImplBaseRequest::AuthResp { .. } => "auth_resp",
WlanFullmacImplBaseRequest::Deauth { .. } => "deauth",
WlanFullmacImplBaseRequest::AssocResp { .. } => "assoc_resp",
WlanFullmacImplBaseRequest::Disassoc { .. } => "disassoc",
WlanFullmacImplBaseRequest::Reset { .. } => "reset",
WlanFullmacImplBaseRequest::StartBss { .. } => "start_bss",
WlanFullmacImplBaseRequest::StopBss { .. } => "stop_bss",
WlanFullmacImplBaseRequest::SetKeysReq { .. } => "set_keys_req",
WlanFullmacImplBaseRequest::DelKeysReq { .. } => "del_keys_req",
WlanFullmacImplBaseRequest::EapolTx { .. } => "eapol_tx",
WlanFullmacImplBaseRequest::GetIfaceCounterStats { .. } => "get_iface_counter_stats",
WlanFullmacImplBaseRequest::GetIfaceHistogramStats { .. } => {
"get_iface_histogram_stats"
}
WlanFullmacImplBaseRequest::SaeHandshakeResp { .. } => "sae_handshake_resp",
WlanFullmacImplBaseRequest::SaeFrameTx { .. } => "sae_frame_tx",
WlanFullmacImplBaseRequest::WmmStatusReq { .. } => "wmm_status_req",
WlanFullmacImplBaseRequest::SetMulticastPromisc { .. } => "set_multicast_promisc",
WlanFullmacImplBaseRequest::OnLinkStateChanged { .. } => "on_link_state_changed",
}
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplBaseControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for WlanFullmacImplBaseControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
}
impl WlanFullmacImplBaseControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseStopResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseStopResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseStopResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseStopResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3f2685c8371251e6,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseQueryResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseQueryResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseQueryResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseQueryResponder {
pub fn send(self, mut result: Result<&WlanFullmacQueryInfo, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&WlanFullmacQueryInfo, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<&WlanFullmacQueryInfo, i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<WlanFullmacImplBaseQueryResponse, i32>>(
result.map(|info| (info,)),
self.tx_id,
0x16b5144d67f27eb9,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseQueryMacSublayerSupportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseQueryMacSublayerSupportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseQueryMacSublayerSupportResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseQueryMacSublayerSupportResponder {
pub fn send(
self,
mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseQueryMacSublayerSupportResponse,
i32,
>>(
result.map(|resp| (resp,)),
self.tx_id,
0x209b5ff943ebf049,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseQuerySecuritySupportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseQuerySecuritySupportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseQuerySecuritySupportResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseQuerySecuritySupportResponder {
pub fn send(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySecuritySupportResponse,
i32,
>>(
result.map(|resp| (resp,)),
self.tx_id,
0x1a5d8312c882fcba,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseQuerySpectrumManagementSupportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseQuerySpectrumManagementSupportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseQuerySpectrumManagementSupportResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseQuerySpectrumManagementSupportResponder {
pub fn send(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySpectrumManagementSupportResponse,
i32,
>>(
result.map(|resp| (resp,)),
self.tx_id,
0x4b9f43e3dfabee9e,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseStartScanResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseStartScanResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseStartScanResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseStartScanResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3dc452902af23757,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseConnectResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseConnectResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseConnectResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseConnectResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x684dd78a0c9ebd2a,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseReconnectResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseReconnectResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseReconnectResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseReconnectResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x75259e6d9fa05df1,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseAuthRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseAuthRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseAuthRespResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseAuthRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x558fac0bd6e468bd,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseDeauthResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseDeauthResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseDeauthResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseDeauthResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3e573f78a0343e2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseAssocRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseAssocRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseAssocRespResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseAssocRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x7626d6d9e6fce311,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseDisassocResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseDisassocResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseDisassocResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseDisassocResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x14b5190abdb17230,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseResetResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseResetResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseResetResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseResetResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x37d8cfd378d3913a,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseStartBssResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseStartBssResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseStartBssResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseStartBssResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x337435c3055da80f,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseStopBssResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseStopBssResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseStopBssResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseStopBssResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x61cf5a6b75a25189,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseSetKeysReqResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseSetKeysReqResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseSetKeysReqResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseSetKeysReqResponder {
pub fn send(self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
let _result = self.send_raw(resp);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut resp: &WlanFullmacSetKeysResp,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(resp);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<WlanFullmacImplBaseSetKeysReqResponse>(
(resp,),
self.tx_id,
0x6b96f84f264f3b4d,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseDelKeysReqResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseDelKeysReqResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseDelKeysReqResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseDelKeysReqResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x7e2981344e041440,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseEapolTxResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseEapolTxResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseEapolTxResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseEapolTxResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x44b71768115d3494,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseGetIfaceCounterStatsResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseGetIfaceCounterStatsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseGetIfaceCounterStatsResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseGetIfaceCounterStatsResponder {
pub fn send(
self,
mut result: Result<&WlanFullmacIfaceCounterStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&WlanFullmacIfaceCounterStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&WlanFullmacIfaceCounterStats, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceCounterStatsResponse,
i32,
>>(
result.map(|stats| (stats,)),
self.tx_id,
0xe5e9c7bb1e7f576,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseGetIfaceHistogramStatsResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseGetIfaceHistogramStatsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseGetIfaceHistogramStatsResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseGetIfaceHistogramStatsResponder {
pub fn send(
self,
mut result: Result<&WlanFullmacIfaceHistogramStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&WlanFullmacIfaceHistogramStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&WlanFullmacIfaceHistogramStats, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceHistogramStatsResponse,
i32,
>>(
result.map(|stats| (stats,)),
self.tx_id,
0x57cfab227d48967d,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseSaeHandshakeRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseSaeHandshakeRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseSaeHandshakeRespResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseSaeHandshakeRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x5be2c56442ea8a26,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseSaeFrameTxResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseSaeFrameTxResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseSaeFrameTxResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseSaeFrameTxResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x8e00b54858b3d26,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseWmmStatusReqResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseWmmStatusReqResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseWmmStatusReqResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseWmmStatusReqResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x4361a32fb2c5f09,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseSetMulticastPromiscResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseSetMulticastPromiscResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseSetMulticastPromiscResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseSetMulticastPromiscResponder {
pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
result,
self.tx_id,
0x13c926de05ad8101,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBaseOnLinkStateChangedResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBaseOnLinkStateChangedResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBaseOnLinkStateChangedResponder {
type ControlHandle = WlanFullmacImplBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBaseOnLinkStateChangedResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x466007ff40a1efa2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct WlanFullmacImplBridgeMarker;
impl fidl::endpoints::ProtocolMarker for WlanFullmacImplBridgeMarker {
type Proxy = WlanFullmacImplBridgeProxy;
type RequestStream = WlanFullmacImplBridgeRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = WlanFullmacImplBridgeSynchronousProxy;
const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImplBridge";
}
impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImplBridgeMarker {}
pub type WlanFullmacImplBridgeStartResult = Result<fidl::Channel, i32>;
pub trait WlanFullmacImplBridgeProxyInterface: Send + Sync {
type StopResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#stop(&self) -> Self::StopResponseFut;
type QueryResponseFut: std::future::Future<Output = Result<WlanFullmacImplBaseQueryResult, fidl::Error>>
+ Send;
fn r#query(&self) -> Self::QueryResponseFut;
type QueryMacSublayerSupportResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseQueryMacSublayerSupportResult, fidl::Error>,
> + Send;
fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut;
type QuerySecuritySupportResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseQuerySecuritySupportResult, fidl::Error>,
> + Send;
fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut;
type QuerySpectrumManagementSupportResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseQuerySpectrumManagementSupportResult, fidl::Error>,
> + Send;
fn r#query_spectrum_management_support(
&self,
) -> Self::QuerySpectrumManagementSupportResponseFut;
type StartScanResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#start_scan(
&self,
payload: &WlanFullmacImplBaseStartScanRequest,
) -> Self::StartScanResponseFut;
type ConnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#connect(&self, payload: &WlanFullmacImplBaseConnectRequest) -> Self::ConnectResponseFut;
type ReconnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#reconnect(
&self,
payload: &WlanFullmacImplBaseReconnectRequest,
) -> Self::ReconnectResponseFut;
type AuthRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#auth_resp(
&self,
payload: &WlanFullmacImplBaseAuthRespRequest,
) -> Self::AuthRespResponseFut;
type DeauthResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#deauth(&self, payload: &WlanFullmacImplBaseDeauthRequest) -> Self::DeauthResponseFut;
type AssocRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#assoc_resp(
&self,
payload: &WlanFullmacImplBaseAssocRespRequest,
) -> Self::AssocRespResponseFut;
type DisassocResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#disassoc(&self, payload: &WlanFullmacImplBaseDisassocRequest)
-> Self::DisassocResponseFut;
type ResetResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#reset(&self, payload: &WlanFullmacImplBaseResetRequest) -> Self::ResetResponseFut;
type StartBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#start_bss(
&self,
payload: &WlanFullmacImplBaseStartBssRequest,
) -> Self::StartBssResponseFut;
type StopBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#stop_bss(&self, payload: &WlanFullmacImplBaseStopBssRequest) -> Self::StopBssResponseFut;
type SetKeysReqResponseFut: std::future::Future<Output = Result<WlanFullmacSetKeysResp, fidl::Error>>
+ Send;
fn r#set_keys_req(&self, req: &WlanFullmacSetKeysReq) -> Self::SetKeysReqResponseFut;
type DelKeysReqResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#del_keys_req(&self, req: &WlanFullmacDelKeysReq) -> Self::DelKeysReqResponseFut;
type EapolTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#eapol_tx(&self, payload: &WlanFullmacImplBaseEapolTxRequest) -> Self::EapolTxResponseFut;
type GetIfaceCounterStatsResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseGetIfaceCounterStatsResult, fidl::Error>,
> + Send;
fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut;
type GetIfaceHistogramStatsResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseGetIfaceHistogramStatsResult, fidl::Error>,
> + Send;
fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut;
type SaeHandshakeRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_handshake_resp(
&self,
resp: &WlanFullmacSaeHandshakeResp,
) -> Self::SaeHandshakeRespResponseFut;
type SaeFrameTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_frame_tx(&self, frame: &WlanFullmacSaeFrame) -> Self::SaeFrameTxResponseFut;
type WmmStatusReqResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut;
type SetMulticastPromiscResponseFut: std::future::Future<
Output = Result<WlanFullmacImplBaseSetMulticastPromiscResult, fidl::Error>,
> + Send;
fn r#set_multicast_promisc(&self, enable: bool) -> Self::SetMulticastPromiscResponseFut;
type OnLinkStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_link_state_changed(&self, online: bool) -> Self::OnLinkStateChangedResponseFut;
type StartResponseFut: std::future::Future<Output = Result<WlanFullmacImplBridgeStartResult, fidl::Error>>
+ Send;
fn r#start(
&self,
ifc: fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanFullmacImplBridgeSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanFullmacImplBridgeSynchronousProxy {
type Proxy = WlanFullmacImplBridgeProxy;
type Protocol = WlanFullmacImplBridgeMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl WlanFullmacImplBridgeSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<WlanFullmacImplBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
pub fn wait_for_event(
&self,
deadline: zx::Time,
) -> Result<WlanFullmacImplBridgeEvent, fidl::Error> {
WlanFullmacImplBridgeEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#stop(&self, ___deadline: zx::Time) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x3f2685c8371251e6,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#query(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQueryResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<WlanFullmacImplBaseQueryResponse, i32>,
>(
(),
0x16b5144d67f27eb9,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.info))
}
pub fn r#query_mac_sublayer_support(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQueryMacSublayerSupportResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseQueryMacSublayerSupportResponse,
i32,
>>(
(),
0x209b5ff943ebf049,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.resp))
}
pub fn r#query_security_support(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQuerySecuritySupportResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySecuritySupportResponse,
i32,
>>(
(),
0x1a5d8312c882fcba,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.resp))
}
pub fn r#query_spectrum_management_support(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseQuerySpectrumManagementSupportResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySpectrumManagementSupportResponse,
i32,
>>(
(), 0x4b9f43e3dfabee9e, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x.resp))
}
pub fn r#start_scan(
&self,
mut payload: &WlanFullmacImplBaseStartScanRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseStartScanRequest, fidl::encoding::EmptyPayload>(
payload,
0x3dc452902af23757,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#connect(
&self,
mut payload: &WlanFullmacImplBaseConnectRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseConnectRequest, fidl::encoding::EmptyPayload>(
payload,
0x684dd78a0c9ebd2a,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#reconnect(
&self,
mut payload: &WlanFullmacImplBaseReconnectRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseReconnectRequest, fidl::encoding::EmptyPayload>(
payload,
0x75259e6d9fa05df1,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#auth_resp(
&self,
mut payload: &WlanFullmacImplBaseAuthRespRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseAuthRespRequest, fidl::encoding::EmptyPayload>(
payload,
0x558fac0bd6e468bd,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#deauth(
&self,
mut payload: &WlanFullmacImplBaseDeauthRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseDeauthRequest, fidl::encoding::EmptyPayload>(
payload,
0x3e573f78a0343e2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#assoc_resp(
&self,
mut payload: &WlanFullmacImplBaseAssocRespRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseAssocRespRequest, fidl::encoding::EmptyPayload>(
payload,
0x7626d6d9e6fce311,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#disassoc(
&self,
mut payload: &WlanFullmacImplBaseDisassocRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseDisassocRequest, fidl::encoding::EmptyPayload>(
payload,
0x14b5190abdb17230,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#reset(
&self,
mut payload: &WlanFullmacImplBaseResetRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseResetRequest, fidl::encoding::EmptyPayload>(
payload,
0x37d8cfd378d3913a,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#start_bss(
&self,
mut payload: &WlanFullmacImplBaseStartBssRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseStartBssRequest, fidl::encoding::EmptyPayload>(
payload,
0x337435c3055da80f,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#stop_bss(
&self,
mut payload: &WlanFullmacImplBaseStopBssRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseStopBssRequest, fidl::encoding::EmptyPayload>(
payload,
0x61cf5a6b75a25189,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#set_keys_req(
&self,
mut req: &WlanFullmacSetKeysReq,
___deadline: zx::Time,
) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBaseSetKeysReqRequest,
WlanFullmacImplBaseSetKeysReqResponse,
>(
(req,),
0x6b96f84f264f3b4d,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.resp)
}
pub fn r#del_keys_req(
&self,
mut req: &WlanFullmacDelKeysReq,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseDelKeysReqRequest, fidl::encoding::EmptyPayload>(
(req,),
0x7e2981344e041440,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#eapol_tx(
&self,
mut payload: &WlanFullmacImplBaseEapolTxRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseEapolTxRequest, fidl::encoding::EmptyPayload>(
payload,
0x44b71768115d3494,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#get_iface_counter_stats(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseGetIfaceCounterStatsResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceCounterStatsResponse,
i32,
>>(
(),
0xe5e9c7bb1e7f576,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.stats))
}
pub fn r#get_iface_histogram_stats(
&self,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseGetIfaceHistogramStatsResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceHistogramStatsResponse,
i32,
>>(
(),
0x57cfab227d48967d,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.stats))
}
pub fn r#sae_handshake_resp(
&self,
mut resp: &WlanFullmacSaeHandshakeResp,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseSaeHandshakeRespRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x5be2c56442ea8a26,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#sae_frame_tx(
&self,
mut frame: &WlanFullmacSaeFrame,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplBaseSaeFrameTxRequest, fidl::encoding::EmptyPayload>(
(frame,),
0x8e00b54858b3d26,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#wmm_status_req(&self, ___deadline: zx::Time) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x4361a32fb2c5f09,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#set_multicast_promisc(
&self,
mut enable: bool,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBaseSetMulticastPromiscResult, fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBaseSetMulticastPromiscRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(enable,),
0x13c926de05ad8101,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#on_link_state_changed(
&self,
mut online: bool,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBaseOnLinkStateChangedRequest,
fidl::encoding::EmptyPayload,
>(
(online,),
0x466007ff40a1efa2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#start(
&self,
mut ifc: fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
___deadline: zx::Time,
) -> Result<WlanFullmacImplBridgeStartResult, fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplBridgeStartRequest,
fidl::encoding::ResultType<WlanFullmacImplBridgeStartResponse, i32>,
>(
(ifc,),
0x36d8ff13a418035f,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.sme_channel))
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplBridgeProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for WlanFullmacImplBridgeProxy {
type Protocol = WlanFullmacImplBridgeMarker;
fn from_channel(inner: fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl WlanFullmacImplBridgeProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<WlanFullmacImplBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> WlanFullmacImplBridgeEventStream {
WlanFullmacImplBridgeEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#stop(&self) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#stop(self)
}
pub fn r#query(&self) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryResult> {
WlanFullmacImplBridgeProxyInterface::r#query(self)
}
pub fn r#query_mac_sublayer_support(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryMacSublayerSupportResult> {
WlanFullmacImplBridgeProxyInterface::r#query_mac_sublayer_support(self)
}
pub fn r#query_security_support(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySecuritySupportResult> {
WlanFullmacImplBridgeProxyInterface::r#query_security_support(self)
}
pub fn r#query_spectrum_management_support(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySpectrumManagementSupportResult>
{
WlanFullmacImplBridgeProxyInterface::r#query_spectrum_management_support(self)
}
pub fn r#start_scan(
&self,
mut payload: &WlanFullmacImplBaseStartScanRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#start_scan(self, payload)
}
pub fn r#connect(
&self,
mut payload: &WlanFullmacImplBaseConnectRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#connect(self, payload)
}
pub fn r#reconnect(
&self,
mut payload: &WlanFullmacImplBaseReconnectRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#reconnect(self, payload)
}
pub fn r#auth_resp(
&self,
mut payload: &WlanFullmacImplBaseAuthRespRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#auth_resp(self, payload)
}
pub fn r#deauth(
&self,
mut payload: &WlanFullmacImplBaseDeauthRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#deauth(self, payload)
}
pub fn r#assoc_resp(
&self,
mut payload: &WlanFullmacImplBaseAssocRespRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#assoc_resp(self, payload)
}
pub fn r#disassoc(
&self,
mut payload: &WlanFullmacImplBaseDisassocRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#disassoc(self, payload)
}
pub fn r#reset(
&self,
mut payload: &WlanFullmacImplBaseResetRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#reset(self, payload)
}
pub fn r#start_bss(
&self,
mut payload: &WlanFullmacImplBaseStartBssRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#start_bss(self, payload)
}
pub fn r#stop_bss(
&self,
mut payload: &WlanFullmacImplBaseStopBssRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#stop_bss(self, payload)
}
pub fn r#set_keys_req(
&self,
mut req: &WlanFullmacSetKeysReq,
) -> fidl::client::QueryResponseFut<WlanFullmacSetKeysResp> {
WlanFullmacImplBridgeProxyInterface::r#set_keys_req(self, req)
}
pub fn r#del_keys_req(
&self,
mut req: &WlanFullmacDelKeysReq,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#del_keys_req(self, req)
}
pub fn r#eapol_tx(
&self,
mut payload: &WlanFullmacImplBaseEapolTxRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#eapol_tx(self, payload)
}
pub fn r#get_iface_counter_stats(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceCounterStatsResult> {
WlanFullmacImplBridgeProxyInterface::r#get_iface_counter_stats(self)
}
pub fn r#get_iface_histogram_stats(
&self,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceHistogramStatsResult> {
WlanFullmacImplBridgeProxyInterface::r#get_iface_histogram_stats(self)
}
pub fn r#sae_handshake_resp(
&self,
mut resp: &WlanFullmacSaeHandshakeResp,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#sae_handshake_resp(self, resp)
}
pub fn r#sae_frame_tx(
&self,
mut frame: &WlanFullmacSaeFrame,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#sae_frame_tx(self, frame)
}
pub fn r#wmm_status_req(&self) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#wmm_status_req(self)
}
pub fn r#set_multicast_promisc(
&self,
mut enable: bool,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBaseSetMulticastPromiscResult> {
WlanFullmacImplBridgeProxyInterface::r#set_multicast_promisc(self, enable)
}
pub fn r#on_link_state_changed(&self, mut online: bool) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplBridgeProxyInterface::r#on_link_state_changed(self, online)
}
pub fn r#start(
&self,
mut ifc: fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
) -> fidl::client::QueryResponseFut<WlanFullmacImplBridgeStartResult> {
WlanFullmacImplBridgeProxyInterface::r#start(self, ifc)
}
}
impl WlanFullmacImplBridgeProxyInterface for WlanFullmacImplBridgeProxy {
type StopResponseFut = fidl::client::QueryResponseFut<()>;
fn r#stop(&self) -> Self::StopResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3f2685c8371251e6,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x3f2685c8371251e6,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QueryResponseFut = fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryResult>;
fn r#query(&self) -> Self::QueryResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQueryResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseQueryResponse, i32>,
0x16b5144d67f27eb9,
>(_buf?)?;
Ok(_response.map(|x| x.info))
}
self.client
.send_query_and_decode::<fidl::encoding::EmptyPayload, WlanFullmacImplBaseQueryResult>(
(),
0x16b5144d67f27eb9,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QueryMacSublayerSupportResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseQueryMacSublayerSupportResult>;
fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQueryMacSublayerSupportResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseQueryMacSublayerSupportResponse, i32>,
0x209b5ff943ebf049,
>(_buf?)?;
Ok(_response.map(|x| x.resp))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseQueryMacSublayerSupportResult,
>(
(),
0x209b5ff943ebf049,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QuerySecuritySupportResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySecuritySupportResult>;
fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQuerySecuritySupportResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseQuerySecuritySupportResponse, i32>,
0x1a5d8312c882fcba,
>(_buf?)?;
Ok(_response.map(|x| x.resp))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseQuerySecuritySupportResult,
>(
(),
0x1a5d8312c882fcba,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type QuerySpectrumManagementSupportResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseQuerySpectrumManagementSupportResult>;
fn r#query_spectrum_management_support(
&self,
) -> Self::QuerySpectrumManagementSupportResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseQuerySpectrumManagementSupportResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySpectrumManagementSupportResponse,
i32,
>,
0x4b9f43e3dfabee9e,
>(_buf?)?;
Ok(_response.map(|x| x.resp))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseQuerySpectrumManagementSupportResult,
>(
(),
0x4b9f43e3dfabee9e,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartScanResponseFut = fidl::client::QueryResponseFut<()>;
fn r#start_scan(
&self,
mut payload: &WlanFullmacImplBaseStartScanRequest,
) -> Self::StartScanResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3dc452902af23757,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseStartScanRequest, ()>(
payload,
0x3dc452902af23757,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ConnectResponseFut = fidl::client::QueryResponseFut<()>;
fn r#connect(
&self,
mut payload: &WlanFullmacImplBaseConnectRequest,
) -> Self::ConnectResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x684dd78a0c9ebd2a,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseConnectRequest, ()>(
payload,
0x684dd78a0c9ebd2a,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ReconnectResponseFut = fidl::client::QueryResponseFut<()>;
fn r#reconnect(
&self,
mut payload: &WlanFullmacImplBaseReconnectRequest,
) -> Self::ReconnectResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x75259e6d9fa05df1,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseReconnectRequest, ()>(
payload,
0x75259e6d9fa05df1,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AuthRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#auth_resp(
&self,
mut payload: &WlanFullmacImplBaseAuthRespRequest,
) -> Self::AuthRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x558fac0bd6e468bd,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseAuthRespRequest, ()>(
payload,
0x558fac0bd6e468bd,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DeauthResponseFut = fidl::client::QueryResponseFut<()>;
fn r#deauth(&self, mut payload: &WlanFullmacImplBaseDeauthRequest) -> Self::DeauthResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3e573f78a0343e2,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseDeauthRequest, ()>(
payload,
0x3e573f78a0343e2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AssocRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#assoc_resp(
&self,
mut payload: &WlanFullmacImplBaseAssocRespRequest,
) -> Self::AssocRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x7626d6d9e6fce311,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseAssocRespRequest, ()>(
payload,
0x7626d6d9e6fce311,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisassocResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disassoc(
&self,
mut payload: &WlanFullmacImplBaseDisassocRequest,
) -> Self::DisassocResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x14b5190abdb17230,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseDisassocRequest, ()>(
payload,
0x14b5190abdb17230,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ResetResponseFut = fidl::client::QueryResponseFut<()>;
fn r#reset(&self, mut payload: &WlanFullmacImplBaseResetRequest) -> Self::ResetResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x37d8cfd378d3913a,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseResetRequest, ()>(
payload,
0x37d8cfd378d3913a,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartBssResponseFut = fidl::client::QueryResponseFut<()>;
fn r#start_bss(
&self,
mut payload: &WlanFullmacImplBaseStartBssRequest,
) -> Self::StartBssResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x337435c3055da80f,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseStartBssRequest, ()>(
payload,
0x337435c3055da80f,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StopBssResponseFut = fidl::client::QueryResponseFut<()>;
fn r#stop_bss(
&self,
mut payload: &WlanFullmacImplBaseStopBssRequest,
) -> Self::StopBssResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x61cf5a6b75a25189,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseStopBssRequest, ()>(
payload,
0x61cf5a6b75a25189,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SetKeysReqResponseFut = fidl::client::QueryResponseFut<WlanFullmacSetKeysResp>;
fn r#set_keys_req(&self, mut req: &WlanFullmacSetKeysReq) -> Self::SetKeysReqResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
WlanFullmacImplBaseSetKeysReqResponse,
0x6b96f84f264f3b4d,
>(_buf?)?;
Ok(_response.resp)
}
self.client
.send_query_and_decode::<WlanFullmacImplBaseSetKeysReqRequest, WlanFullmacSetKeysResp>(
(req,),
0x6b96f84f264f3b4d,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DelKeysReqResponseFut = fidl::client::QueryResponseFut<()>;
fn r#del_keys_req(&self, mut req: &WlanFullmacDelKeysReq) -> Self::DelKeysReqResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x7e2981344e041440,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseDelKeysReqRequest, ()>(
(req,),
0x7e2981344e041440,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type EapolTxResponseFut = fidl::client::QueryResponseFut<()>;
fn r#eapol_tx(
&self,
mut payload: &WlanFullmacImplBaseEapolTxRequest,
) -> Self::EapolTxResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x44b71768115d3494,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseEapolTxRequest, ()>(
payload,
0x44b71768115d3494,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetIfaceCounterStatsResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceCounterStatsResult>;
fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseGetIfaceCounterStatsResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseGetIfaceCounterStatsResponse, i32>,
0xe5e9c7bb1e7f576,
>(_buf?)?;
Ok(_response.map(|x| x.stats))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseGetIfaceCounterStatsResult,
>(
(),
0xe5e9c7bb1e7f576,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetIfaceHistogramStatsResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseGetIfaceHistogramStatsResult>;
fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseGetIfaceHistogramStatsResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBaseGetIfaceHistogramStatsResponse, i32>,
0x57cfab227d48967d,
>(_buf?)?;
Ok(_response.map(|x| x.stats))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
WlanFullmacImplBaseGetIfaceHistogramStatsResult,
>(
(),
0x57cfab227d48967d,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeHandshakeRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_handshake_resp(
&self,
mut resp: &WlanFullmacSaeHandshakeResp,
) -> Self::SaeHandshakeRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x5be2c56442ea8a26,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseSaeHandshakeRespRequest, ()>(
(resp,),
0x5be2c56442ea8a26,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeFrameTxResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_frame_tx(&self, mut frame: &WlanFullmacSaeFrame) -> Self::SaeFrameTxResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x8e00b54858b3d26,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseSaeFrameTxRequest, ()>(
(frame,),
0x8e00b54858b3d26,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type WmmStatusReqResponseFut = fidl::client::QueryResponseFut<()>;
fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x4361a32fb2c5f09,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x4361a32fb2c5f09,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SetMulticastPromiscResponseFut =
fidl::client::QueryResponseFut<WlanFullmacImplBaseSetMulticastPromiscResult>;
fn r#set_multicast_promisc(&self, mut enable: bool) -> Self::SetMulticastPromiscResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBaseSetMulticastPromiscResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x13c926de05ad8101,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
WlanFullmacImplBaseSetMulticastPromiscRequest,
WlanFullmacImplBaseSetMulticastPromiscResult,
>(
(enable,),
0x13c926de05ad8101,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnLinkStateChangedResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_link_state_changed(&self, mut online: bool) -> Self::OnLinkStateChangedResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x466007ff40a1efa2,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplBaseOnLinkStateChangedRequest, ()>(
(online,),
0x466007ff40a1efa2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartResponseFut = fidl::client::QueryResponseFut<WlanFullmacImplBridgeStartResult>;
fn r#start(
&self,
mut ifc: fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
) -> Self::StartResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<WlanFullmacImplBridgeStartResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<WlanFullmacImplBridgeStartResponse, i32>,
0x36d8ff13a418035f,
>(_buf?)?;
Ok(_response.map(|x| x.sme_channel))
}
self.client.send_query_and_decode::<
WlanFullmacImplBridgeStartRequest,
WlanFullmacImplBridgeStartResult,
>(
(ifc,),
0x36d8ff13a418035f,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct WlanFullmacImplBridgeEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for WlanFullmacImplBridgeEventStream {}
impl futures::stream::FusedStream for WlanFullmacImplBridgeEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for WlanFullmacImplBridgeEventStream {
type Item = Result<WlanFullmacImplBridgeEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImplBridgeEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum WlanFullmacImplBridgeEvent {}
impl WlanFullmacImplBridgeEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<WlanFullmacImplBridgeEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<WlanFullmacImplBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct WlanFullmacImplBridgeRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for WlanFullmacImplBridgeRequestStream {}
impl futures::stream::FusedStream for WlanFullmacImplBridgeRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for WlanFullmacImplBridgeRequestStream {
type Protocol = WlanFullmacImplBridgeMarker;
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn from_channel(channel: fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
WlanFullmacImplBridgeControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for WlanFullmacImplBridgeRequestStream {
type Item = Result<WlanFullmacImplBridgeRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled WlanFullmacImplBridgeRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x3f2685c8371251e6 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Stop {
responder: WlanFullmacImplBridgeStopResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x16b5144d67f27eb9 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Query {
responder: WlanFullmacImplBridgeQueryResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x209b5ff943ebf049 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::QueryMacSublayerSupport {
responder: WlanFullmacImplBridgeQueryMacSublayerSupportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1a5d8312c882fcba => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::QuerySecuritySupport {
responder: WlanFullmacImplBridgeQuerySecuritySupportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4b9f43e3dfabee9e => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::QuerySpectrumManagementSupport {
responder: WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3dc452902af23757 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseStartScanRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseStartScanRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::StartScan {
payload: req,
responder: WlanFullmacImplBridgeStartScanResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x684dd78a0c9ebd2a => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseConnectRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseConnectRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Connect {
payload: req,
responder: WlanFullmacImplBridgeConnectResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x75259e6d9fa05df1 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseReconnectRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseReconnectRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Reconnect {
payload: req,
responder: WlanFullmacImplBridgeReconnectResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x558fac0bd6e468bd => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseAuthRespRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseAuthRespRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::AuthResp {
payload: req,
responder: WlanFullmacImplBridgeAuthRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3e573f78a0343e2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseDeauthRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseDeauthRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Deauth {
payload: req,
responder: WlanFullmacImplBridgeDeauthResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7626d6d9e6fce311 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseAssocRespRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseAssocRespRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::AssocResp {
payload: req,
responder: WlanFullmacImplBridgeAssocRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x14b5190abdb17230 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseDisassocRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseDisassocRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Disassoc {
payload: req,
responder: WlanFullmacImplBridgeDisassocResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x37d8cfd378d3913a => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseResetRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseResetRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Reset {
payload: req,
responder: WlanFullmacImplBridgeResetResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x337435c3055da80f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseStartBssRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseStartBssRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::StartBss {
payload: req,
responder: WlanFullmacImplBridgeStartBssResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x61cf5a6b75a25189 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseStopBssRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseStopBssRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::StopBss {
payload: req,
responder: WlanFullmacImplBridgeStopBssResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6b96f84f264f3b4d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSetKeysReqRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseSetKeysReqRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::SetKeysReq {
req: req.req,
responder: WlanFullmacImplBridgeSetKeysReqResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7e2981344e041440 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseDelKeysReqRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseDelKeysReqRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::DelKeysReq {
req: req.req,
responder: WlanFullmacImplBridgeDelKeysReqResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x44b71768115d3494 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseEapolTxRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseEapolTxRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::EapolTx {
payload: req,
responder: WlanFullmacImplBridgeEapolTxResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xe5e9c7bb1e7f576 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::GetIfaceCounterStats {
responder: WlanFullmacImplBridgeGetIfaceCounterStatsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x57cfab227d48967d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::GetIfaceHistogramStats {
responder: WlanFullmacImplBridgeGetIfaceHistogramStatsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5be2c56442ea8a26 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSaeHandshakeRespRequest);
fidl::encoding::Decoder::decode_into::<
WlanFullmacImplBaseSaeHandshakeRespRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::SaeHandshakeResp {
resp: req.resp,
responder: WlanFullmacImplBridgeSaeHandshakeRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x8e00b54858b3d26 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSaeFrameTxRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBaseSaeFrameTxRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::SaeFrameTx {
frame: req.frame,
responder: WlanFullmacImplBridgeSaeFrameTxResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4361a32fb2c5f09 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::WmmStatusReq {
responder: WlanFullmacImplBridgeWmmStatusReqResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x13c926de05ad8101 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseSetMulticastPromiscRequest);
fidl::encoding::Decoder::decode_into::<
WlanFullmacImplBaseSetMulticastPromiscRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::SetMulticastPromisc {
enable: req.enable,
responder: WlanFullmacImplBridgeSetMulticastPromiscResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x466007ff40a1efa2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBaseOnLinkStateChangedRequest);
fidl::encoding::Decoder::decode_into::<
WlanFullmacImplBaseOnLinkStateChangedRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::OnLinkStateChanged {
online: req.online,
responder: WlanFullmacImplBridgeOnLinkStateChangedResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x36d8ff13a418035f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplBridgeStartRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplBridgeStartRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
WlanFullmacImplBridgeControlHandle { inner: this.inner.clone() };
Ok(WlanFullmacImplBridgeRequest::Start {
ifc: req.ifc,
responder: WlanFullmacImplBridgeStartResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<WlanFullmacImplBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum WlanFullmacImplBridgeRequest {
Stop {
responder: WlanFullmacImplBridgeStopResponder,
},
Query {
responder: WlanFullmacImplBridgeQueryResponder,
},
QueryMacSublayerSupport {
responder: WlanFullmacImplBridgeQueryMacSublayerSupportResponder,
},
QuerySecuritySupport {
responder: WlanFullmacImplBridgeQuerySecuritySupportResponder,
},
QuerySpectrumManagementSupport {
responder: WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder,
},
StartScan {
payload: WlanFullmacImplBaseStartScanRequest,
responder: WlanFullmacImplBridgeStartScanResponder,
},
Connect {
payload: WlanFullmacImplBaseConnectRequest,
responder: WlanFullmacImplBridgeConnectResponder,
},
Reconnect {
payload: WlanFullmacImplBaseReconnectRequest,
responder: WlanFullmacImplBridgeReconnectResponder,
},
AuthResp {
payload: WlanFullmacImplBaseAuthRespRequest,
responder: WlanFullmacImplBridgeAuthRespResponder,
},
Deauth {
payload: WlanFullmacImplBaseDeauthRequest,
responder: WlanFullmacImplBridgeDeauthResponder,
},
AssocResp {
payload: WlanFullmacImplBaseAssocRespRequest,
responder: WlanFullmacImplBridgeAssocRespResponder,
},
Disassoc {
payload: WlanFullmacImplBaseDisassocRequest,
responder: WlanFullmacImplBridgeDisassocResponder,
},
Reset {
payload: WlanFullmacImplBaseResetRequest,
responder: WlanFullmacImplBridgeResetResponder,
},
StartBss {
payload: WlanFullmacImplBaseStartBssRequest,
responder: WlanFullmacImplBridgeStartBssResponder,
},
StopBss {
payload: WlanFullmacImplBaseStopBssRequest,
responder: WlanFullmacImplBridgeStopBssResponder,
},
SetKeysReq {
req: WlanFullmacSetKeysReq,
responder: WlanFullmacImplBridgeSetKeysReqResponder,
},
DelKeysReq {
req: WlanFullmacDelKeysReq,
responder: WlanFullmacImplBridgeDelKeysReqResponder,
},
EapolTx {
payload: WlanFullmacImplBaseEapolTxRequest,
responder: WlanFullmacImplBridgeEapolTxResponder,
},
GetIfaceCounterStats {
responder: WlanFullmacImplBridgeGetIfaceCounterStatsResponder,
},
GetIfaceHistogramStats {
responder: WlanFullmacImplBridgeGetIfaceHistogramStatsResponder,
},
SaeHandshakeResp {
resp: WlanFullmacSaeHandshakeResp,
responder: WlanFullmacImplBridgeSaeHandshakeRespResponder,
},
SaeFrameTx {
frame: WlanFullmacSaeFrame,
responder: WlanFullmacImplBridgeSaeFrameTxResponder,
},
WmmStatusReq {
responder: WlanFullmacImplBridgeWmmStatusReqResponder,
},
SetMulticastPromisc {
enable: bool,
responder: WlanFullmacImplBridgeSetMulticastPromiscResponder,
},
OnLinkStateChanged {
online: bool,
responder: WlanFullmacImplBridgeOnLinkStateChangedResponder,
},
Start {
ifc: fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
responder: WlanFullmacImplBridgeStartResponder,
},
}
impl WlanFullmacImplBridgeRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_stop(self) -> Option<(WlanFullmacImplBridgeStopResponder)> {
if let WlanFullmacImplBridgeRequest::Stop { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query(self) -> Option<(WlanFullmacImplBridgeQueryResponder)> {
if let WlanFullmacImplBridgeRequest::Query { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query_mac_sublayer_support(
self,
) -> Option<(WlanFullmacImplBridgeQueryMacSublayerSupportResponder)> {
if let WlanFullmacImplBridgeRequest::QueryMacSublayerSupport { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query_security_support(
self,
) -> Option<(WlanFullmacImplBridgeQuerySecuritySupportResponder)> {
if let WlanFullmacImplBridgeRequest::QuerySecuritySupport { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_query_spectrum_management_support(
self,
) -> Option<(WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder)> {
if let WlanFullmacImplBridgeRequest::QuerySpectrumManagementSupport { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start_scan(
self,
) -> Option<(WlanFullmacImplBaseStartScanRequest, WlanFullmacImplBridgeStartScanResponder)>
{
if let WlanFullmacImplBridgeRequest::StartScan { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect(
self,
) -> Option<(WlanFullmacImplBaseConnectRequest, WlanFullmacImplBridgeConnectResponder)> {
if let WlanFullmacImplBridgeRequest::Connect { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_reconnect(
self,
) -> Option<(WlanFullmacImplBaseReconnectRequest, WlanFullmacImplBridgeReconnectResponder)>
{
if let WlanFullmacImplBridgeRequest::Reconnect { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_auth_resp(
self,
) -> Option<(WlanFullmacImplBaseAuthRespRequest, WlanFullmacImplBridgeAuthRespResponder)> {
if let WlanFullmacImplBridgeRequest::AuthResp { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_deauth(
self,
) -> Option<(WlanFullmacImplBaseDeauthRequest, WlanFullmacImplBridgeDeauthResponder)> {
if let WlanFullmacImplBridgeRequest::Deauth { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_assoc_resp(
self,
) -> Option<(WlanFullmacImplBaseAssocRespRequest, WlanFullmacImplBridgeAssocRespResponder)>
{
if let WlanFullmacImplBridgeRequest::AssocResp { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disassoc(
self,
) -> Option<(WlanFullmacImplBaseDisassocRequest, WlanFullmacImplBridgeDisassocResponder)> {
if let WlanFullmacImplBridgeRequest::Disassoc { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_reset(
self,
) -> Option<(WlanFullmacImplBaseResetRequest, WlanFullmacImplBridgeResetResponder)> {
if let WlanFullmacImplBridgeRequest::Reset { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start_bss(
self,
) -> Option<(WlanFullmacImplBaseStartBssRequest, WlanFullmacImplBridgeStartBssResponder)> {
if let WlanFullmacImplBridgeRequest::StartBss { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_stop_bss(
self,
) -> Option<(WlanFullmacImplBaseStopBssRequest, WlanFullmacImplBridgeStopBssResponder)> {
if let WlanFullmacImplBridgeRequest::StopBss { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_set_keys_req(
self,
) -> Option<(WlanFullmacSetKeysReq, WlanFullmacImplBridgeSetKeysReqResponder)> {
if let WlanFullmacImplBridgeRequest::SetKeysReq { req, responder } = self {
Some((req, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_del_keys_req(
self,
) -> Option<(WlanFullmacDelKeysReq, WlanFullmacImplBridgeDelKeysReqResponder)> {
if let WlanFullmacImplBridgeRequest::DelKeysReq { req, responder } = self {
Some((req, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_eapol_tx(
self,
) -> Option<(WlanFullmacImplBaseEapolTxRequest, WlanFullmacImplBridgeEapolTxResponder)> {
if let WlanFullmacImplBridgeRequest::EapolTx { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_iface_counter_stats(
self,
) -> Option<(WlanFullmacImplBridgeGetIfaceCounterStatsResponder)> {
if let WlanFullmacImplBridgeRequest::GetIfaceCounterStats { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_iface_histogram_stats(
self,
) -> Option<(WlanFullmacImplBridgeGetIfaceHistogramStatsResponder)> {
if let WlanFullmacImplBridgeRequest::GetIfaceHistogramStats { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_handshake_resp(
self,
) -> Option<(WlanFullmacSaeHandshakeResp, WlanFullmacImplBridgeSaeHandshakeRespResponder)> {
if let WlanFullmacImplBridgeRequest::SaeHandshakeResp { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_frame_tx(
self,
) -> Option<(WlanFullmacSaeFrame, WlanFullmacImplBridgeSaeFrameTxResponder)> {
if let WlanFullmacImplBridgeRequest::SaeFrameTx { frame, responder } = self {
Some((frame, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_wmm_status_req(self) -> Option<(WlanFullmacImplBridgeWmmStatusReqResponder)> {
if let WlanFullmacImplBridgeRequest::WmmStatusReq { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_set_multicast_promisc(
self,
) -> Option<(bool, WlanFullmacImplBridgeSetMulticastPromiscResponder)> {
if let WlanFullmacImplBridgeRequest::SetMulticastPromisc { enable, responder } = self {
Some((enable, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_link_state_changed(
self,
) -> Option<(bool, WlanFullmacImplBridgeOnLinkStateChangedResponder)> {
if let WlanFullmacImplBridgeRequest::OnLinkStateChanged { online, responder } = self {
Some((online, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start(
self,
) -> Option<(
fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
WlanFullmacImplBridgeStartResponder,
)> {
if let WlanFullmacImplBridgeRequest::Start { ifc, responder } = self {
Some((ifc, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
WlanFullmacImplBridgeRequest::Stop { .. } => "stop",
WlanFullmacImplBridgeRequest::Query { .. } => "query",
WlanFullmacImplBridgeRequest::QueryMacSublayerSupport { .. } => {
"query_mac_sublayer_support"
}
WlanFullmacImplBridgeRequest::QuerySecuritySupport { .. } => "query_security_support",
WlanFullmacImplBridgeRequest::QuerySpectrumManagementSupport { .. } => {
"query_spectrum_management_support"
}
WlanFullmacImplBridgeRequest::StartScan { .. } => "start_scan",
WlanFullmacImplBridgeRequest::Connect { .. } => "connect",
WlanFullmacImplBridgeRequest::Reconnect { .. } => "reconnect",
WlanFullmacImplBridgeRequest::AuthResp { .. } => "auth_resp",
WlanFullmacImplBridgeRequest::Deauth { .. } => "deauth",
WlanFullmacImplBridgeRequest::AssocResp { .. } => "assoc_resp",
WlanFullmacImplBridgeRequest::Disassoc { .. } => "disassoc",
WlanFullmacImplBridgeRequest::Reset { .. } => "reset",
WlanFullmacImplBridgeRequest::StartBss { .. } => "start_bss",
WlanFullmacImplBridgeRequest::StopBss { .. } => "stop_bss",
WlanFullmacImplBridgeRequest::SetKeysReq { .. } => "set_keys_req",
WlanFullmacImplBridgeRequest::DelKeysReq { .. } => "del_keys_req",
WlanFullmacImplBridgeRequest::EapolTx { .. } => "eapol_tx",
WlanFullmacImplBridgeRequest::GetIfaceCounterStats { .. } => "get_iface_counter_stats",
WlanFullmacImplBridgeRequest::GetIfaceHistogramStats { .. } => {
"get_iface_histogram_stats"
}
WlanFullmacImplBridgeRequest::SaeHandshakeResp { .. } => "sae_handshake_resp",
WlanFullmacImplBridgeRequest::SaeFrameTx { .. } => "sae_frame_tx",
WlanFullmacImplBridgeRequest::WmmStatusReq { .. } => "wmm_status_req",
WlanFullmacImplBridgeRequest::SetMulticastPromisc { .. } => "set_multicast_promisc",
WlanFullmacImplBridgeRequest::OnLinkStateChanged { .. } => "on_link_state_changed",
WlanFullmacImplBridgeRequest::Start { .. } => "start",
}
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplBridgeControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for WlanFullmacImplBridgeControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
}
impl WlanFullmacImplBridgeControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeStopResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeStopResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeStopResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeStopResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3f2685c8371251e6,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeQueryResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeQueryResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeQueryResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeQueryResponder {
pub fn send(self, mut result: Result<&WlanFullmacQueryInfo, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&WlanFullmacQueryInfo, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<&WlanFullmacQueryInfo, i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<WlanFullmacImplBaseQueryResponse, i32>>(
result.map(|info| (info,)),
self.tx_id,
0x16b5144d67f27eb9,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeQueryMacSublayerSupportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeQueryMacSublayerSupportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeQueryMacSublayerSupportResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeQueryMacSublayerSupportResponder {
pub fn send(
self,
mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseQueryMacSublayerSupportResponse,
i32,
>>(
result.map(|resp| (resp,)),
self.tx_id,
0x209b5ff943ebf049,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeQuerySecuritySupportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeQuerySecuritySupportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeQuerySecuritySupportResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeQuerySecuritySupportResponder {
pub fn send(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySecuritySupportResponse,
i32,
>>(
result.map(|resp| (resp,)),
self.tx_id,
0x1a5d8312c882fcba,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeQuerySpectrumManagementSupportResponder {
pub fn send(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseQuerySpectrumManagementSupportResponse,
i32,
>>(
result.map(|resp| (resp,)),
self.tx_id,
0x4b9f43e3dfabee9e,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeStartScanResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeStartScanResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeStartScanResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeStartScanResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3dc452902af23757,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeConnectResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeConnectResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeConnectResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeConnectResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x684dd78a0c9ebd2a,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeReconnectResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeReconnectResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeReconnectResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeReconnectResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x75259e6d9fa05df1,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeAuthRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeAuthRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeAuthRespResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeAuthRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x558fac0bd6e468bd,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeDeauthResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeDeauthResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeDeauthResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeDeauthResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3e573f78a0343e2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeAssocRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeAssocRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeAssocRespResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeAssocRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x7626d6d9e6fce311,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeDisassocResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeDisassocResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeDisassocResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeDisassocResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x14b5190abdb17230,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeResetResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeResetResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeResetResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeResetResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x37d8cfd378d3913a,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeStartBssResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeStartBssResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeStartBssResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeStartBssResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x337435c3055da80f,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeStopBssResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeStopBssResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeStopBssResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeStopBssResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x61cf5a6b75a25189,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeSetKeysReqResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeSetKeysReqResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeSetKeysReqResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeSetKeysReqResponder {
pub fn send(self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
let _result = self.send_raw(resp);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut resp: &WlanFullmacSetKeysResp,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(resp);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<WlanFullmacImplBaseSetKeysReqResponse>(
(resp,),
self.tx_id,
0x6b96f84f264f3b4d,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeDelKeysReqResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeDelKeysReqResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeDelKeysReqResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeDelKeysReqResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x7e2981344e041440,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeEapolTxResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeEapolTxResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeEapolTxResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeEapolTxResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x44b71768115d3494,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeGetIfaceCounterStatsResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeGetIfaceCounterStatsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeGetIfaceCounterStatsResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeGetIfaceCounterStatsResponder {
pub fn send(
self,
mut result: Result<&WlanFullmacIfaceCounterStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&WlanFullmacIfaceCounterStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&WlanFullmacIfaceCounterStats, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceCounterStatsResponse,
i32,
>>(
result.map(|stats| (stats,)),
self.tx_id,
0xe5e9c7bb1e7f576,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeGetIfaceHistogramStatsResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeGetIfaceHistogramStatsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeGetIfaceHistogramStatsResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeGetIfaceHistogramStatsResponder {
pub fn send(
self,
mut result: Result<&WlanFullmacIfaceHistogramStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&WlanFullmacIfaceHistogramStats, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&WlanFullmacIfaceHistogramStats, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
WlanFullmacImplBaseGetIfaceHistogramStatsResponse,
i32,
>>(
result.map(|stats| (stats,)),
self.tx_id,
0x57cfab227d48967d,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeSaeHandshakeRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeSaeHandshakeRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeSaeHandshakeRespResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeSaeHandshakeRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x5be2c56442ea8a26,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeSaeFrameTxResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeSaeFrameTxResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeSaeFrameTxResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeSaeFrameTxResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x8e00b54858b3d26,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeWmmStatusReqResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeWmmStatusReqResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeWmmStatusReqResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeWmmStatusReqResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x4361a32fb2c5f09,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeSetMulticastPromiscResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeSetMulticastPromiscResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeSetMulticastPromiscResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeSetMulticastPromiscResponder {
pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
result,
self.tx_id,
0x13c926de05ad8101,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeOnLinkStateChangedResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeOnLinkStateChangedResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeOnLinkStateChangedResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeOnLinkStateChangedResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x466007ff40a1efa2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplBridgeStartResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplBridgeStartResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplBridgeStartResponder {
type ControlHandle = WlanFullmacImplBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplBridgeStartResponder {
pub fn send(self, mut result: Result<fidl::Channel, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<fidl::Channel, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<fidl::Channel, i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<WlanFullmacImplBridgeStartResponse, i32>>(
result.map(|sme_channel| (sme_channel,)),
self.tx_id,
0x36d8ff13a418035f,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct WlanFullmacImplIfcBaseMarker;
impl fidl::endpoints::ProtocolMarker for WlanFullmacImplIfcBaseMarker {
type Proxy = WlanFullmacImplIfcBaseProxy;
type RequestStream = WlanFullmacImplIfcBaseRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = WlanFullmacImplIfcBaseSynchronousProxy;
const DEBUG_NAME: &'static str = "(anonymous) WlanFullmacImplIfcBase";
}
pub trait WlanFullmacImplIfcBaseProxyInterface: Send + Sync {
type OnScanResultResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_scan_result(&self, result: &WlanFullmacScanResult) -> Self::OnScanResultResponseFut;
type OnScanEndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_scan_end(&self, end: &WlanFullmacScanEnd) -> Self::OnScanEndResponseFut;
type ConnectConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#connect_conf(&self, resp: &WlanFullmacConnectConfirm) -> Self::ConnectConfResponseFut;
type RoamConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#roam_conf(&self, resp: &WlanFullmacRoamConfirm) -> Self::RoamConfResponseFut;
type AuthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#auth_ind(&self, resp: &WlanFullmacAuthInd) -> Self::AuthIndResponseFut;
type DeauthConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#deauth_conf(
&self,
payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
) -> Self::DeauthConfResponseFut;
type DeauthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#deauth_ind(&self, ind: &WlanFullmacDeauthIndication) -> Self::DeauthIndResponseFut;
type AssocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#assoc_ind(&self, resp: &WlanFullmacAssocInd) -> Self::AssocIndResponseFut;
type DisassocConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#disassoc_conf(&self, resp: &WlanFullmacDisassocConfirm) -> Self::DisassocConfResponseFut;
type DisassocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#disassoc_ind(&self, ind: &WlanFullmacDisassocIndication) -> Self::DisassocIndResponseFut;
type StartConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#start_conf(&self, resp: &WlanFullmacStartConfirm) -> Self::StartConfResponseFut;
type StopConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#stop_conf(&self, resp: &WlanFullmacStopConfirm) -> Self::StopConfResponseFut;
type EapolConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#eapol_conf(&self, resp: &WlanFullmacEapolConfirm) -> Self::EapolConfResponseFut;
type OnChannelSwitchResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_channel_switch(
&self,
ind: &WlanFullmacChannelSwitchInfo,
) -> Self::OnChannelSwitchResponseFut;
type SignalReportResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#signal_report(
&self,
ind: &WlanFullmacSignalReportIndication,
) -> Self::SignalReportResponseFut;
type EapolIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#eapol_ind(&self, ind: &WlanFullmacEapolIndication) -> Self::EapolIndResponseFut;
type OnPmkAvailableResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_pmk_available(&self, info: &WlanFullmacPmkInfo) -> Self::OnPmkAvailableResponseFut;
type SaeHandshakeIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_handshake_ind(
&self,
ind: &WlanFullmacSaeHandshakeInd,
) -> Self::SaeHandshakeIndResponseFut;
type SaeFrameRxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_frame_rx(&self, frame: &WlanFullmacSaeFrame) -> Self::SaeFrameRxResponseFut;
type OnWmmStatusRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_wmm_status_resp(
&self,
status: i32,
wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
) -> Self::OnWmmStatusRespResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanFullmacImplIfcBaseSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanFullmacImplIfcBaseSynchronousProxy {
type Proxy = WlanFullmacImplIfcBaseProxy;
type Protocol = WlanFullmacImplIfcBaseMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl WlanFullmacImplIfcBaseSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<WlanFullmacImplIfcBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
pub fn wait_for_event(
&self,
deadline: zx::Time,
) -> Result<WlanFullmacImplIfcBaseEvent, fidl::Error> {
WlanFullmacImplIfcBaseEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#on_scan_result(
&self,
mut result: &WlanFullmacScanResult,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseOnScanResultRequest, fidl::encoding::EmptyPayload>(
(result,),
0x88e861d700f64f8,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_scan_end(
&self,
mut end: &WlanFullmacScanEnd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseOnScanEndRequest, fidl::encoding::EmptyPayload>(
(end,),
0x76c6bed92c990276,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#connect_conf(
&self,
mut resp: &WlanFullmacConnectConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseConnectConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x75d0197de2f9b917,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#roam_conf(
&self,
mut resp: &WlanFullmacRoamConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseRoamConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0xe9bd7650a98031e,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#auth_ind(
&self,
mut resp: &WlanFullmacAuthInd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseAuthIndRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x3e7a3572a9f63462,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#deauth_conf(
&self,
mut payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDeauthConfRequest, fidl::encoding::EmptyPayload>(
payload,
0x28252ce030ea7bfa,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#deauth_ind(
&self,
mut ind: &WlanFullmacDeauthIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDeauthIndRequest, fidl::encoding::EmptyPayload>(
(ind,),
0x182a4013cb8a74ce,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#assoc_ind(
&self,
mut resp: &WlanFullmacAssocInd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseAssocIndRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x6df7225a8d83b32b,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#disassoc_conf(
&self,
mut resp: &WlanFullmacDisassocConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDisassocConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x2fd70afed8eac241,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#disassoc_ind(
&self,
mut ind: &WlanFullmacDisassocIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDisassocIndRequest, fidl::encoding::EmptyPayload>(
(ind,),
0x10f3565644b5b2aa,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#start_conf(
&self,
mut resp: &WlanFullmacStartConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseStartConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x45cd1385bf807723,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#stop_conf(
&self,
mut resp: &WlanFullmacStopConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseStopConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x4955a91549ee69b2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#eapol_conf(
&self,
mut resp: &WlanFullmacEapolConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseEapolConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x1f1f10c6aff5f5fd,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_channel_switch(
&self,
mut ind: &WlanFullmacChannelSwitchInfo,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseOnChannelSwitchRequest,
fidl::encoding::EmptyPayload,
>(
(ind,),
0x1bd58e236346deef,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#signal_report(
&self,
mut ind: &WlanFullmacSignalReportIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseSignalReportRequest, fidl::encoding::EmptyPayload>(
(ind,),
0x2f4687c6bf250510,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#eapol_ind(
&self,
mut ind: &WlanFullmacEapolIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseEapolIndRequest, fidl::encoding::EmptyPayload>(
(ind,),
0xdd7f86db0551e81,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_pmk_available(
&self,
mut info: &WlanFullmacPmkInfo,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseOnPmkAvailableRequest,
fidl::encoding::EmptyPayload,
>(
(info,),
0x3eed32d74dc54818,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#sae_handshake_ind(
&self,
mut ind: &WlanFullmacSaeHandshakeInd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseSaeHandshakeIndRequest,
fidl::encoding::EmptyPayload,
>(
(ind,),
0x1a925d47ed6f28ed,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#sae_frame_rx(
&self,
mut frame: &WlanFullmacSaeFrame,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseSaeFrameRxRequest, fidl::encoding::EmptyPayload>(
(frame,),
0x26b842795b7688f3,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_wmm_status_resp(
&self,
mut status: i32,
mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseOnWmmStatusRespRequest,
fidl::encoding::EmptyPayload,
>(
(status, wmm_params,),
0x39334623a4cd8128,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplIfcBaseProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for WlanFullmacImplIfcBaseProxy {
type Protocol = WlanFullmacImplIfcBaseMarker;
fn from_channel(inner: fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl WlanFullmacImplIfcBaseProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<WlanFullmacImplIfcBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> WlanFullmacImplIfcBaseEventStream {
WlanFullmacImplIfcBaseEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#on_scan_result(
&self,
mut result: &WlanFullmacScanResult,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#on_scan_result(self, result)
}
pub fn r#on_scan_end(
&self,
mut end: &WlanFullmacScanEnd,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#on_scan_end(self, end)
}
pub fn r#connect_conf(
&self,
mut resp: &WlanFullmacConnectConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#connect_conf(self, resp)
}
pub fn r#roam_conf(
&self,
mut resp: &WlanFullmacRoamConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#roam_conf(self, resp)
}
pub fn r#auth_ind(&self, mut resp: &WlanFullmacAuthInd) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#auth_ind(self, resp)
}
pub fn r#deauth_conf(
&self,
mut payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#deauth_conf(self, payload)
}
pub fn r#deauth_ind(
&self,
mut ind: &WlanFullmacDeauthIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#deauth_ind(self, ind)
}
pub fn r#assoc_ind(
&self,
mut resp: &WlanFullmacAssocInd,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#assoc_ind(self, resp)
}
pub fn r#disassoc_conf(
&self,
mut resp: &WlanFullmacDisassocConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#disassoc_conf(self, resp)
}
pub fn r#disassoc_ind(
&self,
mut ind: &WlanFullmacDisassocIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#disassoc_ind(self, ind)
}
pub fn r#start_conf(
&self,
mut resp: &WlanFullmacStartConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#start_conf(self, resp)
}
pub fn r#stop_conf(
&self,
mut resp: &WlanFullmacStopConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#stop_conf(self, resp)
}
pub fn r#eapol_conf(
&self,
mut resp: &WlanFullmacEapolConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#eapol_conf(self, resp)
}
pub fn r#on_channel_switch(
&self,
mut ind: &WlanFullmacChannelSwitchInfo,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#on_channel_switch(self, ind)
}
pub fn r#signal_report(
&self,
mut ind: &WlanFullmacSignalReportIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#signal_report(self, ind)
}
pub fn r#eapol_ind(
&self,
mut ind: &WlanFullmacEapolIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#eapol_ind(self, ind)
}
pub fn r#on_pmk_available(
&self,
mut info: &WlanFullmacPmkInfo,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#on_pmk_available(self, info)
}
pub fn r#sae_handshake_ind(
&self,
mut ind: &WlanFullmacSaeHandshakeInd,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#sae_handshake_ind(self, ind)
}
pub fn r#sae_frame_rx(
&self,
mut frame: &WlanFullmacSaeFrame,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#sae_frame_rx(self, frame)
}
pub fn r#on_wmm_status_resp(
&self,
mut status: i32,
mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBaseProxyInterface::r#on_wmm_status_resp(self, status, wmm_params)
}
}
impl WlanFullmacImplIfcBaseProxyInterface for WlanFullmacImplIfcBaseProxy {
type OnScanResultResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_scan_result(
&self,
mut result: &WlanFullmacScanResult,
) -> Self::OnScanResultResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x88e861d700f64f8,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnScanResultRequest, ()>(
(result,),
0x88e861d700f64f8,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnScanEndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_scan_end(&self, mut end: &WlanFullmacScanEnd) -> Self::OnScanEndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x76c6bed92c990276,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnScanEndRequest, ()>(
(end,),
0x76c6bed92c990276,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ConnectConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#connect_conf(&self, mut resp: &WlanFullmacConnectConfirm) -> Self::ConnectConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x75d0197de2f9b917,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseConnectConfRequest, ()>(
(resp,),
0x75d0197de2f9b917,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type RoamConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#roam_conf(&self, mut resp: &WlanFullmacRoamConfirm) -> Self::RoamConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0xe9bd7650a98031e,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseRoamConfRequest, ()>(
(resp,),
0xe9bd7650a98031e,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AuthIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#auth_ind(&self, mut resp: &WlanFullmacAuthInd) -> Self::AuthIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3e7a3572a9f63462,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseAuthIndRequest, ()>(
(resp,),
0x3e7a3572a9f63462,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DeauthConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#deauth_conf(
&self,
mut payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
) -> Self::DeauthConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x28252ce030ea7bfa,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDeauthConfRequest, ()>(
payload,
0x28252ce030ea7bfa,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DeauthIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#deauth_ind(&self, mut ind: &WlanFullmacDeauthIndication) -> Self::DeauthIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x182a4013cb8a74ce,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDeauthIndRequest, ()>(
(ind,),
0x182a4013cb8a74ce,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AssocIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#assoc_ind(&self, mut resp: &WlanFullmacAssocInd) -> Self::AssocIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x6df7225a8d83b32b,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseAssocIndRequest, ()>(
(resp,),
0x6df7225a8d83b32b,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisassocConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disassoc_conf(
&self,
mut resp: &WlanFullmacDisassocConfirm,
) -> Self::DisassocConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x2fd70afed8eac241,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDisassocConfRequest, ()>(
(resp,),
0x2fd70afed8eac241,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisassocIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disassoc_ind(
&self,
mut ind: &WlanFullmacDisassocIndication,
) -> Self::DisassocIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x10f3565644b5b2aa,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDisassocIndRequest, ()>(
(ind,),
0x10f3565644b5b2aa,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#start_conf(&self, mut resp: &WlanFullmacStartConfirm) -> Self::StartConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x45cd1385bf807723,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseStartConfRequest, ()>(
(resp,),
0x45cd1385bf807723,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StopConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#stop_conf(&self, mut resp: &WlanFullmacStopConfirm) -> Self::StopConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x4955a91549ee69b2,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseStopConfRequest, ()>(
(resp,),
0x4955a91549ee69b2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type EapolConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#eapol_conf(&self, mut resp: &WlanFullmacEapolConfirm) -> Self::EapolConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x1f1f10c6aff5f5fd,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseEapolConfRequest, ()>(
(resp,),
0x1f1f10c6aff5f5fd,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnChannelSwitchResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_channel_switch(
&self,
mut ind: &WlanFullmacChannelSwitchInfo,
) -> Self::OnChannelSwitchResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x1bd58e236346deef,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnChannelSwitchRequest, ()>(
(ind,),
0x1bd58e236346deef,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SignalReportResponseFut = fidl::client::QueryResponseFut<()>;
fn r#signal_report(
&self,
mut ind: &WlanFullmacSignalReportIndication,
) -> Self::SignalReportResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x2f4687c6bf250510,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseSignalReportRequest, ()>(
(ind,),
0x2f4687c6bf250510,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type EapolIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#eapol_ind(&self, mut ind: &WlanFullmacEapolIndication) -> Self::EapolIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0xdd7f86db0551e81,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseEapolIndRequest, ()>(
(ind,),
0xdd7f86db0551e81,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnPmkAvailableResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_pmk_available(&self, mut info: &WlanFullmacPmkInfo) -> Self::OnPmkAvailableResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3eed32d74dc54818,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnPmkAvailableRequest, ()>(
(info,),
0x3eed32d74dc54818,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeHandshakeIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_handshake_ind(
&self,
mut ind: &WlanFullmacSaeHandshakeInd,
) -> Self::SaeHandshakeIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x1a925d47ed6f28ed,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseSaeHandshakeIndRequest, ()>(
(ind,),
0x1a925d47ed6f28ed,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeFrameRxResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_frame_rx(&self, mut frame: &WlanFullmacSaeFrame) -> Self::SaeFrameRxResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x26b842795b7688f3,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseSaeFrameRxRequest, ()>(
(frame,),
0x26b842795b7688f3,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnWmmStatusRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_wmm_status_resp(
&self,
mut status: i32,
mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
) -> Self::OnWmmStatusRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x39334623a4cd8128,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest, ()>(
(status, wmm_params),
0x39334623a4cd8128,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct WlanFullmacImplIfcBaseEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for WlanFullmacImplIfcBaseEventStream {}
impl futures::stream::FusedStream for WlanFullmacImplIfcBaseEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for WlanFullmacImplIfcBaseEventStream {
type Item = Result<WlanFullmacImplIfcBaseEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImplIfcBaseEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum WlanFullmacImplIfcBaseEvent {}
impl WlanFullmacImplIfcBaseEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<WlanFullmacImplIfcBaseEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<WlanFullmacImplIfcBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct WlanFullmacImplIfcBaseRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for WlanFullmacImplIfcBaseRequestStream {}
impl futures::stream::FusedStream for WlanFullmacImplIfcBaseRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for WlanFullmacImplIfcBaseRequestStream {
type Protocol = WlanFullmacImplIfcBaseMarker;
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn from_channel(channel: fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
WlanFullmacImplIfcBaseControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for WlanFullmacImplIfcBaseRequestStream {
type Item = Result<WlanFullmacImplIfcBaseRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled WlanFullmacImplIfcBaseRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x88e861d700f64f8 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnScanResultRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnScanResultRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::OnScanResult {result: req.result,
responder: WlanFullmacImplIfcBaseOnScanResultResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x76c6bed92c990276 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnScanEndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnScanEndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::OnScanEnd {end: req.end,
responder: WlanFullmacImplIfcBaseOnScanEndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x75d0197de2f9b917 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseConnectConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseConnectConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::ConnectConf {resp: req.resp,
responder: WlanFullmacImplIfcBaseConnectConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xe9bd7650a98031e => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseRoamConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseRoamConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::RoamConf {resp: req.resp,
responder: WlanFullmacImplIfcBaseRoamConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3e7a3572a9f63462 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseAuthIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseAuthIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::AuthInd {resp: req.resp,
responder: WlanFullmacImplIfcBaseAuthIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x28252ce030ea7bfa => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDeauthConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDeauthConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::DeauthConf {payload: req,
responder: WlanFullmacImplIfcBaseDeauthConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x182a4013cb8a74ce => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDeauthIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDeauthIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::DeauthInd {ind: req.ind,
responder: WlanFullmacImplIfcBaseDeauthIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6df7225a8d83b32b => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseAssocIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseAssocIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::AssocInd {resp: req.resp,
responder: WlanFullmacImplIfcBaseAssocIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2fd70afed8eac241 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDisassocConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDisassocConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::DisassocConf {resp: req.resp,
responder: WlanFullmacImplIfcBaseDisassocConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x10f3565644b5b2aa => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDisassocIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDisassocIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::DisassocInd {ind: req.ind,
responder: WlanFullmacImplIfcBaseDisassocIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x45cd1385bf807723 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseStartConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseStartConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::StartConf {resp: req.resp,
responder: WlanFullmacImplIfcBaseStartConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4955a91549ee69b2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseStopConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseStopConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::StopConf {resp: req.resp,
responder: WlanFullmacImplIfcBaseStopConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1f1f10c6aff5f5fd => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseEapolConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseEapolConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::EapolConf {resp: req.resp,
responder: WlanFullmacImplIfcBaseEapolConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1bd58e236346deef => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnChannelSwitchRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnChannelSwitchRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::OnChannelSwitch {ind: req.ind,
responder: WlanFullmacImplIfcBaseOnChannelSwitchResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2f4687c6bf250510 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseSignalReportRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseSignalReportRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::SignalReport {ind: req.ind,
responder: WlanFullmacImplIfcBaseSignalReportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xdd7f86db0551e81 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseEapolIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseEapolIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::EapolInd {ind: req.ind,
responder: WlanFullmacImplIfcBaseEapolIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3eed32d74dc54818 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnPmkAvailableRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnPmkAvailableRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::OnPmkAvailable {info: req.info,
responder: WlanFullmacImplIfcBaseOnPmkAvailableResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1a925d47ed6f28ed => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseSaeHandshakeIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseSaeHandshakeIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::SaeHandshakeInd {ind: req.ind,
responder: WlanFullmacImplIfcBaseSaeHandshakeIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x26b842795b7688f3 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseSaeFrameRxRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseSaeFrameRxRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::SaeFrameRx {frame: req.frame,
responder: WlanFullmacImplIfcBaseSaeFrameRxResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x39334623a4cd8128 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnWmmStatusRespRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBaseControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBaseRequest::OnWmmStatusResp {status: req.status,
wmm_params: req.wmm_params,
responder: WlanFullmacImplIfcBaseOnWmmStatusRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <WlanFullmacImplIfcBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum WlanFullmacImplIfcBaseRequest {
OnScanResult {
result: WlanFullmacScanResult,
responder: WlanFullmacImplIfcBaseOnScanResultResponder,
},
OnScanEnd {
end: WlanFullmacScanEnd,
responder: WlanFullmacImplIfcBaseOnScanEndResponder,
},
ConnectConf {
resp: WlanFullmacConnectConfirm,
responder: WlanFullmacImplIfcBaseConnectConfResponder,
},
RoamConf {
resp: WlanFullmacRoamConfirm,
responder: WlanFullmacImplIfcBaseRoamConfResponder,
},
AuthInd {
resp: WlanFullmacAuthInd,
responder: WlanFullmacImplIfcBaseAuthIndResponder,
},
DeauthConf {
payload: WlanFullmacImplIfcBaseDeauthConfRequest,
responder: WlanFullmacImplIfcBaseDeauthConfResponder,
},
DeauthInd {
ind: WlanFullmacDeauthIndication,
responder: WlanFullmacImplIfcBaseDeauthIndResponder,
},
AssocInd {
resp: WlanFullmacAssocInd,
responder: WlanFullmacImplIfcBaseAssocIndResponder,
},
DisassocConf {
resp: WlanFullmacDisassocConfirm,
responder: WlanFullmacImplIfcBaseDisassocConfResponder,
},
DisassocInd {
ind: WlanFullmacDisassocIndication,
responder: WlanFullmacImplIfcBaseDisassocIndResponder,
},
StartConf {
resp: WlanFullmacStartConfirm,
responder: WlanFullmacImplIfcBaseStartConfResponder,
},
StopConf {
resp: WlanFullmacStopConfirm,
responder: WlanFullmacImplIfcBaseStopConfResponder,
},
EapolConf {
resp: WlanFullmacEapolConfirm,
responder: WlanFullmacImplIfcBaseEapolConfResponder,
},
OnChannelSwitch {
ind: WlanFullmacChannelSwitchInfo,
responder: WlanFullmacImplIfcBaseOnChannelSwitchResponder,
},
SignalReport {
ind: WlanFullmacSignalReportIndication,
responder: WlanFullmacImplIfcBaseSignalReportResponder,
},
EapolInd {
ind: WlanFullmacEapolIndication,
responder: WlanFullmacImplIfcBaseEapolIndResponder,
},
OnPmkAvailable {
info: WlanFullmacPmkInfo,
responder: WlanFullmacImplIfcBaseOnPmkAvailableResponder,
},
SaeHandshakeInd {
ind: WlanFullmacSaeHandshakeInd,
responder: WlanFullmacImplIfcBaseSaeHandshakeIndResponder,
},
SaeFrameRx {
frame: WlanFullmacSaeFrame,
responder: WlanFullmacImplIfcBaseSaeFrameRxResponder,
},
OnWmmStatusResp {
status: i32,
wmm_params: fidl_fuchsia_wlan_common::WlanWmmParameters,
responder: WlanFullmacImplIfcBaseOnWmmStatusRespResponder,
},
}
impl WlanFullmacImplIfcBaseRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_on_scan_result(
self,
) -> Option<(WlanFullmacScanResult, WlanFullmacImplIfcBaseOnScanResultResponder)> {
if let WlanFullmacImplIfcBaseRequest::OnScanResult { result, responder } = self {
Some((result, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_scan_end(
self,
) -> Option<(WlanFullmacScanEnd, WlanFullmacImplIfcBaseOnScanEndResponder)> {
if let WlanFullmacImplIfcBaseRequest::OnScanEnd { end, responder } = self {
Some((end, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect_conf(
self,
) -> Option<(WlanFullmacConnectConfirm, WlanFullmacImplIfcBaseConnectConfResponder)> {
if let WlanFullmacImplIfcBaseRequest::ConnectConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_roam_conf(
self,
) -> Option<(WlanFullmacRoamConfirm, WlanFullmacImplIfcBaseRoamConfResponder)> {
if let WlanFullmacImplIfcBaseRequest::RoamConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_auth_ind(
self,
) -> Option<(WlanFullmacAuthInd, WlanFullmacImplIfcBaseAuthIndResponder)> {
if let WlanFullmacImplIfcBaseRequest::AuthInd { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_deauth_conf(
self,
) -> Option<(WlanFullmacImplIfcBaseDeauthConfRequest, WlanFullmacImplIfcBaseDeauthConfResponder)>
{
if let WlanFullmacImplIfcBaseRequest::DeauthConf { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_deauth_ind(
self,
) -> Option<(WlanFullmacDeauthIndication, WlanFullmacImplIfcBaseDeauthIndResponder)> {
if let WlanFullmacImplIfcBaseRequest::DeauthInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_assoc_ind(
self,
) -> Option<(WlanFullmacAssocInd, WlanFullmacImplIfcBaseAssocIndResponder)> {
if let WlanFullmacImplIfcBaseRequest::AssocInd { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disassoc_conf(
self,
) -> Option<(WlanFullmacDisassocConfirm, WlanFullmacImplIfcBaseDisassocConfResponder)> {
if let WlanFullmacImplIfcBaseRequest::DisassocConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disassoc_ind(
self,
) -> Option<(WlanFullmacDisassocIndication, WlanFullmacImplIfcBaseDisassocIndResponder)> {
if let WlanFullmacImplIfcBaseRequest::DisassocInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start_conf(
self,
) -> Option<(WlanFullmacStartConfirm, WlanFullmacImplIfcBaseStartConfResponder)> {
if let WlanFullmacImplIfcBaseRequest::StartConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_stop_conf(
self,
) -> Option<(WlanFullmacStopConfirm, WlanFullmacImplIfcBaseStopConfResponder)> {
if let WlanFullmacImplIfcBaseRequest::StopConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_eapol_conf(
self,
) -> Option<(WlanFullmacEapolConfirm, WlanFullmacImplIfcBaseEapolConfResponder)> {
if let WlanFullmacImplIfcBaseRequest::EapolConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_channel_switch(
self,
) -> Option<(WlanFullmacChannelSwitchInfo, WlanFullmacImplIfcBaseOnChannelSwitchResponder)>
{
if let WlanFullmacImplIfcBaseRequest::OnChannelSwitch { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_signal_report(
self,
) -> Option<(WlanFullmacSignalReportIndication, WlanFullmacImplIfcBaseSignalReportResponder)>
{
if let WlanFullmacImplIfcBaseRequest::SignalReport { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_eapol_ind(
self,
) -> Option<(WlanFullmacEapolIndication, WlanFullmacImplIfcBaseEapolIndResponder)> {
if let WlanFullmacImplIfcBaseRequest::EapolInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_pmk_available(
self,
) -> Option<(WlanFullmacPmkInfo, WlanFullmacImplIfcBaseOnPmkAvailableResponder)> {
if let WlanFullmacImplIfcBaseRequest::OnPmkAvailable { info, responder } = self {
Some((info, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_handshake_ind(
self,
) -> Option<(WlanFullmacSaeHandshakeInd, WlanFullmacImplIfcBaseSaeHandshakeIndResponder)> {
if let WlanFullmacImplIfcBaseRequest::SaeHandshakeInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_frame_rx(
self,
) -> Option<(WlanFullmacSaeFrame, WlanFullmacImplIfcBaseSaeFrameRxResponder)> {
if let WlanFullmacImplIfcBaseRequest::SaeFrameRx { frame, responder } = self {
Some((frame, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_wmm_status_resp(
self,
) -> Option<(
i32,
fidl_fuchsia_wlan_common::WlanWmmParameters,
WlanFullmacImplIfcBaseOnWmmStatusRespResponder,
)> {
if let WlanFullmacImplIfcBaseRequest::OnWmmStatusResp { status, wmm_params, responder } =
self
{
Some((status, wmm_params, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
WlanFullmacImplIfcBaseRequest::OnScanResult { .. } => "on_scan_result",
WlanFullmacImplIfcBaseRequest::OnScanEnd { .. } => "on_scan_end",
WlanFullmacImplIfcBaseRequest::ConnectConf { .. } => "connect_conf",
WlanFullmacImplIfcBaseRequest::RoamConf { .. } => "roam_conf",
WlanFullmacImplIfcBaseRequest::AuthInd { .. } => "auth_ind",
WlanFullmacImplIfcBaseRequest::DeauthConf { .. } => "deauth_conf",
WlanFullmacImplIfcBaseRequest::DeauthInd { .. } => "deauth_ind",
WlanFullmacImplIfcBaseRequest::AssocInd { .. } => "assoc_ind",
WlanFullmacImplIfcBaseRequest::DisassocConf { .. } => "disassoc_conf",
WlanFullmacImplIfcBaseRequest::DisassocInd { .. } => "disassoc_ind",
WlanFullmacImplIfcBaseRequest::StartConf { .. } => "start_conf",
WlanFullmacImplIfcBaseRequest::StopConf { .. } => "stop_conf",
WlanFullmacImplIfcBaseRequest::EapolConf { .. } => "eapol_conf",
WlanFullmacImplIfcBaseRequest::OnChannelSwitch { .. } => "on_channel_switch",
WlanFullmacImplIfcBaseRequest::SignalReport { .. } => "signal_report",
WlanFullmacImplIfcBaseRequest::EapolInd { .. } => "eapol_ind",
WlanFullmacImplIfcBaseRequest::OnPmkAvailable { .. } => "on_pmk_available",
WlanFullmacImplIfcBaseRequest::SaeHandshakeInd { .. } => "sae_handshake_ind",
WlanFullmacImplIfcBaseRequest::SaeFrameRx { .. } => "sae_frame_rx",
WlanFullmacImplIfcBaseRequest::OnWmmStatusResp { .. } => "on_wmm_status_resp",
}
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplIfcBaseControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for WlanFullmacImplIfcBaseControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
}
impl WlanFullmacImplIfcBaseControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseOnScanResultResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseOnScanResultResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseOnScanResultResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseOnScanResultResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x88e861d700f64f8,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseOnScanEndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseOnScanEndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseOnScanEndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseOnScanEndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x76c6bed92c990276,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseConnectConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseConnectConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseConnectConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseConnectConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x75d0197de2f9b917,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseRoamConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseRoamConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseRoamConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseRoamConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0xe9bd7650a98031e,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseAuthIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseAuthIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseAuthIndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseAuthIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3e7a3572a9f63462,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseDeauthConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseDeauthConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseDeauthConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseDeauthConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x28252ce030ea7bfa,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseDeauthIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseDeauthIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseDeauthIndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseDeauthIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x182a4013cb8a74ce,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseAssocIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseAssocIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseAssocIndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseAssocIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x6df7225a8d83b32b,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseDisassocConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseDisassocConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseDisassocConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseDisassocConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x2fd70afed8eac241,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseDisassocIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseDisassocIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseDisassocIndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseDisassocIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x10f3565644b5b2aa,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseStartConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseStartConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseStartConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseStartConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x45cd1385bf807723,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseStopConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseStopConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseStopConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseStopConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x4955a91549ee69b2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseEapolConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseEapolConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseEapolConfResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseEapolConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x1f1f10c6aff5f5fd,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseOnChannelSwitchResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseOnChannelSwitchResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseOnChannelSwitchResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseOnChannelSwitchResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x1bd58e236346deef,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseSignalReportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseSignalReportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseSignalReportResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseSignalReportResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x2f4687c6bf250510,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseEapolIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseEapolIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseEapolIndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseEapolIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0xdd7f86db0551e81,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseOnPmkAvailableResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseOnPmkAvailableResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseOnPmkAvailableResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseOnPmkAvailableResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3eed32d74dc54818,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseSaeHandshakeIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseSaeHandshakeIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseSaeHandshakeIndResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseSaeHandshakeIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x1a925d47ed6f28ed,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseSaeFrameRxResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseSaeFrameRxResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseSaeFrameRxResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseSaeFrameRxResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x26b842795b7688f3,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBaseOnWmmStatusRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBaseControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBaseOnWmmStatusRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBaseOnWmmStatusRespResponder {
type ControlHandle = WlanFullmacImplIfcBaseControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBaseControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBaseOnWmmStatusRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x39334623a4cd8128,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct WlanFullmacImplIfcBridgeMarker;
impl fidl::endpoints::ProtocolMarker for WlanFullmacImplIfcBridgeMarker {
type Proxy = WlanFullmacImplIfcBridgeProxy;
type RequestStream = WlanFullmacImplIfcBridgeRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = WlanFullmacImplIfcBridgeSynchronousProxy;
const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImplIfcBridge";
}
impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImplIfcBridgeMarker {}
pub trait WlanFullmacImplIfcBridgeProxyInterface: Send + Sync {
type OnScanResultResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_scan_result(&self, result: &WlanFullmacScanResult) -> Self::OnScanResultResponseFut;
type OnScanEndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_scan_end(&self, end: &WlanFullmacScanEnd) -> Self::OnScanEndResponseFut;
type ConnectConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#connect_conf(&self, resp: &WlanFullmacConnectConfirm) -> Self::ConnectConfResponseFut;
type RoamConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#roam_conf(&self, resp: &WlanFullmacRoamConfirm) -> Self::RoamConfResponseFut;
type AuthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#auth_ind(&self, resp: &WlanFullmacAuthInd) -> Self::AuthIndResponseFut;
type DeauthConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#deauth_conf(
&self,
payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
) -> Self::DeauthConfResponseFut;
type DeauthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#deauth_ind(&self, ind: &WlanFullmacDeauthIndication) -> Self::DeauthIndResponseFut;
type AssocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#assoc_ind(&self, resp: &WlanFullmacAssocInd) -> Self::AssocIndResponseFut;
type DisassocConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#disassoc_conf(&self, resp: &WlanFullmacDisassocConfirm) -> Self::DisassocConfResponseFut;
type DisassocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#disassoc_ind(&self, ind: &WlanFullmacDisassocIndication) -> Self::DisassocIndResponseFut;
type StartConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#start_conf(&self, resp: &WlanFullmacStartConfirm) -> Self::StartConfResponseFut;
type StopConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#stop_conf(&self, resp: &WlanFullmacStopConfirm) -> Self::StopConfResponseFut;
type EapolConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#eapol_conf(&self, resp: &WlanFullmacEapolConfirm) -> Self::EapolConfResponseFut;
type OnChannelSwitchResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_channel_switch(
&self,
ind: &WlanFullmacChannelSwitchInfo,
) -> Self::OnChannelSwitchResponseFut;
type SignalReportResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#signal_report(
&self,
ind: &WlanFullmacSignalReportIndication,
) -> Self::SignalReportResponseFut;
type EapolIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#eapol_ind(&self, ind: &WlanFullmacEapolIndication) -> Self::EapolIndResponseFut;
type OnPmkAvailableResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_pmk_available(&self, info: &WlanFullmacPmkInfo) -> Self::OnPmkAvailableResponseFut;
type SaeHandshakeIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_handshake_ind(
&self,
ind: &WlanFullmacSaeHandshakeInd,
) -> Self::SaeHandshakeIndResponseFut;
type SaeFrameRxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#sae_frame_rx(&self, frame: &WlanFullmacSaeFrame) -> Self::SaeFrameRxResponseFut;
type OnWmmStatusRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#on_wmm_status_resp(
&self,
status: i32,
wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
) -> Self::OnWmmStatusRespResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanFullmacImplIfcBridgeSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanFullmacImplIfcBridgeSynchronousProxy {
type Proxy = WlanFullmacImplIfcBridgeProxy;
type Protocol = WlanFullmacImplIfcBridgeMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl WlanFullmacImplIfcBridgeSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<WlanFullmacImplIfcBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
pub fn wait_for_event(
&self,
deadline: zx::Time,
) -> Result<WlanFullmacImplIfcBridgeEvent, fidl::Error> {
WlanFullmacImplIfcBridgeEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#on_scan_result(
&self,
mut result: &WlanFullmacScanResult,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseOnScanResultRequest, fidl::encoding::EmptyPayload>(
(result,),
0x88e861d700f64f8,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_scan_end(
&self,
mut end: &WlanFullmacScanEnd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseOnScanEndRequest, fidl::encoding::EmptyPayload>(
(end,),
0x76c6bed92c990276,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#connect_conf(
&self,
mut resp: &WlanFullmacConnectConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseConnectConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x75d0197de2f9b917,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#roam_conf(
&self,
mut resp: &WlanFullmacRoamConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseRoamConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0xe9bd7650a98031e,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#auth_ind(
&self,
mut resp: &WlanFullmacAuthInd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseAuthIndRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x3e7a3572a9f63462,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#deauth_conf(
&self,
mut payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDeauthConfRequest, fidl::encoding::EmptyPayload>(
payload,
0x28252ce030ea7bfa,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#deauth_ind(
&self,
mut ind: &WlanFullmacDeauthIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDeauthIndRequest, fidl::encoding::EmptyPayload>(
(ind,),
0x182a4013cb8a74ce,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#assoc_ind(
&self,
mut resp: &WlanFullmacAssocInd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseAssocIndRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x6df7225a8d83b32b,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#disassoc_conf(
&self,
mut resp: &WlanFullmacDisassocConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDisassocConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x2fd70afed8eac241,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#disassoc_ind(
&self,
mut ind: &WlanFullmacDisassocIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseDisassocIndRequest, fidl::encoding::EmptyPayload>(
(ind,),
0x10f3565644b5b2aa,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#start_conf(
&self,
mut resp: &WlanFullmacStartConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseStartConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x45cd1385bf807723,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#stop_conf(
&self,
mut resp: &WlanFullmacStopConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseStopConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x4955a91549ee69b2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#eapol_conf(
&self,
mut resp: &WlanFullmacEapolConfirm,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseEapolConfRequest, fidl::encoding::EmptyPayload>(
(resp,),
0x1f1f10c6aff5f5fd,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_channel_switch(
&self,
mut ind: &WlanFullmacChannelSwitchInfo,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseOnChannelSwitchRequest,
fidl::encoding::EmptyPayload,
>(
(ind,),
0x1bd58e236346deef,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#signal_report(
&self,
mut ind: &WlanFullmacSignalReportIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseSignalReportRequest, fidl::encoding::EmptyPayload>(
(ind,),
0x2f4687c6bf250510,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#eapol_ind(
&self,
mut ind: &WlanFullmacEapolIndication,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseEapolIndRequest, fidl::encoding::EmptyPayload>(
(ind,),
0xdd7f86db0551e81,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_pmk_available(
&self,
mut info: &WlanFullmacPmkInfo,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseOnPmkAvailableRequest,
fidl::encoding::EmptyPayload,
>(
(info,),
0x3eed32d74dc54818,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#sae_handshake_ind(
&self,
mut ind: &WlanFullmacSaeHandshakeInd,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseSaeHandshakeIndRequest,
fidl::encoding::EmptyPayload,
>(
(ind,),
0x1a925d47ed6f28ed,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#sae_frame_rx(
&self,
mut frame: &WlanFullmacSaeFrame,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self
.client
.send_query::<WlanFullmacImplIfcBaseSaeFrameRxRequest, fidl::encoding::EmptyPayload>(
(frame,),
0x26b842795b7688f3,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#on_wmm_status_resp(
&self,
mut status: i32,
mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
WlanFullmacImplIfcBaseOnWmmStatusRespRequest,
fidl::encoding::EmptyPayload,
>(
(status, wmm_params,),
0x39334623a4cd8128,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplIfcBridgeProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for WlanFullmacImplIfcBridgeProxy {
type Protocol = WlanFullmacImplIfcBridgeMarker;
fn from_channel(inner: fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl WlanFullmacImplIfcBridgeProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<WlanFullmacImplIfcBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> WlanFullmacImplIfcBridgeEventStream {
WlanFullmacImplIfcBridgeEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#on_scan_result(
&self,
mut result: &WlanFullmacScanResult,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#on_scan_result(self, result)
}
pub fn r#on_scan_end(
&self,
mut end: &WlanFullmacScanEnd,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#on_scan_end(self, end)
}
pub fn r#connect_conf(
&self,
mut resp: &WlanFullmacConnectConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#connect_conf(self, resp)
}
pub fn r#roam_conf(
&self,
mut resp: &WlanFullmacRoamConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#roam_conf(self, resp)
}
pub fn r#auth_ind(&self, mut resp: &WlanFullmacAuthInd) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#auth_ind(self, resp)
}
pub fn r#deauth_conf(
&self,
mut payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#deauth_conf(self, payload)
}
pub fn r#deauth_ind(
&self,
mut ind: &WlanFullmacDeauthIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#deauth_ind(self, ind)
}
pub fn r#assoc_ind(
&self,
mut resp: &WlanFullmacAssocInd,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#assoc_ind(self, resp)
}
pub fn r#disassoc_conf(
&self,
mut resp: &WlanFullmacDisassocConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#disassoc_conf(self, resp)
}
pub fn r#disassoc_ind(
&self,
mut ind: &WlanFullmacDisassocIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#disassoc_ind(self, ind)
}
pub fn r#start_conf(
&self,
mut resp: &WlanFullmacStartConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#start_conf(self, resp)
}
pub fn r#stop_conf(
&self,
mut resp: &WlanFullmacStopConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#stop_conf(self, resp)
}
pub fn r#eapol_conf(
&self,
mut resp: &WlanFullmacEapolConfirm,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#eapol_conf(self, resp)
}
pub fn r#on_channel_switch(
&self,
mut ind: &WlanFullmacChannelSwitchInfo,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#on_channel_switch(self, ind)
}
pub fn r#signal_report(
&self,
mut ind: &WlanFullmacSignalReportIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#signal_report(self, ind)
}
pub fn r#eapol_ind(
&self,
mut ind: &WlanFullmacEapolIndication,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#eapol_ind(self, ind)
}
pub fn r#on_pmk_available(
&self,
mut info: &WlanFullmacPmkInfo,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#on_pmk_available(self, info)
}
pub fn r#sae_handshake_ind(
&self,
mut ind: &WlanFullmacSaeHandshakeInd,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#sae_handshake_ind(self, ind)
}
pub fn r#sae_frame_rx(
&self,
mut frame: &WlanFullmacSaeFrame,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#sae_frame_rx(self, frame)
}
pub fn r#on_wmm_status_resp(
&self,
mut status: i32,
mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
) -> fidl::client::QueryResponseFut<()> {
WlanFullmacImplIfcBridgeProxyInterface::r#on_wmm_status_resp(self, status, wmm_params)
}
}
impl WlanFullmacImplIfcBridgeProxyInterface for WlanFullmacImplIfcBridgeProxy {
type OnScanResultResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_scan_result(
&self,
mut result: &WlanFullmacScanResult,
) -> Self::OnScanResultResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x88e861d700f64f8,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnScanResultRequest, ()>(
(result,),
0x88e861d700f64f8,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnScanEndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_scan_end(&self, mut end: &WlanFullmacScanEnd) -> Self::OnScanEndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x76c6bed92c990276,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnScanEndRequest, ()>(
(end,),
0x76c6bed92c990276,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ConnectConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#connect_conf(&self, mut resp: &WlanFullmacConnectConfirm) -> Self::ConnectConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x75d0197de2f9b917,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseConnectConfRequest, ()>(
(resp,),
0x75d0197de2f9b917,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type RoamConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#roam_conf(&self, mut resp: &WlanFullmacRoamConfirm) -> Self::RoamConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0xe9bd7650a98031e,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseRoamConfRequest, ()>(
(resp,),
0xe9bd7650a98031e,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AuthIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#auth_ind(&self, mut resp: &WlanFullmacAuthInd) -> Self::AuthIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3e7a3572a9f63462,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseAuthIndRequest, ()>(
(resp,),
0x3e7a3572a9f63462,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DeauthConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#deauth_conf(
&self,
mut payload: &WlanFullmacImplIfcBaseDeauthConfRequest,
) -> Self::DeauthConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x28252ce030ea7bfa,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDeauthConfRequest, ()>(
payload,
0x28252ce030ea7bfa,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DeauthIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#deauth_ind(&self, mut ind: &WlanFullmacDeauthIndication) -> Self::DeauthIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x182a4013cb8a74ce,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDeauthIndRequest, ()>(
(ind,),
0x182a4013cb8a74ce,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AssocIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#assoc_ind(&self, mut resp: &WlanFullmacAssocInd) -> Self::AssocIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x6df7225a8d83b32b,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseAssocIndRequest, ()>(
(resp,),
0x6df7225a8d83b32b,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisassocConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disassoc_conf(
&self,
mut resp: &WlanFullmacDisassocConfirm,
) -> Self::DisassocConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x2fd70afed8eac241,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDisassocConfRequest, ()>(
(resp,),
0x2fd70afed8eac241,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisassocIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disassoc_ind(
&self,
mut ind: &WlanFullmacDisassocIndication,
) -> Self::DisassocIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x10f3565644b5b2aa,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseDisassocIndRequest, ()>(
(ind,),
0x10f3565644b5b2aa,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StartConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#start_conf(&self, mut resp: &WlanFullmacStartConfirm) -> Self::StartConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x45cd1385bf807723,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseStartConfRequest, ()>(
(resp,),
0x45cd1385bf807723,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StopConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#stop_conf(&self, mut resp: &WlanFullmacStopConfirm) -> Self::StopConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x4955a91549ee69b2,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseStopConfRequest, ()>(
(resp,),
0x4955a91549ee69b2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type EapolConfResponseFut = fidl::client::QueryResponseFut<()>;
fn r#eapol_conf(&self, mut resp: &WlanFullmacEapolConfirm) -> Self::EapolConfResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x1f1f10c6aff5f5fd,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseEapolConfRequest, ()>(
(resp,),
0x1f1f10c6aff5f5fd,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnChannelSwitchResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_channel_switch(
&self,
mut ind: &WlanFullmacChannelSwitchInfo,
) -> Self::OnChannelSwitchResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x1bd58e236346deef,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnChannelSwitchRequest, ()>(
(ind,),
0x1bd58e236346deef,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SignalReportResponseFut = fidl::client::QueryResponseFut<()>;
fn r#signal_report(
&self,
mut ind: &WlanFullmacSignalReportIndication,
) -> Self::SignalReportResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x2f4687c6bf250510,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseSignalReportRequest, ()>(
(ind,),
0x2f4687c6bf250510,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type EapolIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#eapol_ind(&self, mut ind: &WlanFullmacEapolIndication) -> Self::EapolIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0xdd7f86db0551e81,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseEapolIndRequest, ()>(
(ind,),
0xdd7f86db0551e81,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnPmkAvailableResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_pmk_available(&self, mut info: &WlanFullmacPmkInfo) -> Self::OnPmkAvailableResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x3eed32d74dc54818,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnPmkAvailableRequest, ()>(
(info,),
0x3eed32d74dc54818,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeHandshakeIndResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_handshake_ind(
&self,
mut ind: &WlanFullmacSaeHandshakeInd,
) -> Self::SaeHandshakeIndResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x1a925d47ed6f28ed,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseSaeHandshakeIndRequest, ()>(
(ind,),
0x1a925d47ed6f28ed,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SaeFrameRxResponseFut = fidl::client::QueryResponseFut<()>;
fn r#sae_frame_rx(&self, mut frame: &WlanFullmacSaeFrame) -> Self::SaeFrameRxResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x26b842795b7688f3,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseSaeFrameRxRequest, ()>(
(frame,),
0x26b842795b7688f3,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type OnWmmStatusRespResponseFut = fidl::client::QueryResponseFut<()>;
fn r#on_wmm_status_resp(
&self,
mut status: i32,
mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
) -> Self::OnWmmStatusRespResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x39334623a4cd8128,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest, ()>(
(status, wmm_params),
0x39334623a4cd8128,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct WlanFullmacImplIfcBridgeEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for WlanFullmacImplIfcBridgeEventStream {}
impl futures::stream::FusedStream for WlanFullmacImplIfcBridgeEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for WlanFullmacImplIfcBridgeEventStream {
type Item = Result<WlanFullmacImplIfcBridgeEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImplIfcBridgeEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum WlanFullmacImplIfcBridgeEvent {}
impl WlanFullmacImplIfcBridgeEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<WlanFullmacImplIfcBridgeEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<WlanFullmacImplIfcBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct WlanFullmacImplIfcBridgeRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for WlanFullmacImplIfcBridgeRequestStream {}
impl futures::stream::FusedStream for WlanFullmacImplIfcBridgeRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for WlanFullmacImplIfcBridgeRequestStream {
type Protocol = WlanFullmacImplIfcBridgeMarker;
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn from_channel(channel: fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
WlanFullmacImplIfcBridgeControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for WlanFullmacImplIfcBridgeRequestStream {
type Item = Result<WlanFullmacImplIfcBridgeRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled WlanFullmacImplIfcBridgeRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x88e861d700f64f8 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnScanResultRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnScanResultRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::OnScanResult {result: req.result,
responder: WlanFullmacImplIfcBridgeOnScanResultResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x76c6bed92c990276 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnScanEndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnScanEndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::OnScanEnd {end: req.end,
responder: WlanFullmacImplIfcBridgeOnScanEndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x75d0197de2f9b917 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseConnectConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseConnectConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::ConnectConf {resp: req.resp,
responder: WlanFullmacImplIfcBridgeConnectConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xe9bd7650a98031e => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseRoamConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseRoamConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::RoamConf {resp: req.resp,
responder: WlanFullmacImplIfcBridgeRoamConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3e7a3572a9f63462 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseAuthIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseAuthIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::AuthInd {resp: req.resp,
responder: WlanFullmacImplIfcBridgeAuthIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x28252ce030ea7bfa => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDeauthConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDeauthConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::DeauthConf {payload: req,
responder: WlanFullmacImplIfcBridgeDeauthConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x182a4013cb8a74ce => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDeauthIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDeauthIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::DeauthInd {ind: req.ind,
responder: WlanFullmacImplIfcBridgeDeauthIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6df7225a8d83b32b => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseAssocIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseAssocIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::AssocInd {resp: req.resp,
responder: WlanFullmacImplIfcBridgeAssocIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2fd70afed8eac241 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDisassocConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDisassocConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::DisassocConf {resp: req.resp,
responder: WlanFullmacImplIfcBridgeDisassocConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x10f3565644b5b2aa => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseDisassocIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseDisassocIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::DisassocInd {ind: req.ind,
responder: WlanFullmacImplIfcBridgeDisassocIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x45cd1385bf807723 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseStartConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseStartConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::StartConf {resp: req.resp,
responder: WlanFullmacImplIfcBridgeStartConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4955a91549ee69b2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseStopConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseStopConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::StopConf {resp: req.resp,
responder: WlanFullmacImplIfcBridgeStopConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1f1f10c6aff5f5fd => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseEapolConfRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseEapolConfRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::EapolConf {resp: req.resp,
responder: WlanFullmacImplIfcBridgeEapolConfResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1bd58e236346deef => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnChannelSwitchRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnChannelSwitchRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::OnChannelSwitch {ind: req.ind,
responder: WlanFullmacImplIfcBridgeOnChannelSwitchResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2f4687c6bf250510 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseSignalReportRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseSignalReportRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::SignalReport {ind: req.ind,
responder: WlanFullmacImplIfcBridgeSignalReportResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xdd7f86db0551e81 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseEapolIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseEapolIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::EapolInd {ind: req.ind,
responder: WlanFullmacImplIfcBridgeEapolIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3eed32d74dc54818 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnPmkAvailableRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnPmkAvailableRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::OnPmkAvailable {info: req.info,
responder: WlanFullmacImplIfcBridgeOnPmkAvailableResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1a925d47ed6f28ed => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseSaeHandshakeIndRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseSaeHandshakeIndRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::SaeHandshakeInd {ind: req.ind,
responder: WlanFullmacImplIfcBridgeSaeHandshakeIndResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x26b842795b7688f3 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseSaeFrameRxRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseSaeFrameRxRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::SaeFrameRx {frame: req.frame,
responder: WlanFullmacImplIfcBridgeSaeFrameRxResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x39334623a4cd8128 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(WlanFullmacImplIfcBaseOnWmmStatusRespRequest);
fidl::encoding::Decoder::decode_into::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest>(&header, _body_bytes, handles, &mut req)?;
let control_handle = WlanFullmacImplIfcBridgeControlHandle {
inner: this.inner.clone(),
};
Ok(WlanFullmacImplIfcBridgeRequest::OnWmmStatusResp {status: req.status,
wmm_params: req.wmm_params,
responder: WlanFullmacImplIfcBridgeOnWmmStatusRespResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <WlanFullmacImplIfcBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum WlanFullmacImplIfcBridgeRequest {
OnScanResult {
result: WlanFullmacScanResult,
responder: WlanFullmacImplIfcBridgeOnScanResultResponder,
},
OnScanEnd {
end: WlanFullmacScanEnd,
responder: WlanFullmacImplIfcBridgeOnScanEndResponder,
},
ConnectConf {
resp: WlanFullmacConnectConfirm,
responder: WlanFullmacImplIfcBridgeConnectConfResponder,
},
RoamConf {
resp: WlanFullmacRoamConfirm,
responder: WlanFullmacImplIfcBridgeRoamConfResponder,
},
AuthInd {
resp: WlanFullmacAuthInd,
responder: WlanFullmacImplIfcBridgeAuthIndResponder,
},
DeauthConf {
payload: WlanFullmacImplIfcBaseDeauthConfRequest,
responder: WlanFullmacImplIfcBridgeDeauthConfResponder,
},
DeauthInd {
ind: WlanFullmacDeauthIndication,
responder: WlanFullmacImplIfcBridgeDeauthIndResponder,
},
AssocInd {
resp: WlanFullmacAssocInd,
responder: WlanFullmacImplIfcBridgeAssocIndResponder,
},
DisassocConf {
resp: WlanFullmacDisassocConfirm,
responder: WlanFullmacImplIfcBridgeDisassocConfResponder,
},
DisassocInd {
ind: WlanFullmacDisassocIndication,
responder: WlanFullmacImplIfcBridgeDisassocIndResponder,
},
StartConf {
resp: WlanFullmacStartConfirm,
responder: WlanFullmacImplIfcBridgeStartConfResponder,
},
StopConf {
resp: WlanFullmacStopConfirm,
responder: WlanFullmacImplIfcBridgeStopConfResponder,
},
EapolConf {
resp: WlanFullmacEapolConfirm,
responder: WlanFullmacImplIfcBridgeEapolConfResponder,
},
OnChannelSwitch {
ind: WlanFullmacChannelSwitchInfo,
responder: WlanFullmacImplIfcBridgeOnChannelSwitchResponder,
},
SignalReport {
ind: WlanFullmacSignalReportIndication,
responder: WlanFullmacImplIfcBridgeSignalReportResponder,
},
EapolInd {
ind: WlanFullmacEapolIndication,
responder: WlanFullmacImplIfcBridgeEapolIndResponder,
},
OnPmkAvailable {
info: WlanFullmacPmkInfo,
responder: WlanFullmacImplIfcBridgeOnPmkAvailableResponder,
},
SaeHandshakeInd {
ind: WlanFullmacSaeHandshakeInd,
responder: WlanFullmacImplIfcBridgeSaeHandshakeIndResponder,
},
SaeFrameRx {
frame: WlanFullmacSaeFrame,
responder: WlanFullmacImplIfcBridgeSaeFrameRxResponder,
},
OnWmmStatusResp {
status: i32,
wmm_params: fidl_fuchsia_wlan_common::WlanWmmParameters,
responder: WlanFullmacImplIfcBridgeOnWmmStatusRespResponder,
},
}
impl WlanFullmacImplIfcBridgeRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_on_scan_result(
self,
) -> Option<(WlanFullmacScanResult, WlanFullmacImplIfcBridgeOnScanResultResponder)> {
if let WlanFullmacImplIfcBridgeRequest::OnScanResult { result, responder } = self {
Some((result, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_scan_end(
self,
) -> Option<(WlanFullmacScanEnd, WlanFullmacImplIfcBridgeOnScanEndResponder)> {
if let WlanFullmacImplIfcBridgeRequest::OnScanEnd { end, responder } = self {
Some((end, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect_conf(
self,
) -> Option<(WlanFullmacConnectConfirm, WlanFullmacImplIfcBridgeConnectConfResponder)> {
if let WlanFullmacImplIfcBridgeRequest::ConnectConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_roam_conf(
self,
) -> Option<(WlanFullmacRoamConfirm, WlanFullmacImplIfcBridgeRoamConfResponder)> {
if let WlanFullmacImplIfcBridgeRequest::RoamConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_auth_ind(
self,
) -> Option<(WlanFullmacAuthInd, WlanFullmacImplIfcBridgeAuthIndResponder)> {
if let WlanFullmacImplIfcBridgeRequest::AuthInd { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_deauth_conf(
self,
) -> Option<(
WlanFullmacImplIfcBaseDeauthConfRequest,
WlanFullmacImplIfcBridgeDeauthConfResponder,
)> {
if let WlanFullmacImplIfcBridgeRequest::DeauthConf { payload, responder } = self {
Some((payload, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_deauth_ind(
self,
) -> Option<(WlanFullmacDeauthIndication, WlanFullmacImplIfcBridgeDeauthIndResponder)> {
if let WlanFullmacImplIfcBridgeRequest::DeauthInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_assoc_ind(
self,
) -> Option<(WlanFullmacAssocInd, WlanFullmacImplIfcBridgeAssocIndResponder)> {
if let WlanFullmacImplIfcBridgeRequest::AssocInd { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disassoc_conf(
self,
) -> Option<(WlanFullmacDisassocConfirm, WlanFullmacImplIfcBridgeDisassocConfResponder)> {
if let WlanFullmacImplIfcBridgeRequest::DisassocConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disassoc_ind(
self,
) -> Option<(WlanFullmacDisassocIndication, WlanFullmacImplIfcBridgeDisassocIndResponder)> {
if let WlanFullmacImplIfcBridgeRequest::DisassocInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_start_conf(
self,
) -> Option<(WlanFullmacStartConfirm, WlanFullmacImplIfcBridgeStartConfResponder)> {
if let WlanFullmacImplIfcBridgeRequest::StartConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_stop_conf(
self,
) -> Option<(WlanFullmacStopConfirm, WlanFullmacImplIfcBridgeStopConfResponder)> {
if let WlanFullmacImplIfcBridgeRequest::StopConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_eapol_conf(
self,
) -> Option<(WlanFullmacEapolConfirm, WlanFullmacImplIfcBridgeEapolConfResponder)> {
if let WlanFullmacImplIfcBridgeRequest::EapolConf { resp, responder } = self {
Some((resp, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_channel_switch(
self,
) -> Option<(WlanFullmacChannelSwitchInfo, WlanFullmacImplIfcBridgeOnChannelSwitchResponder)>
{
if let WlanFullmacImplIfcBridgeRequest::OnChannelSwitch { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_signal_report(
self,
) -> Option<(WlanFullmacSignalReportIndication, WlanFullmacImplIfcBridgeSignalReportResponder)>
{
if let WlanFullmacImplIfcBridgeRequest::SignalReport { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_eapol_ind(
self,
) -> Option<(WlanFullmacEapolIndication, WlanFullmacImplIfcBridgeEapolIndResponder)> {
if let WlanFullmacImplIfcBridgeRequest::EapolInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_pmk_available(
self,
) -> Option<(WlanFullmacPmkInfo, WlanFullmacImplIfcBridgeOnPmkAvailableResponder)> {
if let WlanFullmacImplIfcBridgeRequest::OnPmkAvailable { info, responder } = self {
Some((info, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_handshake_ind(
self,
) -> Option<(WlanFullmacSaeHandshakeInd, WlanFullmacImplIfcBridgeSaeHandshakeIndResponder)>
{
if let WlanFullmacImplIfcBridgeRequest::SaeHandshakeInd { ind, responder } = self {
Some((ind, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_sae_frame_rx(
self,
) -> Option<(WlanFullmacSaeFrame, WlanFullmacImplIfcBridgeSaeFrameRxResponder)> {
if let WlanFullmacImplIfcBridgeRequest::SaeFrameRx { frame, responder } = self {
Some((frame, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_on_wmm_status_resp(
self,
) -> Option<(
i32,
fidl_fuchsia_wlan_common::WlanWmmParameters,
WlanFullmacImplIfcBridgeOnWmmStatusRespResponder,
)> {
if let WlanFullmacImplIfcBridgeRequest::OnWmmStatusResp { status, wmm_params, responder } =
self
{
Some((status, wmm_params, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
WlanFullmacImplIfcBridgeRequest::OnScanResult { .. } => "on_scan_result",
WlanFullmacImplIfcBridgeRequest::OnScanEnd { .. } => "on_scan_end",
WlanFullmacImplIfcBridgeRequest::ConnectConf { .. } => "connect_conf",
WlanFullmacImplIfcBridgeRequest::RoamConf { .. } => "roam_conf",
WlanFullmacImplIfcBridgeRequest::AuthInd { .. } => "auth_ind",
WlanFullmacImplIfcBridgeRequest::DeauthConf { .. } => "deauth_conf",
WlanFullmacImplIfcBridgeRequest::DeauthInd { .. } => "deauth_ind",
WlanFullmacImplIfcBridgeRequest::AssocInd { .. } => "assoc_ind",
WlanFullmacImplIfcBridgeRequest::DisassocConf { .. } => "disassoc_conf",
WlanFullmacImplIfcBridgeRequest::DisassocInd { .. } => "disassoc_ind",
WlanFullmacImplIfcBridgeRequest::StartConf { .. } => "start_conf",
WlanFullmacImplIfcBridgeRequest::StopConf { .. } => "stop_conf",
WlanFullmacImplIfcBridgeRequest::EapolConf { .. } => "eapol_conf",
WlanFullmacImplIfcBridgeRequest::OnChannelSwitch { .. } => "on_channel_switch",
WlanFullmacImplIfcBridgeRequest::SignalReport { .. } => "signal_report",
WlanFullmacImplIfcBridgeRequest::EapolInd { .. } => "eapol_ind",
WlanFullmacImplIfcBridgeRequest::OnPmkAvailable { .. } => "on_pmk_available",
WlanFullmacImplIfcBridgeRequest::SaeHandshakeInd { .. } => "sae_handshake_ind",
WlanFullmacImplIfcBridgeRequest::SaeFrameRx { .. } => "sae_frame_rx",
WlanFullmacImplIfcBridgeRequest::OnWmmStatusResp { .. } => "on_wmm_status_resp",
}
}
}
#[derive(Debug, Clone)]
pub struct WlanFullmacImplIfcBridgeControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for WlanFullmacImplIfcBridgeControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
}
impl WlanFullmacImplIfcBridgeControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeOnScanResultResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeOnScanResultResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeOnScanResultResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeOnScanResultResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x88e861d700f64f8,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeOnScanEndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeOnScanEndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeOnScanEndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeOnScanEndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x76c6bed92c990276,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeConnectConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeConnectConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeConnectConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeConnectConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x75d0197de2f9b917,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeRoamConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeRoamConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeRoamConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeRoamConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0xe9bd7650a98031e,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeAuthIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeAuthIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeAuthIndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeAuthIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3e7a3572a9f63462,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeDeauthConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeDeauthConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeDeauthConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeDeauthConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x28252ce030ea7bfa,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeDeauthIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeDeauthIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeDeauthIndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeDeauthIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x182a4013cb8a74ce,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeAssocIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeAssocIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeAssocIndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeAssocIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x6df7225a8d83b32b,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeDisassocConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeDisassocConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeDisassocConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeDisassocConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x2fd70afed8eac241,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeDisassocIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeDisassocIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeDisassocIndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeDisassocIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x10f3565644b5b2aa,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeStartConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeStartConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeStartConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeStartConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x45cd1385bf807723,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeStopConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeStopConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeStopConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeStopConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x4955a91549ee69b2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeEapolConfResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeEapolConfResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeEapolConfResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeEapolConfResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x1f1f10c6aff5f5fd,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeOnChannelSwitchResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeOnChannelSwitchResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeOnChannelSwitchResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeOnChannelSwitchResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x1bd58e236346deef,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeSignalReportResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeSignalReportResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeSignalReportResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeSignalReportResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x2f4687c6bf250510,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeEapolIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeEapolIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeEapolIndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeEapolIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0xdd7f86db0551e81,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeOnPmkAvailableResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeOnPmkAvailableResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeOnPmkAvailableResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeOnPmkAvailableResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x3eed32d74dc54818,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeSaeHandshakeIndResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeSaeHandshakeIndResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeSaeHandshakeIndResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeSaeHandshakeIndResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x1a925d47ed6f28ed,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeSaeFrameRxResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeSaeFrameRxResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeSaeFrameRxResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeSaeFrameRxResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x26b842795b7688f3,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct WlanFullmacImplIfcBridgeOnWmmStatusRespResponder {
control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcBridgeControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for WlanFullmacImplIfcBridgeOnWmmStatusRespResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for WlanFullmacImplIfcBridgeOnWmmStatusRespResponder {
type ControlHandle = WlanFullmacImplIfcBridgeControlHandle;
fn control_handle(&self) -> &WlanFullmacImplIfcBridgeControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl WlanFullmacImplIfcBridgeOnWmmStatusRespResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x39334623a4cd8128,
fidl::encoding::DynamicFlags::empty(),
)
}
}
mod internal {
use super::*;
unsafe impl fidl::encoding::TypeMarker for WlanAssocResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanAssocResult {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanAssocResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanAssocResult {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanAuthResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanAuthResult {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanAuthResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanAuthResult {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanAuthType {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanAuthType {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanAuthType {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanAuthType {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanEapolResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanEapolResult {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanEapolResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanEapolResult {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacAntennaFreq {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacAntennaFreq {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanFullmacAntennaFreq {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacAntennaFreq {
#[inline(always)]
fn new_empty() -> Self {
Self::Antenna2G
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacHistScope {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacHistScope {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanFullmacHistScope {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacHistScope {
#[inline(always)]
fn new_empty() -> Self {
Self::Station
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanScanResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanScanResult {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanScanResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanScanResult {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanScanType {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanScanType {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanScanType {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanScanType {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanStartResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanStartResult {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanStartResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanStartResult {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanStopResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for WlanStopResult {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for WlanStopResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanStopResult {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeleteKeyDescriptor {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
10
}
}
impl fidl::encoding::ValueTypeMarker for DeleteKeyDescriptor {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeleteKeyDescriptor> for &DeleteKeyDescriptor {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeleteKeyDescriptor>(offset);
fidl::encoding::Encode::<DeleteKeyDescriptor>::encode(
(
<u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.key_id),
<fidl_fuchsia_wlan_common::WlanKeyType as fidl::encoding::ValueTypeMarker>::borrow(&self.key_type),
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<u16>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common::WlanKeyType>,
T2: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
> fidl::encoding::Encode<DeleteKeyDescriptor> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeleteKeyDescriptor>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u16).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 2, depth)?;
self.2.encode(encoder, offset + 3, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeleteKeyDescriptor {
#[inline(always)]
fn new_empty() -> Self {
Self {
key_id: fidl::new_empty!(u16),
key_type: fidl::new_empty!(fidl_fuchsia_wlan_common::WlanKeyType),
address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
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 + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(u16, &mut self.key_id, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_common::WlanKeyType,
&mut self.key_type,
decoder,
offset + 2,
_depth
)?;
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.address, decoder, offset + 3, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacAntennaId {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacAntennaId {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacAntennaId> for &WlanFullmacAntennaId {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacAntennaId>(offset);
fidl::encoding::Encode::<WlanFullmacAntennaId>::encode(
(
<WlanFullmacAntennaFreq as fidl::encoding::ValueTypeMarker>::borrow(&self.freq),
<u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacAntennaFreq>, T1: fidl::encoding::Encode<u8>>
fidl::encoding::Encode<WlanFullmacAntennaId> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacAntennaId>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacAntennaId {
#[inline(always)]
fn new_empty() -> Self {
Self { freq: fidl::new_empty!(WlanFullmacAntennaFreq), index: fidl::new_empty!(u8) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacAntennaFreq, &mut self.freq, decoder, offset + 0, _depth)?;
fidl::decode!(u8, &mut self.index, decoder, offset + 1, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacAssocInd {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
848
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacAssocInd {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacAssocInd> for &WlanFullmacAssocInd {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacAssocInd>(offset);
fidl::encoding::Encode::<WlanFullmacAssocInd>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
&self.peer_sta_address,
),
<u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.listen_interval),
<fidl_fuchsia_wlan_ieee80211::CSsid as fidl::encoding::ValueTypeMarker>::borrow(
&self.ssid,
),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.rsne_len),
<fidl::encoding::Array<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rsne,
),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.vendor_ie_len),
<fidl::encoding::Array<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow(
&self.vendor_ie,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<u16>,
T2: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::CSsid>,
T3: fidl::encoding::Encode<u64>,
T4: fidl::encoding::Encode<fidl::encoding::Array<u8, 257>>,
T5: fidl::encoding::Encode<u64>,
T6: fidl::encoding::Encode<fidl::encoding::Array<u8, 514>>,
> fidl::encoding::Encode<WlanFullmacAssocInd> for (T0, T1, T2, T3, T4, T5, T6)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacAssocInd>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(312);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(840);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 48, depth)?;
self.4.encode(encoder, offset + 56, depth)?;
self.5.encode(encoder, offset + 320, depth)?;
self.6.encode(encoder, offset + 328, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacAssocInd {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
listen_interval: fidl::new_empty!(u16),
ssid: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::CSsid),
rsne_len: fidl::new_empty!(u64),
rsne: fidl::new_empty!(fidl::encoding::Array<u8, 257>),
vendor_ie_len: fidl::new_empty!(u64),
vendor_ie: fidl::new_empty!(fidl::encoding::Array<u8, 514>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
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 + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(312) };
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 + 312 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(840) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffffff0000u64;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 840 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(u16, &mut self.listen_interval, decoder, offset + 6, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::CSsid,
&mut self.ssid,
decoder,
offset + 8,
_depth
)?;
fidl::decode!(u64, &mut self.rsne_len, decoder, offset + 48, _depth)?;
fidl::decode!(fidl::encoding::Array<u8, 257>, &mut self.rsne, decoder, offset + 56, _depth)?;
fidl::decode!(u64, &mut self.vendor_ie_len, decoder, offset + 320, _depth)?;
fidl::decode!(fidl::encoding::Array<u8, 514>, &mut self.vendor_ie, decoder, offset + 328, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacAuthInd {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
7
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacAuthInd {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacAuthInd> for &WlanFullmacAuthInd {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacAuthInd>(offset);
fidl::encoding::Encode::<WlanFullmacAuthInd>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
&self.peer_sta_address,
),
<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow(&self.auth_type),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<WlanAuthType>,
> fidl::encoding::Encode<WlanFullmacAuthInd> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacAuthInd>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacAuthInd {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
auth_type: fidl::new_empty!(WlanAuthType),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(WlanAuthType, &mut self.auth_type, decoder, offset + 6, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacBandCapability {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
312
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacBandCapability {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacBandCapability> for &WlanFullmacBandCapability {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacBandCapability>(offset);
fidl::encoding::Encode::<WlanFullmacBandCapability>::encode(
(
<fidl_fuchsia_wlan_common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow(&self.band),
<u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.basic_rate_count),
<fidl::encoding::Array<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow(&self.basic_rate_list),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.ht_supported),
<fidl_fuchsia_wlan_ieee80211::HtCapabilities as fidl::encoding::ValueTypeMarker>::borrow(&self.ht_caps),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.vht_supported),
<fidl_fuchsia_wlan_ieee80211::VhtCapabilities as fidl::encoding::ValueTypeMarker>::borrow(&self.vht_caps),
<u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.operating_channel_count),
<fidl::encoding::Array<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.operating_channel_list),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common::WlanBand>,
T1: fidl::encoding::Encode<u8>,
T2: fidl::encoding::Encode<fidl::encoding::Array<u8, 12>>,
T3: fidl::encoding::Encode<bool>,
T4: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::HtCapabilities>,
T5: fidl::encoding::Encode<bool>,
T6: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::VhtCapabilities>,
T7: fidl::encoding::Encode<u16>,
T8: fidl::encoding::Encode<fidl::encoding::Array<u8, 256>>,
> fidl::encoding::Encode<WlanFullmacBandCapability>
for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacBandCapability>(offset);
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 + 14, depth)?;
self.4.encode(encoder, offset + 15, depth)?;
self.5.encode(encoder, offset + 41, depth)?;
self.6.encode(encoder, offset + 42, depth)?;
self.7.encode(encoder, offset + 54, depth)?;
self.8.encode(encoder, offset + 56, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacBandCapability {
#[inline(always)]
fn new_empty() -> Self {
Self {
band: fidl::new_empty!(fidl_fuchsia_wlan_common::WlanBand),
basic_rate_count: fidl::new_empty!(u8),
basic_rate_list: fidl::new_empty!(fidl::encoding::Array<u8, 12>),
ht_supported: fidl::new_empty!(bool),
ht_caps: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::HtCapabilities),
vht_supported: fidl::new_empty!(bool),
vht_caps: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::VhtCapabilities),
operating_channel_count: fidl::new_empty!(u16),
operating_channel_list: fidl::new_empty!(fidl::encoding::Array<u8, 256>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_wlan_common::WlanBand,
&mut self.band,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(u8, &mut self.basic_rate_count, decoder, offset + 1, _depth)?;
fidl::decode!(fidl::encoding::Array<u8, 12>, &mut self.basic_rate_list, decoder, offset + 2, _depth)?;
fidl::decode!(bool, &mut self.ht_supported, decoder, offset + 14, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::HtCapabilities,
&mut self.ht_caps,
decoder,
offset + 15,
_depth
)?;
fidl::decode!(bool, &mut self.vht_supported, decoder, offset + 41, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::VhtCapabilities,
&mut self.vht_caps,
decoder,
offset + 42,
_depth
)?;
fidl::decode!(u16, &mut self.operating_channel_count, decoder, offset + 54, _depth)?;
fidl::decode!(fidl::encoding::Array<u8, 256>, &mut self.operating_channel_list, decoder, offset + 56, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacChannelSwitchInfo {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacChannelSwitchInfo {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacChannelSwitchInfo> for &WlanFullmacChannelSwitchInfo {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacChannelSwitchInfo)
.write_unaligned((self as *const WlanFullmacChannelSwitchInfo).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u8>> fidl::encoding::Encode<WlanFullmacChannelSwitchInfo>
for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacChannelSwitchInfo {
#[inline(always)]
fn new_empty() -> Self {
Self { new_channel: fidl::new_empty!(u8) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacConnectConfirm {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacConnectConfirm {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacConnectConfirm> for &WlanFullmacConnectConfirm {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacConnectConfirm>(offset);
fidl::encoding::Encode::<WlanFullmacConnectConfirm>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
<fidl_fuchsia_wlan_ieee80211::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
<u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::StatusCode>,
T2: fidl::encoding::Encode<u16>,
T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>>,
> fidl::encoding::Encode<WlanFullmacConnectConfirm> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacConnectConfirm>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacConnectConfirm {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
result_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::StatusCode),
association_id: fidl::new_empty!(u16),
association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffffff0000u64;
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::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::StatusCode,
&mut self.result_code,
decoder,
offset + 6,
_depth
)?;
fidl::decode!(u16, &mut self.association_id, decoder, offset + 8, _depth)?;
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
&mut self.association_ies,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacDeauthIndication {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
10
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacDeauthIndication {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacDeauthIndication> for &WlanFullmacDeauthIndication {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDeauthIndication>(offset);
fidl::encoding::Encode::<WlanFullmacDeauthIndication>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
<fidl_fuchsia_wlan_ieee80211::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.locally_initiated),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::ReasonCode>,
T2: fidl::encoding::Encode<bool>,
> fidl::encoding::Encode<WlanFullmacDeauthIndication> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDeauthIndication>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u16).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacDeauthIndication {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::ReasonCode),
locally_initiated: fidl::new_empty!(bool),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
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 + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::ReasonCode,
&mut self.reason_code,
decoder,
offset + 6,
_depth
)?;
fidl::decode!(bool, &mut self.locally_initiated, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacDelKeysReq {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
48
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacDelKeysReq {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacDelKeysReq> for &WlanFullmacDelKeysReq {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDelKeysReq>(offset);
fidl::encoding::Encode::<WlanFullmacDelKeysReq>::encode(
(
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_keys),
<fidl::encoding::Array<DeleteKeyDescriptor, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.keylist),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<u64>,
T1: fidl::encoding::Encode<fidl::encoding::Array<DeleteKeyDescriptor, 4>>,
> fidl::encoding::Encode<WlanFullmacDelKeysReq> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDelKeysReq>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacDelKeysReq {
#[inline(always)]
fn new_empty() -> Self {
Self {
num_keys: fidl::new_empty!(u64),
keylist: fidl::new_empty!(fidl::encoding::Array<DeleteKeyDescriptor, 4>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(u64, &mut self.num_keys, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Array<DeleteKeyDescriptor, 4>, &mut self.keylist, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacDisassocConfirm {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacDisassocConfirm {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacDisassocConfirm> for &WlanFullmacDisassocConfirm {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDisassocConfirm>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacDisassocConfirm)
.write_unaligned((self as *const WlanFullmacDisassocConfirm).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i32>> fidl::encoding::Encode<WlanFullmacDisassocConfirm>
for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDisassocConfirm>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacDisassocConfirm {
#[inline(always)]
fn new_empty() -> Self {
Self { status: fidl::new_empty!(i32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacDisassocIndication {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
10
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacDisassocIndication {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacDisassocIndication>
for &WlanFullmacDisassocIndication
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDisassocIndication>(offset);
fidl::encoding::Encode::<WlanFullmacDisassocIndication>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
<fidl_fuchsia_wlan_ieee80211::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.locally_initiated),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::ReasonCode>,
T2: fidl::encoding::Encode<bool>,
> fidl::encoding::Encode<WlanFullmacDisassocIndication> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacDisassocIndication>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u16).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacDisassocIndication {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::ReasonCode),
locally_initiated: fidl::new_empty!(bool),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
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 + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::ReasonCode,
&mut self.reason_code,
decoder,
offset + 6,
_depth
)?;
fidl::decode!(bool, &mut self.locally_initiated, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacEapolConfirm {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
7
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacEapolConfirm {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacEapolConfirm> for &WlanFullmacEapolConfirm {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacEapolConfirm>(offset);
fidl::encoding::Encode::<WlanFullmacEapolConfirm>::encode(
(
<WlanEapolResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
&self.dst_addr,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<WlanEapolResult>,
T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
> fidl::encoding::Encode<WlanFullmacEapolConfirm> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacEapolConfirm>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacEapolConfirm {
#[inline(always)]
fn new_empty() -> Self {
Self {
result_code: fidl::new_empty!(WlanEapolResult),
dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanEapolResult, &mut self.result_code, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.dst_addr, decoder, offset + 1, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacEapolIndication {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacEapolIndication {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacEapolIndication> for &WlanFullmacEapolIndication {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacEapolIndication>(offset);
fidl::encoding::Encode::<WlanFullmacEapolIndication>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.src_addr),
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_addr),
<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>>,
> fidl::encoding::Encode<WlanFullmacEapolIndication> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacEapolIndication>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacEapolIndication {
#[inline(always)]
fn new_empty() -> Self {
Self {
src_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
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 + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.src_addr, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.dst_addr, decoder, offset + 6, _depth)?;
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
&mut self.data,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacHistBucket {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacHistBucket {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacHistBucket> for &WlanFullmacHistBucket {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacHistBucket>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacHistBucket)
.write_unaligned((self as *const WlanFullmacHistBucket).read());
let padding_ptr = buf_ptr.offset(0) as *mut u64;
let padding_mask = 0xffffffffffff0000u64;
padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u16>, T1: fidl::encoding::Encode<u64>>
fidl::encoding::Encode<WlanFullmacHistBucket> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacHistBucket>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacHistBucket {
#[inline(always)]
fn new_empty() -> Self {
Self { bucket_index: fidl::new_empty!(u16), num_samples: fidl::new_empty!(u64) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
let ptr = unsafe { buf_ptr.offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffffff0000u64;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacIfaceCounterStats {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
40
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacIfaceCounterStats {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacIfaceCounterStats> for &WlanFullmacIfaceCounterStats {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacIfaceCounterStats>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacIfaceCounterStats)
.write_unaligned((self as *const WlanFullmacIfaceCounterStats).read());
}
Ok(())
}
}
unsafe impl<
T0: fidl::encoding::Encode<u64>,
T1: fidl::encoding::Encode<u64>,
T2: fidl::encoding::Encode<u64>,
T3: fidl::encoding::Encode<u64>,
T4: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<WlanFullmacIfaceCounterStats> for (T0, T1, T2, T3, T4)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacIfaceCounterStats>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
self.2.encode(encoder, offset + 16, depth)?;
self.3.encode(encoder, offset + 24, depth)?;
self.4.encode(encoder, offset + 32, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacIfaceCounterStats {
#[inline(always)]
fn new_empty() -> Self {
Self {
rx_unicast_total: fidl::new_empty!(u64),
rx_unicast_drop: fidl::new_empty!(u64),
rx_multicast: fidl::new_empty!(u64),
tx_total: fidl::new_empty!(u64),
tx_drop: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 40);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseDelKeysReqRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
48
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseDelKeysReqRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseDelKeysReqRequest>
for &WlanFullmacImplBaseDelKeysReqRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseDelKeysReqRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseDelKeysReqRequest>::encode(
(<WlanFullmacDelKeysReq as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacDelKeysReq>>
fidl::encoding::Encode<WlanFullmacImplBaseDelKeysReqRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseDelKeysReqRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseDelKeysReqRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { req: fidl::new_empty!(WlanFullmacDelKeysReq) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacDelKeysReq, &mut self.req, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseOnLinkStateChangedRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseOnLinkStateChangedRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseOnLinkStateChangedRequest>
for &WlanFullmacImplBaseOnLinkStateChangedRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseOnLinkStateChangedRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseOnLinkStateChangedRequest>::encode(
(<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.online),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<bool>>
fidl::encoding::Encode<WlanFullmacImplBaseOnLinkStateChangedRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseOnLinkStateChangedRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseOnLinkStateChangedRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { online: fidl::new_empty!(bool) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(bool, &mut self.online, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseSaeFrameTxRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseSaeFrameTxRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseSaeFrameTxRequest>
for &WlanFullmacImplBaseSaeFrameTxRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSaeFrameTxRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseSaeFrameTxRequest>::encode(
(<WlanFullmacSaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSaeFrame>>
fidl::encoding::Encode<WlanFullmacImplBaseSaeFrameTxRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSaeFrameTxRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseSaeFrameTxRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { frame: fidl::new_empty!(WlanFullmacSaeFrame) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacSaeFrame, &mut self.frame, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseSaeHandshakeRespRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseSaeHandshakeRespRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseSaeHandshakeRespRequest>
for &WlanFullmacImplBaseSaeHandshakeRespRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSaeHandshakeRespRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseSaeHandshakeRespRequest>::encode(
(<WlanFullmacSaeHandshakeResp as fidl::encoding::ValueTypeMarker>::borrow(
&self.resp,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSaeHandshakeResp>>
fidl::encoding::Encode<WlanFullmacImplBaseSaeHandshakeRespRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSaeHandshakeRespRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseSaeHandshakeRespRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacSaeHandshakeResp) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
WlanFullmacSaeHandshakeResp,
&mut self.resp,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseSetKeysReqRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
72
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseSetKeysReqRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseSetKeysReqRequest>
for &WlanFullmacImplBaseSetKeysReqRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSetKeysReqRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseSetKeysReqRequest>::encode(
(<WlanFullmacSetKeysReq as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSetKeysReq>>
fidl::encoding::Encode<WlanFullmacImplBaseSetKeysReqRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSetKeysReqRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseSetKeysReqRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { req: fidl::new_empty!(WlanFullmacSetKeysReq) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacSetKeysReq, &mut self.req, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseSetKeysReqResponse {
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
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseSetKeysReqResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseSetKeysReqResponse>
for &WlanFullmacImplBaseSetKeysReqResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSetKeysReqResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacImplBaseSetKeysReqResponse)
.write_unaligned((self as *const WlanFullmacImplBaseSetKeysReqResponse).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSetKeysResp>>
fidl::encoding::Encode<WlanFullmacImplBaseSetKeysReqResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSetKeysReqResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseSetKeysReqResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacSetKeysResp) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseSetMulticastPromiscRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseSetMulticastPromiscRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseSetMulticastPromiscRequest>
for &WlanFullmacImplBaseSetMulticastPromiscRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSetMulticastPromiscRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseSetMulticastPromiscRequest>::encode(
(<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enable),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<bool>>
fidl::encoding::Encode<WlanFullmacImplBaseSetMulticastPromiscRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseSetMulticastPromiscRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseSetMulticastPromiscRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { enable: fidl::new_empty!(bool) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(bool, &mut self.enable, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseGetIfaceCounterStatsResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
40
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseGetIfaceCounterStatsResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseGetIfaceCounterStatsResponse>
for &WlanFullmacImplBaseGetIfaceCounterStatsResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseGetIfaceCounterStatsResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacImplBaseGetIfaceCounterStatsResponse).write_unaligned(
(self as *const WlanFullmacImplBaseGetIfaceCounterStatsResponse).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacIfaceCounterStats>>
fidl::encoding::Encode<WlanFullmacImplBaseGetIfaceCounterStatsResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseGetIfaceCounterStatsResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseGetIfaceCounterStatsResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { stats: fidl::new_empty!(WlanFullmacIfaceCounterStats) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 40);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseGetIfaceHistogramStatsResponse {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseGetIfaceHistogramStatsResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseGetIfaceHistogramStatsResponse>
for &WlanFullmacImplBaseGetIfaceHistogramStatsResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseGetIfaceHistogramStatsResponse>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseGetIfaceHistogramStatsResponse>::encode(
(<WlanFullmacIfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(
&self.stats,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacIfaceHistogramStats>>
fidl::encoding::Encode<WlanFullmacImplBaseGetIfaceHistogramStatsResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseGetIfaceHistogramStatsResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseGetIfaceHistogramStatsResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { stats: fidl::new_empty!(WlanFullmacIfaceHistogramStats) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
WlanFullmacIfaceHistogramStats,
&mut self.stats,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseQueryMacSublayerSupportResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
5
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseQueryMacSublayerSupportResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseQueryMacSublayerSupportResponse>
for &WlanFullmacImplBaseQueryMacSublayerSupportResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder
.debug_check_bounds::<WlanFullmacImplBaseQueryMacSublayerSupportResponse>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseQueryMacSublayerSupportResponse>::encode(
(
<fidl_fuchsia_wlan_common::MacSublayerSupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common::MacSublayerSupport>>
fidl::encoding::Encode<WlanFullmacImplBaseQueryMacSublayerSupportResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder
.debug_check_bounds::<WlanFullmacImplBaseQueryMacSublayerSupportResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseQueryMacSublayerSupportResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common::MacSublayerSupport) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_wlan_common::MacSublayerSupport,
&mut self.resp,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseQuerySecuritySupportResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
3
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseQuerySecuritySupportResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseQuerySecuritySupportResponse>
for &WlanFullmacImplBaseQuerySecuritySupportResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseQuerySecuritySupportResponse>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseQuerySecuritySupportResponse>::encode(
(
<fidl_fuchsia_wlan_common::SecuritySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common::SecuritySupport>>
fidl::encoding::Encode<WlanFullmacImplBaseQuerySecuritySupportResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseQuerySecuritySupportResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseQuerySecuritySupportResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common::SecuritySupport) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_wlan_common::SecuritySupport,
&mut self.resp,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker
for WlanFullmacImplBaseQuerySpectrumManagementSupportResponse
{
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseQuerySpectrumManagementSupportResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseQuerySpectrumManagementSupportResponse>
for &WlanFullmacImplBaseQuerySpectrumManagementSupportResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder
.debug_check_bounds::<WlanFullmacImplBaseQuerySpectrumManagementSupportResponse>(
offset,
);
fidl::encoding::Encode::<WlanFullmacImplBaseQuerySpectrumManagementSupportResponse>::encode(
(
<fidl_fuchsia_wlan_common::SpectrumManagementSupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common::SpectrumManagementSupport>>
fidl::encoding::Encode<WlanFullmacImplBaseQuerySpectrumManagementSupportResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder
.debug_check_bounds::<WlanFullmacImplBaseQuerySpectrumManagementSupportResponse>(
offset,
);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseQuerySpectrumManagementSupportResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common::SpectrumManagementSupport) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_wlan_common::SpectrumManagementSupport,
&mut self.resp,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseQueryResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
5008
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseQueryResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseQueryResponse>
for &WlanFullmacImplBaseQueryResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseQueryResponse>(offset);
fidl::encoding::Encode::<WlanFullmacImplBaseQueryResponse>::encode(
(<WlanFullmacQueryInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacQueryInfo>>
fidl::encoding::Encode<WlanFullmacImplBaseQueryResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseQueryResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseQueryResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { info: fidl::new_empty!(WlanFullmacQueryInfo) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacQueryInfo, &mut self.info, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBridgeStartRequest {
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
}
}
impl fidl::encoding::ResourceTypeMarker for WlanFullmacImplBridgeStartRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBridgeStartRequest>
for &mut WlanFullmacImplBridgeStartRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBridgeStartRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplBridgeStartRequest>::encode(
(<fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.ifc
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
>,
>,
> fidl::encoding::Encode<WlanFullmacImplBridgeStartRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBridgeStartRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBridgeStartRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
ifc: fidl::new_empty!(
fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<WlanFullmacImplIfcBridgeMarker>,
>,
&mut self.ifc,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBridgeStartResponse {
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
}
}
impl fidl::encoding::ResourceTypeMarker for WlanFullmacImplBridgeStartResponse {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBridgeStartResponse>
for &mut WlanFullmacImplBridgeStartResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBridgeStartResponse>(offset);
fidl::encoding::Encode::<WlanFullmacImplBridgeStartResponse>::encode(
(<fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.sme_channel
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
> fidl::encoding::Encode<WlanFullmacImplBridgeStartResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBridgeStartResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBridgeStartResponse {
#[inline(always)]
fn new_empty() -> Self {
Self {
sme_channel: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.sme_channel, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseAssocIndRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
848
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseAssocIndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseAssocIndRequest>
for &WlanFullmacImplIfcBaseAssocIndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseAssocIndRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseAssocIndRequest>::encode(
(<WlanFullmacAssocInd as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacAssocInd>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseAssocIndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseAssocIndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseAssocIndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacAssocInd) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacAssocInd, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseAuthIndRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
7
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseAuthIndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseAuthIndRequest>
for &WlanFullmacImplIfcBaseAuthIndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseAuthIndRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseAuthIndRequest>::encode(
(<WlanFullmacAuthInd as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacAuthInd>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseAuthIndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseAuthIndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseAuthIndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacAuthInd) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacAuthInd, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseConnectConfRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseConnectConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseConnectConfRequest>
for &WlanFullmacImplIfcBaseConnectConfRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseConnectConfRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseConnectConfRequest>::encode(
(<WlanFullmacConnectConfirm as fidl::encoding::ValueTypeMarker>::borrow(
&self.resp,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacConnectConfirm>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseConnectConfRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseConnectConfRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseConnectConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacConnectConfirm) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacConnectConfirm, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseDeauthIndRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
10
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseDeauthIndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseDeauthIndRequest>
for &WlanFullmacImplIfcBaseDeauthIndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDeauthIndRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseDeauthIndRequest>::encode(
(<WlanFullmacDeauthIndication as fidl::encoding::ValueTypeMarker>::borrow(
&self.ind,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacDeauthIndication>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseDeauthIndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDeauthIndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseDeauthIndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { ind: fidl::new_empty!(WlanFullmacDeauthIndication) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacDeauthIndication, &mut self.ind, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseDisassocConfRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseDisassocConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseDisassocConfRequest>
for &WlanFullmacImplIfcBaseDisassocConfRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDisassocConfRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacImplIfcBaseDisassocConfRequest).write_unaligned(
(self as *const WlanFullmacImplIfcBaseDisassocConfRequest).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacDisassocConfirm>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseDisassocConfRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDisassocConfRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseDisassocConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacDisassocConfirm) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseDisassocIndRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
10
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseDisassocIndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseDisassocIndRequest>
for &WlanFullmacImplIfcBaseDisassocIndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDisassocIndRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseDisassocIndRequest>::encode(
(<WlanFullmacDisassocIndication as fidl::encoding::ValueTypeMarker>::borrow(
&self.ind,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacDisassocIndication>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseDisassocIndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDisassocIndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseDisassocIndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { ind: fidl::new_empty!(WlanFullmacDisassocIndication) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
WlanFullmacDisassocIndication,
&mut self.ind,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseEapolConfRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
7
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseEapolConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseEapolConfRequest>
for &WlanFullmacImplIfcBaseEapolConfRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseEapolConfRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseEapolConfRequest>::encode(
(<WlanFullmacEapolConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacEapolConfirm>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseEapolConfRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseEapolConfRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseEapolConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacEapolConfirm) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacEapolConfirm, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseEapolIndRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseEapolIndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseEapolIndRequest>
for &WlanFullmacImplIfcBaseEapolIndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseEapolIndRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseEapolIndRequest>::encode(
(<WlanFullmacEapolIndication as fidl::encoding::ValueTypeMarker>::borrow(
&self.ind,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacEapolIndication>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseEapolIndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseEapolIndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseEapolIndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { ind: fidl::new_empty!(WlanFullmacEapolIndication) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacEapolIndication, &mut self.ind, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseOnChannelSwitchRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseOnChannelSwitchRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseOnChannelSwitchRequest>
for &WlanFullmacImplIfcBaseOnChannelSwitchRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnChannelSwitchRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacImplIfcBaseOnChannelSwitchRequest).write_unaligned(
(self as *const WlanFullmacImplIfcBaseOnChannelSwitchRequest).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacChannelSwitchInfo>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseOnChannelSwitchRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnChannelSwitchRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseOnChannelSwitchRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { ind: fidl::new_empty!(WlanFullmacChannelSwitchInfo) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseOnPmkAvailableRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseOnPmkAvailableRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseOnPmkAvailableRequest>
for &WlanFullmacImplIfcBaseOnPmkAvailableRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnPmkAvailableRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseOnPmkAvailableRequest>::encode(
(<WlanFullmacPmkInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacPmkInfo>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseOnPmkAvailableRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnPmkAvailableRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseOnPmkAvailableRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { info: fidl::new_empty!(WlanFullmacPmkInfo) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacPmkInfo, &mut self.info, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseOnScanEndRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseOnScanEndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseOnScanEndRequest>
for &WlanFullmacImplIfcBaseOnScanEndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnScanEndRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseOnScanEndRequest>::encode(
(<WlanFullmacScanEnd as fidl::encoding::ValueTypeMarker>::borrow(&self.end),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacScanEnd>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseOnScanEndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnScanEndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseOnScanEndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { end: fidl::new_empty!(WlanFullmacScanEnd) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacScanEnd, &mut self.end, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseOnScanResultRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
64
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseOnScanResultRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseOnScanResultRequest>
for &WlanFullmacImplIfcBaseOnScanResultRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnScanResultRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseOnScanResultRequest>::encode(
(<WlanFullmacScanResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacScanResult>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseOnScanResultRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnScanResultRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseOnScanResultRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { result: fidl::new_empty!(WlanFullmacScanResult) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacScanResult, &mut self.result, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseOnWmmStatusRespRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
40
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseOnWmmStatusRespRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseOnWmmStatusRespRequest>
for &WlanFullmacImplIfcBaseOnWmmStatusRespRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest>::encode(
(
<i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
<fidl_fuchsia_wlan_common::WlanWmmParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_params),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<i32>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common::WlanWmmParameters>,
> fidl::encoding::Encode<WlanFullmacImplIfcBaseOnWmmStatusRespRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseOnWmmStatusRespRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(36);
(ptr as *mut u32).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 4, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseOnWmmStatusRespRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
status: fidl::new_empty!(i32),
wmm_params: fidl::new_empty!(fidl_fuchsia_wlan_common::WlanWmmParameters),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(36) };
let padval = unsafe { (ptr as *const u32).read_unaligned() };
let mask = 0xffff0000u32;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(i32, &mut self.status, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_common::WlanWmmParameters,
&mut self.wmm_params,
decoder,
offset + 4,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseRoamConfRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseRoamConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseRoamConfRequest>
for &WlanFullmacImplIfcBaseRoamConfRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseRoamConfRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseRoamConfRequest>::encode(
(<WlanFullmacRoamConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacRoamConfirm>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseRoamConfRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseRoamConfRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseRoamConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacRoamConfirm) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacRoamConfirm, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseSaeFrameRxRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseSaeFrameRxRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseSaeFrameRxRequest>
for &WlanFullmacImplIfcBaseSaeFrameRxRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseSaeFrameRxRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseSaeFrameRxRequest>::encode(
(<WlanFullmacSaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSaeFrame>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseSaeFrameRxRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseSaeFrameRxRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseSaeFrameRxRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { frame: fidl::new_empty!(WlanFullmacSaeFrame) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacSaeFrame, &mut self.frame, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseSaeHandshakeIndRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
6
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseSaeHandshakeIndRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseSaeHandshakeIndRequest>
for &WlanFullmacImplIfcBaseSaeHandshakeIndRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseSaeHandshakeIndRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacImplIfcBaseSaeHandshakeIndRequest).write_unaligned(
(self as *const WlanFullmacImplIfcBaseSaeHandshakeIndRequest).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSaeHandshakeInd>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseSaeHandshakeIndRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseSaeHandshakeIndRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseSaeHandshakeIndRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { ind: fidl::new_empty!(WlanFullmacSaeHandshakeInd) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseSignalReportRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseSignalReportRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseSignalReportRequest>
for &WlanFullmacImplIfcBaseSignalReportRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseSignalReportRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacImplIfcBaseSignalReportRequest).write_unaligned(
(self as *const WlanFullmacImplIfcBaseSignalReportRequest).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacSignalReportIndication>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseSignalReportRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseSignalReportRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseSignalReportRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { ind: fidl::new_empty!(WlanFullmacSignalReportIndication) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseStartConfRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseStartConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseStartConfRequest>
for &WlanFullmacImplIfcBaseStartConfRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseStartConfRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseStartConfRequest>::encode(
(<WlanFullmacStartConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacStartConfirm>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseStartConfRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseStartConfRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseStartConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacStartConfirm) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacStartConfirm, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseStopConfRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseStopConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseStopConfRequest>
for &WlanFullmacImplIfcBaseStopConfRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseStopConfRequest>(offset);
fidl::encoding::Encode::<WlanFullmacImplIfcBaseStopConfRequest>::encode(
(<WlanFullmacStopConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanFullmacStopConfirm>>
fidl::encoding::Encode<WlanFullmacImplIfcBaseStopConfRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseStopConfRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseStopConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { resp: fidl::new_empty!(WlanFullmacStopConfirm) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanFullmacStopConfirm, &mut self.resp, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacNoiseFloorHistogram {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacNoiseFloorHistogram {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacNoiseFloorHistogram>
for &WlanFullmacNoiseFloorHistogram
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacNoiseFloorHistogram>(offset);
fidl::encoding::Encode::<WlanFullmacNoiseFloorHistogram>::encode(
(
<WlanFullmacHistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
<WlanFullmacAntennaId as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
<fidl::encoding::Vector<WlanFullmacHistBucket, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.noise_floor_samples),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<WlanFullmacHistScope>,
T1: fidl::encoding::Encode<WlanFullmacAntennaId>,
T2: fidl::encoding::Encode<fidl::encoding::Vector<WlanFullmacHistBucket, 255>>,
T3: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<WlanFullmacNoiseFloorHistogram> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacNoiseFloorHistogram>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacNoiseFloorHistogram {
#[inline(always)]
fn new_empty() -> Self {
Self {
hist_scope: fidl::new_empty!(WlanFullmacHistScope),
antenna_id: fidl::new_empty!(WlanFullmacAntennaId),
noise_floor_samples: fidl::new_empty!(fidl::encoding::Vector<WlanFullmacHistBucket, 255>),
invalid_samples: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffff000000u64;
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!(WlanFullmacHistScope, &mut self.hist_scope, decoder, offset + 0, _depth)?;
fidl::decode!(WlanFullmacAntennaId, &mut self.antenna_id, decoder, offset + 1, _depth)?;
fidl::decode!(fidl::encoding::Vector<WlanFullmacHistBucket, 255>, &mut self.noise_floor_samples, decoder, offset + 8, _depth)?;
fidl::decode!(u64, &mut self.invalid_samples, decoder, offset + 24, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacPmkInfo {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacPmkInfo {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacPmkInfo> for &WlanFullmacPmkInfo {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacPmkInfo>(offset);
fidl::encoding::Encode::<WlanFullmacPmkInfo>::encode(
(
<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.pmk),
<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.pmkid),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>>,
T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>>,
> fidl::encoding::Encode<WlanFullmacPmkInfo> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacPmkInfo>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacPmkInfo {
#[inline(always)]
fn new_empty() -> Self {
Self {
pmk: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>),
pmkid: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
&mut self.pmk,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
&mut self.pmkid,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacQueryInfo {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
5008
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacQueryInfo {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacQueryInfo> for &WlanFullmacQueryInfo {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacQueryInfo>(offset);
fidl::encoding::Encode::<WlanFullmacQueryInfo>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.sta_addr),
<fidl_fuchsia_wlan_common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow(&self.role),
<fidl::encoding::Array<WlanFullmacBandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.band_cap_list),
<u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.band_cap_count),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common::WlanMacRole>,
T2: fidl::encoding::Encode<fidl::encoding::Array<WlanFullmacBandCapability, 16>>,
T3: fidl::encoding::Encode<u8>,
> fidl::encoding::Encode<WlanFullmacQueryInfo> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacQueryInfo>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
(ptr as *mut u32).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(5004);
(ptr as *mut u32).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
self.2.encode(encoder, offset + 12, depth)?;
self.3.encode(encoder, offset + 5004, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacQueryInfo {
#[inline(always)]
fn new_empty() -> Self {
Self {
sta_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
role: fidl::new_empty!(fidl_fuchsia_wlan_common::WlanMacRole),
band_cap_list: fidl::new_empty!(fidl::encoding::Array<WlanFullmacBandCapability, 16>),
band_cap_count: fidl::new_empty!(u8),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(4) };
let padval = unsafe { (ptr as *const u32).read_unaligned() };
let mask = 0xffff0000u32;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(5004) };
let padval = unsafe { (ptr as *const u32).read_unaligned() };
let mask = 0xffffff00u32;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 5004 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.sta_addr, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_common::WlanMacRole,
&mut self.role,
decoder,
offset + 8,
_depth
)?;
fidl::decode!(fidl::encoding::Array<WlanFullmacBandCapability, 16>, &mut self.band_cap_list, decoder, offset + 12, _depth)?;
fidl::decode!(u8, &mut self.band_cap_count, decoder, offset + 5004, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacRoamConfirm {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacRoamConfirm {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacRoamConfirm> for &WlanFullmacRoamConfirm {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRoamConfirm>(offset);
fidl::encoding::Encode::<WlanFullmacRoamConfirm>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.target_bssid),
<fidl_fuchsia_wlan_ieee80211::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
<fidl_fuchsia_wlan_internal::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::StatusCode>,
T2: fidl::encoding::Encode<fidl_fuchsia_wlan_internal::BssDescription>,
> fidl::encoding::Encode<WlanFullmacRoamConfirm> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRoamConfirm>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacRoamConfirm {
#[inline(always)]
fn new_empty() -> Self {
Self {
target_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
result_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::StatusCode),
selected_bss: fidl::new_empty!(fidl_fuchsia_wlan_internal::BssDescription),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.target_bssid, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::StatusCode,
&mut self.result_code,
decoder,
offset + 6,
_depth
)?;
fidl::decode!(
fidl_fuchsia_wlan_internal::BssDescription,
&mut self.selected_bss,
decoder,
offset + 8,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacRssiHistogram {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacRssiHistogram {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacRssiHistogram> for &WlanFullmacRssiHistogram {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRssiHistogram>(offset);
fidl::encoding::Encode::<WlanFullmacRssiHistogram>::encode(
(
<WlanFullmacHistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
<WlanFullmacAntennaId as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
<fidl::encoding::Vector<WlanFullmacHistBucket, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi_samples),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<WlanFullmacHistScope>,
T1: fidl::encoding::Encode<WlanFullmacAntennaId>,
T2: fidl::encoding::Encode<fidl::encoding::Vector<WlanFullmacHistBucket, 255>>,
T3: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<WlanFullmacRssiHistogram> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRssiHistogram>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacRssiHistogram {
#[inline(always)]
fn new_empty() -> Self {
Self {
hist_scope: fidl::new_empty!(WlanFullmacHistScope),
antenna_id: fidl::new_empty!(WlanFullmacAntennaId),
rssi_samples: fidl::new_empty!(fidl::encoding::Vector<WlanFullmacHistBucket, 255>),
invalid_samples: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffff000000u64;
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!(WlanFullmacHistScope, &mut self.hist_scope, decoder, offset + 0, _depth)?;
fidl::decode!(WlanFullmacAntennaId, &mut self.antenna_id, decoder, offset + 1, _depth)?;
fidl::decode!(fidl::encoding::Vector<WlanFullmacHistBucket, 255>, &mut self.rssi_samples, decoder, offset + 8, _depth)?;
fidl::decode!(u64, &mut self.invalid_samples, decoder, offset + 24, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacRssiStats {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacRssiStats {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacRssiStats> for &WlanFullmacRssiStats {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
fidl::encoding::Encode::<WlanFullmacRssiStats>::encode(
(
<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.hist),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>>>
fidl::encoding::Encode<WlanFullmacRssiStats> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacRssiStats {
#[inline(always)]
fn new_empty() -> Self {
Self { hist: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::UnboundedVector<u64>,
&mut self.hist,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacRxRateIndexHistogram {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacRxRateIndexHistogram {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacRxRateIndexHistogram>
for &WlanFullmacRxRateIndexHistogram
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRxRateIndexHistogram>(offset);
fidl::encoding::Encode::<WlanFullmacRxRateIndexHistogram>::encode(
(
<WlanFullmacHistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
<WlanFullmacAntennaId as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
<fidl::encoding::Vector<WlanFullmacHistBucket, 196> as fidl::encoding::ValueTypeMarker>::borrow(&self.rx_rate_index_samples),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<WlanFullmacHistScope>,
T1: fidl::encoding::Encode<WlanFullmacAntennaId>,
T2: fidl::encoding::Encode<fidl::encoding::Vector<WlanFullmacHistBucket, 196>>,
T3: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<WlanFullmacRxRateIndexHistogram> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacRxRateIndexHistogram>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacRxRateIndexHistogram {
#[inline(always)]
fn new_empty() -> Self {
Self {
hist_scope: fidl::new_empty!(WlanFullmacHistScope),
antenna_id: fidl::new_empty!(WlanFullmacAntennaId),
rx_rate_index_samples: fidl::new_empty!(fidl::encoding::Vector<WlanFullmacHistBucket, 196>),
invalid_samples: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffff000000u64;
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!(WlanFullmacHistScope, &mut self.hist_scope, decoder, offset + 0, _depth)?;
fidl::decode!(WlanFullmacAntennaId, &mut self.antenna_id, decoder, offset + 1, _depth)?;
fidl::decode!(fidl::encoding::Vector<WlanFullmacHistBucket, 196>, &mut self.rx_rate_index_samples, decoder, offset + 8, _depth)?;
fidl::decode!(u64, &mut self.invalid_samples, decoder, offset + 24, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSaeFrame {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSaeFrame {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSaeFrame> for &WlanFullmacSaeFrame {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSaeFrame>(offset);
fidl::encoding::Encode::<WlanFullmacSaeFrame>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
<fidl_fuchsia_wlan_ieee80211::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
<u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.seq_num),
<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.sae_fields),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::StatusCode>,
T2: fidl::encoding::Encode<u16>,
T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>>,
> fidl::encoding::Encode<WlanFullmacSaeFrame> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSaeFrame>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSaeFrame {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::StatusCode),
seq_num: fidl::new_empty!(u16),
sae_fields: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffffff0000u64;
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::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::StatusCode,
&mut self.status_code,
decoder,
offset + 6,
_depth
)?;
fidl::decode!(u16, &mut self.seq_num, decoder, offset + 8, _depth)?;
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
&mut self.sae_fields,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSaeHandshakeInd {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
6
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSaeHandshakeInd {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSaeHandshakeInd> for &WlanFullmacSaeHandshakeInd {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSaeHandshakeInd>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacSaeHandshakeInd)
.write_unaligned((self as *const WlanFullmacSaeHandshakeInd).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>>
fidl::encoding::Encode<WlanFullmacSaeHandshakeInd> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSaeHandshakeInd>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSaeHandshakeInd {
#[inline(always)]
fn new_empty() -> Self {
Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSaeHandshakeResp {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSaeHandshakeResp {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSaeHandshakeResp> for &WlanFullmacSaeHandshakeResp {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSaeHandshakeResp>(offset);
fidl::encoding::Encode::<WlanFullmacSaeHandshakeResp>::encode(
(
<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
<fidl_fuchsia_wlan_ieee80211::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>>,
T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211::StatusCode>,
> fidl::encoding::Encode<WlanFullmacSaeHandshakeResp> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSaeHandshakeResp>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 6, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSaeHandshakeResp {
#[inline(always)]
fn new_empty() -> Self {
Self {
peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>),
status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::StatusCode),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Array<u8, 6>, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::StatusCode,
&mut self.status_code,
decoder,
offset + 6,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacScanEnd {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacScanEnd {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacScanEnd> for &WlanFullmacScanEnd {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacScanEnd>(offset);
fidl::encoding::Encode::<WlanFullmacScanEnd>::encode(
(
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
<WlanScanResult as fidl::encoding::ValueTypeMarker>::borrow(&self.code),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<u64>, T1: fidl::encoding::Encode<WlanScanResult>>
fidl::encoding::Encode<WlanFullmacScanEnd> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacScanEnd>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacScanEnd {
#[inline(always)]
fn new_empty() -> Self {
Self { txn_id: fidl::new_empty!(u64), code: fidl::new_empty!(WlanScanResult) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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!(u64, &mut self.txn_id, decoder, offset + 0, _depth)?;
fidl::decode!(WlanScanResult, &mut self.code, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacScanResult {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
64
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacScanResult {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacScanResult> for &WlanFullmacScanResult {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacScanResult>(offset);
fidl::encoding::Encode::<WlanFullmacScanResult>::encode(
(
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
<i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp_nanos),
<fidl_fuchsia_wlan_internal::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.bss),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<u64>,
T1: fidl::encoding::Encode<i64>,
T2: fidl::encoding::Encode<fidl_fuchsia_wlan_internal::BssDescription>,
> fidl::encoding::Encode<WlanFullmacScanResult> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacScanResult>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
self.2.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacScanResult {
#[inline(always)]
fn new_empty() -> Self {
Self {
txn_id: fidl::new_empty!(u64),
timestamp_nanos: fidl::new_empty!(i64),
bss: fidl::new_empty!(fidl_fuchsia_wlan_internal::BssDescription),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(u64, &mut self.txn_id, decoder, offset + 0, _depth)?;
fidl::decode!(i64, &mut self.timestamp_nanos, decoder, offset + 8, _depth)?;
fidl::decode!(
fidl_fuchsia_wlan_internal::BssDescription,
&mut self.bss,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSetKeysReq {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
72
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSetKeysReq {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSetKeysReq> for &WlanFullmacSetKeysReq {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSetKeysReq>(offset);
fidl::encoding::Encode::<WlanFullmacSetKeysReq>::encode(
(
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_keys),
<fidl::encoding::Array<fidl_fuchsia_wlan_common::WlanKeyConfig, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.keylist),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<u64>,
T1: fidl::encoding::Encode<
fidl::encoding::Array<fidl_fuchsia_wlan_common::WlanKeyConfig, 4>,
>,
> fidl::encoding::Encode<WlanFullmacSetKeysReq> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSetKeysReq>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSetKeysReq {
#[inline(always)]
fn new_empty() -> Self {
Self {
num_keys: fidl::new_empty!(u64),
keylist: fidl::new_empty!(fidl::encoding::Array<fidl_fuchsia_wlan_common::WlanKeyConfig, 4>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(u64, &mut self.num_keys, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Array<fidl_fuchsia_wlan_common::WlanKeyConfig, 4>, &mut self.keylist, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSetKeysResp {
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
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSetKeysResp {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSetKeysResp> for &WlanFullmacSetKeysResp {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacSetKeysResp)
.write_unaligned((self as *const WlanFullmacSetKeysResp).read());
}
Ok(())
}
}
unsafe impl<
T0: fidl::encoding::Encode<u64>,
T1: fidl::encoding::Encode<fidl::encoding::Array<i32, 4>>,
> fidl::encoding::Encode<WlanFullmacSetKeysResp> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSetKeysResp {
#[inline(always)]
fn new_empty() -> Self {
Self {
num_keys: fidl::new_empty!(u64),
statuslist: fidl::new_empty!(fidl::encoding::Array<i32, 4>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSignalReportIndication {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSignalReportIndication {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSignalReportIndication>
for &WlanFullmacSignalReportIndication
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut WlanFullmacSignalReportIndication)
.write_unaligned((self as *const WlanFullmacSignalReportIndication).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i8>, T1: fidl::encoding::Encode<i8>>
fidl::encoding::Encode<WlanFullmacSignalReportIndication> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSignalReportIndication {
#[inline(always)]
fn new_empty() -> Self {
Self { rssi_dbm: fidl::new_empty!(i8), snr_db: fidl::new_empty!(i8) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacSnrHistogram {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacSnrHistogram {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacSnrHistogram> for &WlanFullmacSnrHistogram {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSnrHistogram>(offset);
fidl::encoding::Encode::<WlanFullmacSnrHistogram>::encode(
(
<WlanFullmacHistScope as fidl::encoding::ValueTypeMarker>::borrow(&self.hist_scope),
<WlanFullmacAntennaId as fidl::encoding::ValueTypeMarker>::borrow(&self.antenna_id),
<fidl::encoding::Vector<WlanFullmacHistBucket, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.snr_samples),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.invalid_samples),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<WlanFullmacHistScope>,
T1: fidl::encoding::Encode<WlanFullmacAntennaId>,
T2: fidl::encoding::Encode<fidl::encoding::Vector<WlanFullmacHistBucket, 256>>,
T3: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<WlanFullmacSnrHistogram> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacSnrHistogram>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 1, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacSnrHistogram {
#[inline(always)]
fn new_empty() -> Self {
Self {
hist_scope: fidl::new_empty!(WlanFullmacHistScope),
antenna_id: fidl::new_empty!(WlanFullmacAntennaId),
snr_samples: fidl::new_empty!(fidl::encoding::Vector<WlanFullmacHistBucket, 256>),
invalid_samples: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffffffffff000000u64;
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!(WlanFullmacHistScope, &mut self.hist_scope, decoder, offset + 0, _depth)?;
fidl::decode!(WlanFullmacAntennaId, &mut self.antenna_id, decoder, offset + 1, _depth)?;
fidl::decode!(fidl::encoding::Vector<WlanFullmacHistBucket, 256>, &mut self.snr_samples, decoder, offset + 8, _depth)?;
fidl::decode!(u64, &mut self.invalid_samples, decoder, offset + 24, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacStartConfirm {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacStartConfirm {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacStartConfirm> for &WlanFullmacStartConfirm {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacStartConfirm>(offset);
fidl::encoding::Encode::<WlanFullmacStartConfirm>::encode(
(<WlanStartResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanStartResult>>
fidl::encoding::Encode<WlanFullmacStartConfirm> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacStartConfirm>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacStartConfirm {
#[inline(always)]
fn new_empty() -> Self {
Self { result_code: fidl::new_empty!(WlanStartResult) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanStartResult, &mut self.result_code, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacStopConfirm {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacStopConfirm {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacStopConfirm> for &WlanFullmacStopConfirm {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacStopConfirm>(offset);
fidl::encoding::Encode::<WlanFullmacStopConfirm>::encode(
(<WlanStopResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<WlanStopResult>>
fidl::encoding::Encode<WlanFullmacStopConfirm> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacStopConfirm>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacStopConfirm {
#[inline(always)]
fn new_empty() -> Self {
Self { result_code: fidl::new_empty!(WlanStopResult) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(WlanStopResult, &mut self.result_code, decoder, offset + 0, _depth)?;
Ok(())
}
}
impl WlanFullmacIfaceHistogramStats {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.snr_histograms {
return 4;
}
if let Some(_) = self.rx_rate_index_histograms {
return 3;
}
if let Some(_) = self.rssi_histograms {
return 2;
}
if let Some(_) = self.noise_floor_histograms {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacIfaceHistogramStats {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacIfaceHistogramStats {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacIfaceHistogramStats>
for &WlanFullmacIfaceHistogramStats
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacIfaceHistogramStats>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<WlanFullmacNoiseFloorHistogram, 8>>(
self.noise_floor_histograms.as_ref().map(<fidl::encoding::Vector<WlanFullmacNoiseFloorHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<WlanFullmacRssiHistogram, 8>>(
self.rssi_histograms.as_ref().map(<fidl::encoding::Vector<WlanFullmacRssiHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<WlanFullmacRxRateIndexHistogram, 8>>(
self.rx_rate_index_histograms.as_ref().map(<fidl::encoding::Vector<WlanFullmacRxRateIndexHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<WlanFullmacSnrHistogram, 8>>(
self.snr_histograms.as_ref().map(<fidl::encoding::Vector<WlanFullmacSnrHistogram, 8> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacIfaceHistogramStats {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<WlanFullmacNoiseFloorHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.noise_floor_histograms.get_or_insert_with(
|| fidl::new_empty!(fidl::encoding::Vector<WlanFullmacNoiseFloorHistogram, 8>),
);
fidl::decode!(fidl::encoding::Vector<WlanFullmacNoiseFloorHistogram, 8>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<WlanFullmacRssiHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.rssi_histograms.get_or_insert_with(
|| fidl::new_empty!(fidl::encoding::Vector<WlanFullmacRssiHistogram, 8>),
);
fidl::decode!(fidl::encoding::Vector<WlanFullmacRssiHistogram, 8>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<WlanFullmacRxRateIndexHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.rx_rate_index_histograms.get_or_insert_with(
|| fidl::new_empty!(fidl::encoding::Vector<WlanFullmacRxRateIndexHistogram, 8>),
);
fidl::decode!(fidl::encoding::Vector<WlanFullmacRxRateIndexHistogram, 8>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<WlanFullmacSnrHistogram, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.snr_histograms.get_or_insert_with(
|| fidl::new_empty!(fidl::encoding::Vector<WlanFullmacSnrHistogram, 8>),
);
fidl::decode!(fidl::encoding::Vector<WlanFullmacSnrHistogram, 8>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseAssocRespRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.association_id {
return 3;
}
if let Some(_) = self.result_code {
return 2;
}
if let Some(_) = self.peer_sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseAssocRespRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseAssocRespRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseAssocRespRequest>
for &WlanFullmacImplBaseAssocRespRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseAssocRespRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.peer_sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<WlanAssocResult>(
self.result_code
.as_ref()
.map(<WlanAssocResult as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u16>(
self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseAssocRespRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.peer_sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<WlanAssocResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAssocResult));
fidl::decode!(WlanAssocResult, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16));
fidl::decode!(u16, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseAuthRespRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.result_code {
return 2;
}
if let Some(_) = self.peer_sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseAuthRespRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseAuthRespRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseAuthRespRequest>
for &WlanFullmacImplBaseAuthRespRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseAuthRespRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.peer_sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<WlanAuthResult>(
self.result_code
.as_ref()
.map(<WlanAuthResult as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseAuthRespRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.peer_sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<WlanAuthResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAuthResult));
fidl::decode!(WlanAuthResult, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseConnectRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.security_ie {
return 6;
}
if let Some(_) = self.wep_key {
return 5;
}
if let Some(_) = self.sae_password {
return 4;
}
if let Some(_) = self.auth_type {
return 3;
}
if let Some(_) = self.connect_failure_timeout {
return 2;
}
if let Some(_) = self.selected_bss {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseConnectRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseConnectRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseConnectRequest>
for &WlanFullmacImplBaseConnectRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseConnectRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_internal::BssDescription>(
self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_internal::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.connect_failure_timeout
.as_ref()
.map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<WlanAuthType>(
self.auth_type
.as_ref()
.map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>>(
self.sae_password.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common::WlanKeyConfig>(
self.wep_key.as_ref().map(<fidl_fuchsia_wlan_common::WlanKeyConfig as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 6 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (6 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>>(
self.security_ie.as_ref().map(
<fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseConnectRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl_fuchsia_wlan_internal::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.selected_bss.get_or_insert_with(|| {
fidl::new_empty!(fidl_fuchsia_wlan_internal::BssDescription)
});
fidl::decode!(
fidl_fuchsia_wlan_internal::BssDescription,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.connect_failure_timeout.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType));
fidl::decode!(WlanAuthType, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.sae_password
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedVector<u8>));
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl_fuchsia_wlan_common::WlanKeyConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.wep_key.get_or_insert_with(|| {
fidl::new_empty!(fidl_fuchsia_wlan_common::WlanKeyConfig)
});
fidl::decode!(
fidl_fuchsia_wlan_common::WlanKeyConfig,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 6 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.security_ie
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>));
fidl::decode!(fidl::encoding::Vector<u8, 257>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseDeauthRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.reason_code {
return 2;
}
if let Some(_) = self.peer_sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseDeauthRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseDeauthRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseDeauthRequest>
for &WlanFullmacImplBaseDeauthRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseDeauthRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.peer_sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211::ReasonCode>(
self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseDeauthRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.peer_sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl_fuchsia_wlan_ieee80211::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.reason_code.get_or_insert_with(|| {
fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::ReasonCode)
});
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::ReasonCode,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseDisassocRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.reason_code {
return 2;
}
if let Some(_) = self.peer_sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseDisassocRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseDisassocRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseDisassocRequest>
for &WlanFullmacImplBaseDisassocRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseDisassocRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.peer_sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211::ReasonCode>(
self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseDisassocRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.peer_sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl_fuchsia_wlan_ieee80211::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.reason_code.get_or_insert_with(|| {
fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::ReasonCode)
});
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::ReasonCode,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseEapolTxRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.data {
return 3;
}
if let Some(_) = self.dst_addr {
return 2;
}
if let Some(_) = self.src_addr {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseEapolTxRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseEapolTxRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseEapolTxRequest>
for &WlanFullmacImplBaseEapolTxRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseEapolTxRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.src_addr
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.dst_addr
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>>(
self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseEapolTxRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.src_addr
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.dst_addr
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.data
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedVector<u8>));
fidl::decode!(
fidl::encoding::UnboundedVector<u8>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseReconnectRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.peer_sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseReconnectRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseReconnectRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseReconnectRequest>
for &WlanFullmacImplBaseReconnectRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseReconnectRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.peer_sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseReconnectRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.peer_sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseResetRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.set_default_mib {
return 2;
}
if let Some(_) = self.sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseResetRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseResetRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseResetRequest>
for &WlanFullmacImplBaseResetRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseResetRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<bool>(
self.set_default_mib
.as_ref()
.map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseResetRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.set_default_mib.get_or_insert_with(|| fidl::new_empty!(bool));
fidl::decode!(bool, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseStartBssRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.vendor_ie {
return 7;
}
if let Some(_) = self.rsne {
return 6;
}
if let Some(_) = self.channel {
return 5;
}
if let Some(_) = self.dtim_period {
return 4;
}
if let Some(_) = self.beacon_period {
return 3;
}
if let Some(_) = self.bss_type {
return 2;
}
if let Some(_) = self.ssid {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseStartBssRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseStartBssRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseStartBssRequest>
for &WlanFullmacImplBaseStartBssRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseStartBssRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211::CSsid>(
self.ssid.as_ref().map(
<fidl_fuchsia_wlan_ieee80211::CSsid as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common::BssType>(
self.bss_type.as_ref().map(
<fidl_fuchsia_wlan_common::BssType as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.beacon_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.dtim_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u8>(
self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 6 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (6 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>>(
self.rsne.as_ref().map(
<fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 7 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (7 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>>(
self.vendor_ie.as_ref().map(
<fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseStartBssRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl_fuchsia_wlan_ieee80211::CSsid as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.ssid
.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::CSsid));
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::CSsid,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl_fuchsia_wlan_common::BssType as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.bss_type
.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_wlan_common::BssType));
fidl::decode!(
fidl_fuchsia_wlan_common::BssType,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.beacon_period.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.dtim_period.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8));
fidl::decode!(u8, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 6 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.rsne
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>));
fidl::decode!(fidl::encoding::Vector<u8, 255>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 7 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.vendor_ie
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>));
fidl::decode!(fidl::encoding::Vector<u8, 514>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseStartScanRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.max_channel_time {
return 6;
}
if let Some(_) = self.min_channel_time {
return 5;
}
if let Some(_) = self.ssids {
return 4;
}
if let Some(_) = self.channels {
return 3;
}
if let Some(_) = self.scan_type {
return 2;
}
if let Some(_) = self.txn_id {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseStartScanRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseStartScanRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseStartScanRequest>
for &WlanFullmacImplBaseStartScanRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseStartScanRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u64>(
self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<WlanScanType>(
self.scan_type
.as_ref()
.map(<WlanScanType as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>>(
self.channels.as_ref().map(
<fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_wlan_ieee80211::CSsid>>(
self.ssids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_wlan_ieee80211::CSsid> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.min_channel_time
.as_ref()
.map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 6 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (6 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.max_channel_time
.as_ref()
.map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseStartScanRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64));
fidl::decode!(u64, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<WlanScanType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.scan_type.get_or_insert_with(|| fidl::new_empty!(WlanScanType));
fidl::decode!(WlanScanType, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.channels
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>));
fidl::decode!(fidl::encoding::Vector<u8, 256>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
fidl_fuchsia_wlan_ieee80211::CSsid,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.ssids.get_or_insert_with(|| {
fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl_fuchsia_wlan_ieee80211::CSsid>
)
});
fidl::decode!(
fidl::encoding::UnboundedVector<fidl_fuchsia_wlan_ieee80211::CSsid>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.min_channel_time.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 6 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.max_channel_time.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplBaseStopBssRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.ssid {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplBaseStopBssRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplBaseStopBssRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplBaseStopBssRequest>
for &WlanFullmacImplBaseStopBssRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplBaseStopBssRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211::CSsid>(
self.ssid.as_ref().map(
<fidl_fuchsia_wlan_ieee80211::CSsid as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplBaseStopBssRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl_fuchsia_wlan_ieee80211::CSsid as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.ssid
.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_wlan_ieee80211::CSsid));
fidl::decode!(
fidl_fuchsia_wlan_ieee80211::CSsid,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl WlanFullmacImplIfcBaseDeauthConfRequest {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.peer_sta_address {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcBaseDeauthConfRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcBaseDeauthConfRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<WlanFullmacImplIfcBaseDeauthConfRequest>
for &WlanFullmacImplIfcBaseDeauthConfRequest
{
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<WlanFullmacImplIfcBaseDeauthConfRequest>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>>(
self.peer_sta_address
.as_ref()
.map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for WlanFullmacImplIfcBaseDeauthConfRequest {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.peer_sta_address
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>));
fidl::decode!(fidl::encoding::Array<u8, 6>, val_ref, decoder, inner_offset, inner_depth)?;
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);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
}