1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_wlan_fullmac_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct WlanFullmacImplInitRequest {
16 pub ifc: Option<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>>,
19 #[doc(hidden)]
20 pub __source_breaking: fidl::marker::SourceBreaking,
21}
22
23impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
24 for WlanFullmacImplInitRequest
25{
26}
27
28#[derive(Debug, Default, PartialEq)]
29pub struct WlanFullmacImplInitResponse {
30 pub sme_channel: Option<fidl::Channel>,
33 #[doc(hidden)]
34 pub __source_breaking: fidl::marker::SourceBreaking,
35}
36
37impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
38 for WlanFullmacImplInitResponse
39{
40}
41
42#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
43pub struct WlanFullmacImpl_Marker;
44
45impl fidl::endpoints::ProtocolMarker for WlanFullmacImpl_Marker {
46 type Proxy = WlanFullmacImpl_Proxy;
47 type RequestStream = WlanFullmacImpl_RequestStream;
48 #[cfg(target_os = "fuchsia")]
49 type SynchronousProxy = WlanFullmacImpl_SynchronousProxy;
50
51 const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImpl";
52}
53impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImpl_Marker {}
54pub type WlanFullmacImplInitResult = Result<WlanFullmacImplInitResponse, i32>;
55pub type WlanFullmacImplQueryResult = Result<WlanFullmacImplQueryResponse, i32>;
56pub type WlanFullmacImplQueryMacSublayerSupportResult =
57 Result<fidl_fuchsia_wlan_common::MacSublayerSupport, i32>;
58pub type WlanFullmacImplQuerySecuritySupportResult =
59 Result<fidl_fuchsia_wlan_common::SecuritySupport, i32>;
60pub type WlanFullmacImplQuerySpectrumManagementSupportResult =
61 Result<fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>;
62pub type WlanFullmacImplQueryTelemetrySupportResult =
63 Result<fidl_fuchsia_wlan_stats::TelemetrySupport, i32>;
64pub type WlanFullmacImplGetIfaceCounterStatsResult =
65 Result<fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>;
66pub type WlanFullmacImplGetIfaceHistogramStatsResult =
67 Result<fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>;
68
69pub trait WlanFullmacImpl_ProxyInterface: Send + Sync {
70 type InitResponseFut: std::future::Future<Output = Result<WlanFullmacImplInitResult, fidl::Error>>
71 + Send;
72 fn r#init(&self, payload: WlanFullmacImplInitRequest) -> Self::InitResponseFut;
73 type QueryResponseFut: std::future::Future<Output = Result<WlanFullmacImplQueryResult, fidl::Error>>
74 + Send;
75 fn r#query(&self) -> Self::QueryResponseFut;
76 type QueryMacSublayerSupportResponseFut: std::future::Future<
77 Output = Result<WlanFullmacImplQueryMacSublayerSupportResult, fidl::Error>,
78 > + Send;
79 fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut;
80 type QuerySecuritySupportResponseFut: std::future::Future<Output = Result<WlanFullmacImplQuerySecuritySupportResult, fidl::Error>>
81 + Send;
82 fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut;
83 type QuerySpectrumManagementSupportResponseFut: std::future::Future<
84 Output = Result<WlanFullmacImplQuerySpectrumManagementSupportResult, fidl::Error>,
85 > + Send;
86 fn r#query_spectrum_management_support(
87 &self,
88 ) -> Self::QuerySpectrumManagementSupportResponseFut;
89 type QueryTelemetrySupportResponseFut: std::future::Future<
90 Output = Result<WlanFullmacImplQueryTelemetrySupportResult, fidl::Error>,
91 > + Send;
92 fn r#query_telemetry_support(&self) -> Self::QueryTelemetrySupportResponseFut;
93 type StartScanResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
94 fn r#start_scan(&self, payload: &WlanFullmacImplStartScanRequest)
95 -> Self::StartScanResponseFut;
96 type ConnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
97 fn r#connect(&self, payload: &WlanFullmacImplConnectRequest) -> Self::ConnectResponseFut;
98 type ReconnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
99 fn r#reconnect(&self, payload: &WlanFullmacImplReconnectRequest) -> Self::ReconnectResponseFut;
100 type RoamResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
101 fn r#roam(&self, payload: &WlanFullmacImplRoamRequest) -> Self::RoamResponseFut;
102 type AuthRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
103 fn r#auth_resp(&self, payload: &WlanFullmacImplAuthRespRequest) -> Self::AuthRespResponseFut;
104 type DeauthResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
105 fn r#deauth(&self, payload: &WlanFullmacImplDeauthRequest) -> Self::DeauthResponseFut;
106 type AssocRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
107 fn r#assoc_resp(&self, payload: &WlanFullmacImplAssocRespRequest)
108 -> Self::AssocRespResponseFut;
109 type DisassocResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
110 fn r#disassoc(&self, payload: &WlanFullmacImplDisassocRequest) -> Self::DisassocResponseFut;
111 type StartBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
112 fn r#start_bss(&self, payload: &WlanFullmacImplStartBssRequest) -> Self::StartBssResponseFut;
113 type StopBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
114 fn r#stop_bss(&self, payload: &WlanFullmacImplStopBssRequest) -> Self::StopBssResponseFut;
115 type SetKeysResponseFut: std::future::Future<Output = Result<WlanFullmacSetKeysResp, fidl::Error>>
116 + Send;
117 fn r#set_keys(&self, payload: &WlanFullmacImplSetKeysRequest) -> Self::SetKeysResponseFut;
118 type EapolTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
119 fn r#eapol_tx(&self, payload: &WlanFullmacImplEapolTxRequest) -> Self::EapolTxResponseFut;
120 type GetIfaceCounterStatsResponseFut: std::future::Future<Output = Result<WlanFullmacImplGetIfaceCounterStatsResult, fidl::Error>>
121 + Send;
122 fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut;
123 type GetIfaceHistogramStatsResponseFut: std::future::Future<
124 Output = Result<WlanFullmacImplGetIfaceHistogramStatsResult, fidl::Error>,
125 > + Send;
126 fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut;
127 type SaeHandshakeRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
128 fn r#sae_handshake_resp(
129 &self,
130 payload: &WlanFullmacImplSaeHandshakeRespRequest,
131 ) -> Self::SaeHandshakeRespResponseFut;
132 type SaeFrameTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
133 fn r#sae_frame_tx(&self, frame: &SaeFrame) -> Self::SaeFrameTxResponseFut;
134 type WmmStatusReqResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
135 fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut;
136 type OnLinkStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
137 fn r#on_link_state_changed(
138 &self,
139 payload: &WlanFullmacImplOnLinkStateChangedRequest,
140 ) -> Self::OnLinkStateChangedResponseFut;
141}
142#[derive(Debug)]
143#[cfg(target_os = "fuchsia")]
144pub struct WlanFullmacImpl_SynchronousProxy {
145 client: fidl::client::sync::Client,
146}
147
148#[cfg(target_os = "fuchsia")]
149impl fidl::endpoints::SynchronousProxy for WlanFullmacImpl_SynchronousProxy {
150 type Proxy = WlanFullmacImpl_Proxy;
151 type Protocol = WlanFullmacImpl_Marker;
152
153 fn from_channel(inner: fidl::Channel) -> Self {
154 Self::new(inner)
155 }
156
157 fn into_channel(self) -> fidl::Channel {
158 self.client.into_channel()
159 }
160
161 fn as_channel(&self) -> &fidl::Channel {
162 self.client.as_channel()
163 }
164}
165
166#[cfg(target_os = "fuchsia")]
167impl WlanFullmacImpl_SynchronousProxy {
168 pub fn new(channel: fidl::Channel) -> Self {
169 let protocol_name = <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
170 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
171 }
172
173 pub fn into_channel(self) -> fidl::Channel {
174 self.client.into_channel()
175 }
176
177 pub fn wait_for_event(
180 &self,
181 deadline: zx::MonotonicInstant,
182 ) -> Result<WlanFullmacImpl_Event, fidl::Error> {
183 WlanFullmacImpl_Event::decode(self.client.wait_for_event(deadline)?)
184 }
185
186 pub fn r#init(
202 &self,
203 mut payload: WlanFullmacImplInitRequest,
204 ___deadline: zx::MonotonicInstant,
205 ) -> Result<WlanFullmacImplInitResult, fidl::Error> {
206 let _response = self.client.send_query::<
207 WlanFullmacImplInitRequest,
208 fidl::encoding::ResultType<WlanFullmacImplInitResponse, i32>,
209 >(
210 &mut payload,
211 0x593dfb6cb3f0f1aa,
212 fidl::encoding::DynamicFlags::empty(),
213 ___deadline,
214 )?;
215 Ok(_response.map(|x| x))
216 }
217
218 pub fn r#query(
221 &self,
222 ___deadline: zx::MonotonicInstant,
223 ) -> Result<WlanFullmacImplQueryResult, fidl::Error> {
224 let _response = self.client.send_query::<
225 fidl::encoding::EmptyPayload,
226 fidl::encoding::ResultType<WlanFullmacImplQueryResponse, i32>,
227 >(
228 (),
229 0x28ac65f9da3941d4,
230 fidl::encoding::DynamicFlags::empty(),
231 ___deadline,
232 )?;
233 Ok(_response.map(|x| x))
234 }
235
236 pub fn r#query_mac_sublayer_support(
237 &self,
238 ___deadline: zx::MonotonicInstant,
239 ) -> Result<WlanFullmacImplQueryMacSublayerSupportResult, fidl::Error> {
240 let _response =
241 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
242 WlanFullmacImplQueryMacSublayerSupportResponse,
243 i32,
244 >>(
245 (),
246 0x2f09187eb87d9bad,
247 fidl::encoding::DynamicFlags::empty(),
248 ___deadline,
249 )?;
250 Ok(_response.map(|x| x.resp))
251 }
252
253 pub fn r#query_security_support(
254 &self,
255 ___deadline: zx::MonotonicInstant,
256 ) -> Result<WlanFullmacImplQuerySecuritySupportResult, fidl::Error> {
257 let _response =
258 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
259 WlanFullmacImplQuerySecuritySupportResponse,
260 i32,
261 >>(
262 (),
263 0x11cf3fa6eeb93f84,
264 fidl::encoding::DynamicFlags::empty(),
265 ___deadline,
266 )?;
267 Ok(_response.map(|x| x.resp))
268 }
269
270 pub fn r#query_spectrum_management_support(
271 &self,
272 ___deadline: zx::MonotonicInstant,
273 ) -> Result<WlanFullmacImplQuerySpectrumManagementSupportResult, fidl::Error> {
274 let _response = self
275 .client
276 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
277 WlanFullmacImplQuerySpectrumManagementSupportResponse,
278 i32,
279 >>(
280 (), 0x22ae7551d855b83a, fidl::encoding::DynamicFlags::empty(), ___deadline
281 )?;
282 Ok(_response.map(|x| x.resp))
283 }
284
285 pub fn r#query_telemetry_support(
286 &self,
287 ___deadline: zx::MonotonicInstant,
288 ) -> Result<WlanFullmacImplQueryTelemetrySupportResult, fidl::Error> {
289 let _response =
290 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
291 WlanFullmacImplQueryTelemetrySupportResponse,
292 i32,
293 >>(
294 (),
295 0x4561479ca560827f,
296 fidl::encoding::DynamicFlags::empty(),
297 ___deadline,
298 )?;
299 Ok(_response.map(|x| x.resp))
300 }
301
302 pub fn r#start_scan(
303 &self,
304 mut payload: &WlanFullmacImplStartScanRequest,
305 ___deadline: zx::MonotonicInstant,
306 ) -> Result<(), fidl::Error> {
307 let _response = self
308 .client
309 .send_query::<WlanFullmacImplStartScanRequest, fidl::encoding::EmptyPayload>(
310 payload,
311 0x26c17bf595aa161c,
312 fidl::encoding::DynamicFlags::empty(),
313 ___deadline,
314 )?;
315 Ok(_response)
316 }
317
318 pub fn r#connect(
319 &self,
320 mut payload: &WlanFullmacImplConnectRequest,
321 ___deadline: zx::MonotonicInstant,
322 ) -> Result<(), fidl::Error> {
323 let _response =
324 self.client.send_query::<WlanFullmacImplConnectRequest, fidl::encoding::EmptyPayload>(
325 payload,
326 0x19eb0322efb07a76,
327 fidl::encoding::DynamicFlags::empty(),
328 ___deadline,
329 )?;
330 Ok(_response)
331 }
332
333 pub fn r#reconnect(
334 &self,
335 mut payload: &WlanFullmacImplReconnectRequest,
336 ___deadline: zx::MonotonicInstant,
337 ) -> Result<(), fidl::Error> {
338 let _response = self
339 .client
340 .send_query::<WlanFullmacImplReconnectRequest, fidl::encoding::EmptyPayload>(
341 payload,
342 0x474084c4ef19ee71,
343 fidl::encoding::DynamicFlags::empty(),
344 ___deadline,
345 )?;
346 Ok(_response)
347 }
348
349 pub fn r#roam(
351 &self,
352 mut payload: &WlanFullmacImplRoamRequest,
353 ___deadline: zx::MonotonicInstant,
354 ) -> Result<(), fidl::Error> {
355 let _response =
356 self.client.send_query::<WlanFullmacImplRoamRequest, fidl::encoding::EmptyPayload>(
357 payload,
358 0x1e35dcc98b124b64,
359 fidl::encoding::DynamicFlags::empty(),
360 ___deadline,
361 )?;
362 Ok(_response)
363 }
364
365 pub fn r#auth_resp(
366 &self,
367 mut payload: &WlanFullmacImplAuthRespRequest,
368 ___deadline: zx::MonotonicInstant,
369 ) -> Result<(), fidl::Error> {
370 let _response = self
371 .client
372 .send_query::<WlanFullmacImplAuthRespRequest, fidl::encoding::EmptyPayload>(
373 payload,
374 0x5f7ea24b44a4aaeb,
375 fidl::encoding::DynamicFlags::empty(),
376 ___deadline,
377 )?;
378 Ok(_response)
379 }
380
381 pub fn r#deauth(
382 &self,
383 mut payload: &WlanFullmacImplDeauthRequest,
384 ___deadline: zx::MonotonicInstant,
385 ) -> Result<(), fidl::Error> {
386 let _response =
387 self.client.send_query::<WlanFullmacImplDeauthRequest, fidl::encoding::EmptyPayload>(
388 payload,
389 0x112786eccbf12f37,
390 fidl::encoding::DynamicFlags::empty(),
391 ___deadline,
392 )?;
393 Ok(_response)
394 }
395
396 pub fn r#assoc_resp(
397 &self,
398 mut payload: &WlanFullmacImplAssocRespRequest,
399 ___deadline: zx::MonotonicInstant,
400 ) -> Result<(), fidl::Error> {
401 let _response = self
402 .client
403 .send_query::<WlanFullmacImplAssocRespRequest, fidl::encoding::EmptyPayload>(
404 payload,
405 0x5022ce6b8eefec2f,
406 fidl::encoding::DynamicFlags::empty(),
407 ___deadline,
408 )?;
409 Ok(_response)
410 }
411
412 pub fn r#disassoc(
413 &self,
414 mut payload: &WlanFullmacImplDisassocRequest,
415 ___deadline: zx::MonotonicInstant,
416 ) -> Result<(), fidl::Error> {
417 let _response = self
418 .client
419 .send_query::<WlanFullmacImplDisassocRequest, fidl::encoding::EmptyPayload>(
420 payload,
421 0x9c0fc4e8de53e01,
422 fidl::encoding::DynamicFlags::empty(),
423 ___deadline,
424 )?;
425 Ok(_response)
426 }
427
428 pub fn r#start_bss(
429 &self,
430 mut payload: &WlanFullmacImplStartBssRequest,
431 ___deadline: zx::MonotonicInstant,
432 ) -> Result<(), fidl::Error> {
433 let _response = self
434 .client
435 .send_query::<WlanFullmacImplStartBssRequest, fidl::encoding::EmptyPayload>(
436 payload,
437 0x6922644d6b1d341d,
438 fidl::encoding::DynamicFlags::empty(),
439 ___deadline,
440 )?;
441 Ok(_response)
442 }
443
444 pub fn r#stop_bss(
445 &self,
446 mut payload: &WlanFullmacImplStopBssRequest,
447 ___deadline: zx::MonotonicInstant,
448 ) -> Result<(), fidl::Error> {
449 let _response =
450 self.client.send_query::<WlanFullmacImplStopBssRequest, fidl::encoding::EmptyPayload>(
451 payload,
452 0x5aeb9b72e7575268,
453 fidl::encoding::DynamicFlags::empty(),
454 ___deadline,
455 )?;
456 Ok(_response)
457 }
458
459 pub fn r#set_keys(
465 &self,
466 mut payload: &WlanFullmacImplSetKeysRequest,
467 ___deadline: zx::MonotonicInstant,
468 ) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
469 let _response = self
470 .client
471 .send_query::<WlanFullmacImplSetKeysRequest, WlanFullmacImplSetKeysResponse>(
472 payload,
473 0x20f46b1e039f0985,
474 fidl::encoding::DynamicFlags::empty(),
475 ___deadline,
476 )?;
477 Ok(_response.resp)
478 }
479
480 pub fn r#eapol_tx(
481 &self,
482 mut payload: &WlanFullmacImplEapolTxRequest,
483 ___deadline: zx::MonotonicInstant,
484 ) -> Result<(), fidl::Error> {
485 let _response =
486 self.client.send_query::<WlanFullmacImplEapolTxRequest, fidl::encoding::EmptyPayload>(
487 payload,
488 0x529a2d90fd4c8177,
489 fidl::encoding::DynamicFlags::empty(),
490 ___deadline,
491 )?;
492 Ok(_response)
493 }
494
495 pub fn r#get_iface_counter_stats(
496 &self,
497 ___deadline: zx::MonotonicInstant,
498 ) -> Result<WlanFullmacImplGetIfaceCounterStatsResult, fidl::Error> {
499 let _response =
500 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
501 WlanFullmacImplGetIfaceCounterStatsResponse,
502 i32,
503 >>(
504 (),
505 0x6b640d6c69c99225,
506 fidl::encoding::DynamicFlags::empty(),
507 ___deadline,
508 )?;
509 Ok(_response.map(|x| x.stats))
510 }
511
512 pub fn r#get_iface_histogram_stats(
513 &self,
514 ___deadline: zx::MonotonicInstant,
515 ) -> Result<WlanFullmacImplGetIfaceHistogramStatsResult, fidl::Error> {
516 let _response =
517 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
518 WlanFullmacImplGetIfaceHistogramStatsResponse,
519 i32,
520 >>(
521 (),
522 0x503d586f30ccf2cd,
523 fidl::encoding::DynamicFlags::empty(),
524 ___deadline,
525 )?;
526 Ok(_response.map(|x| x.stats))
527 }
528
529 pub fn r#sae_handshake_resp(
531 &self,
532 mut payload: &WlanFullmacImplSaeHandshakeRespRequest,
533 ___deadline: zx::MonotonicInstant,
534 ) -> Result<(), fidl::Error> {
535 let _response = self
536 .client
537 .send_query::<WlanFullmacImplSaeHandshakeRespRequest, fidl::encoding::EmptyPayload>(
538 payload,
539 0x72cd3a31ae5a54f6,
540 fidl::encoding::DynamicFlags::empty(),
541 ___deadline,
542 )?;
543 Ok(_response)
544 }
545
546 pub fn r#sae_frame_tx(
548 &self,
549 mut frame: &SaeFrame,
550 ___deadline: zx::MonotonicInstant,
551 ) -> Result<(), fidl::Error> {
552 let _response = self
553 .client
554 .send_query::<WlanFullmacImplSaeFrameTxRequest, fidl::encoding::EmptyPayload>(
555 (frame,),
556 0x4715ad5dc5a6340f,
557 fidl::encoding::DynamicFlags::empty(),
558 ___deadline,
559 )?;
560 Ok(_response)
561 }
562
563 pub fn r#wmm_status_req(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
564 let _response =
565 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
566 (),
567 0x635ecef3beb7a059,
568 fidl::encoding::DynamicFlags::empty(),
569 ___deadline,
570 )?;
571 Ok(_response)
572 }
573
574 pub fn r#on_link_state_changed(
575 &self,
576 mut payload: &WlanFullmacImplOnLinkStateChangedRequest,
577 ___deadline: zx::MonotonicInstant,
578 ) -> Result<(), fidl::Error> {
579 let _response = self
580 .client
581 .send_query::<WlanFullmacImplOnLinkStateChangedRequest, fidl::encoding::EmptyPayload>(
582 payload,
583 0x4d896e5b68e488d7,
584 fidl::encoding::DynamicFlags::empty(),
585 ___deadline,
586 )?;
587 Ok(_response)
588 }
589}
590
591#[derive(Debug, Clone)]
592pub struct WlanFullmacImpl_Proxy {
593 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
594}
595
596impl fidl::endpoints::Proxy for WlanFullmacImpl_Proxy {
597 type Protocol = WlanFullmacImpl_Marker;
598
599 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
600 Self::new(inner)
601 }
602
603 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
604 self.client.into_channel().map_err(|client| Self { client })
605 }
606
607 fn as_channel(&self) -> &::fidl::AsyncChannel {
608 self.client.as_channel()
609 }
610}
611
612impl WlanFullmacImpl_Proxy {
613 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
615 let protocol_name = <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
616 Self { client: fidl::client::Client::new(channel, protocol_name) }
617 }
618
619 pub fn take_event_stream(&self) -> WlanFullmacImpl_EventStream {
625 WlanFullmacImpl_EventStream { event_receiver: self.client.take_event_receiver() }
626 }
627
628 pub fn r#init(
644 &self,
645 mut payload: WlanFullmacImplInitRequest,
646 ) -> fidl::client::QueryResponseFut<
647 WlanFullmacImplInitResult,
648 fidl::encoding::DefaultFuchsiaResourceDialect,
649 > {
650 WlanFullmacImpl_ProxyInterface::r#init(self, payload)
651 }
652
653 pub fn r#query(
656 &self,
657 ) -> fidl::client::QueryResponseFut<
658 WlanFullmacImplQueryResult,
659 fidl::encoding::DefaultFuchsiaResourceDialect,
660 > {
661 WlanFullmacImpl_ProxyInterface::r#query(self)
662 }
663
664 pub fn r#query_mac_sublayer_support(
665 &self,
666 ) -> fidl::client::QueryResponseFut<
667 WlanFullmacImplQueryMacSublayerSupportResult,
668 fidl::encoding::DefaultFuchsiaResourceDialect,
669 > {
670 WlanFullmacImpl_ProxyInterface::r#query_mac_sublayer_support(self)
671 }
672
673 pub fn r#query_security_support(
674 &self,
675 ) -> fidl::client::QueryResponseFut<
676 WlanFullmacImplQuerySecuritySupportResult,
677 fidl::encoding::DefaultFuchsiaResourceDialect,
678 > {
679 WlanFullmacImpl_ProxyInterface::r#query_security_support(self)
680 }
681
682 pub fn r#query_spectrum_management_support(
683 &self,
684 ) -> fidl::client::QueryResponseFut<
685 WlanFullmacImplQuerySpectrumManagementSupportResult,
686 fidl::encoding::DefaultFuchsiaResourceDialect,
687 > {
688 WlanFullmacImpl_ProxyInterface::r#query_spectrum_management_support(self)
689 }
690
691 pub fn r#query_telemetry_support(
692 &self,
693 ) -> fidl::client::QueryResponseFut<
694 WlanFullmacImplQueryTelemetrySupportResult,
695 fidl::encoding::DefaultFuchsiaResourceDialect,
696 > {
697 WlanFullmacImpl_ProxyInterface::r#query_telemetry_support(self)
698 }
699
700 pub fn r#start_scan(
701 &self,
702 mut payload: &WlanFullmacImplStartScanRequest,
703 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
704 WlanFullmacImpl_ProxyInterface::r#start_scan(self, payload)
705 }
706
707 pub fn r#connect(
708 &self,
709 mut payload: &WlanFullmacImplConnectRequest,
710 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
711 WlanFullmacImpl_ProxyInterface::r#connect(self, payload)
712 }
713
714 pub fn r#reconnect(
715 &self,
716 mut payload: &WlanFullmacImplReconnectRequest,
717 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
718 WlanFullmacImpl_ProxyInterface::r#reconnect(self, payload)
719 }
720
721 pub fn r#roam(
723 &self,
724 mut payload: &WlanFullmacImplRoamRequest,
725 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
726 WlanFullmacImpl_ProxyInterface::r#roam(self, payload)
727 }
728
729 pub fn r#auth_resp(
730 &self,
731 mut payload: &WlanFullmacImplAuthRespRequest,
732 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
733 WlanFullmacImpl_ProxyInterface::r#auth_resp(self, payload)
734 }
735
736 pub fn r#deauth(
737 &self,
738 mut payload: &WlanFullmacImplDeauthRequest,
739 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
740 WlanFullmacImpl_ProxyInterface::r#deauth(self, payload)
741 }
742
743 pub fn r#assoc_resp(
744 &self,
745 mut payload: &WlanFullmacImplAssocRespRequest,
746 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
747 WlanFullmacImpl_ProxyInterface::r#assoc_resp(self, payload)
748 }
749
750 pub fn r#disassoc(
751 &self,
752 mut payload: &WlanFullmacImplDisassocRequest,
753 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
754 WlanFullmacImpl_ProxyInterface::r#disassoc(self, payload)
755 }
756
757 pub fn r#start_bss(
758 &self,
759 mut payload: &WlanFullmacImplStartBssRequest,
760 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
761 WlanFullmacImpl_ProxyInterface::r#start_bss(self, payload)
762 }
763
764 pub fn r#stop_bss(
765 &self,
766 mut payload: &WlanFullmacImplStopBssRequest,
767 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
768 WlanFullmacImpl_ProxyInterface::r#stop_bss(self, payload)
769 }
770
771 pub fn r#set_keys(
777 &self,
778 mut payload: &WlanFullmacImplSetKeysRequest,
779 ) -> fidl::client::QueryResponseFut<
780 WlanFullmacSetKeysResp,
781 fidl::encoding::DefaultFuchsiaResourceDialect,
782 > {
783 WlanFullmacImpl_ProxyInterface::r#set_keys(self, payload)
784 }
785
786 pub fn r#eapol_tx(
787 &self,
788 mut payload: &WlanFullmacImplEapolTxRequest,
789 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
790 WlanFullmacImpl_ProxyInterface::r#eapol_tx(self, payload)
791 }
792
793 pub fn r#get_iface_counter_stats(
794 &self,
795 ) -> fidl::client::QueryResponseFut<
796 WlanFullmacImplGetIfaceCounterStatsResult,
797 fidl::encoding::DefaultFuchsiaResourceDialect,
798 > {
799 WlanFullmacImpl_ProxyInterface::r#get_iface_counter_stats(self)
800 }
801
802 pub fn r#get_iface_histogram_stats(
803 &self,
804 ) -> fidl::client::QueryResponseFut<
805 WlanFullmacImplGetIfaceHistogramStatsResult,
806 fidl::encoding::DefaultFuchsiaResourceDialect,
807 > {
808 WlanFullmacImpl_ProxyInterface::r#get_iface_histogram_stats(self)
809 }
810
811 pub fn r#sae_handshake_resp(
813 &self,
814 mut payload: &WlanFullmacImplSaeHandshakeRespRequest,
815 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
816 WlanFullmacImpl_ProxyInterface::r#sae_handshake_resp(self, payload)
817 }
818
819 pub fn r#sae_frame_tx(
821 &self,
822 mut frame: &SaeFrame,
823 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
824 WlanFullmacImpl_ProxyInterface::r#sae_frame_tx(self, frame)
825 }
826
827 pub fn r#wmm_status_req(
828 &self,
829 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
830 WlanFullmacImpl_ProxyInterface::r#wmm_status_req(self)
831 }
832
833 pub fn r#on_link_state_changed(
834 &self,
835 mut payload: &WlanFullmacImplOnLinkStateChangedRequest,
836 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
837 WlanFullmacImpl_ProxyInterface::r#on_link_state_changed(self, payload)
838 }
839}
840
841impl WlanFullmacImpl_ProxyInterface for WlanFullmacImpl_Proxy {
842 type InitResponseFut = fidl::client::QueryResponseFut<
843 WlanFullmacImplInitResult,
844 fidl::encoding::DefaultFuchsiaResourceDialect,
845 >;
846 fn r#init(&self, mut payload: WlanFullmacImplInitRequest) -> Self::InitResponseFut {
847 fn _decode(
848 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
849 ) -> Result<WlanFullmacImplInitResult, fidl::Error> {
850 let _response = fidl::client::decode_transaction_body::<
851 fidl::encoding::ResultType<WlanFullmacImplInitResponse, i32>,
852 fidl::encoding::DefaultFuchsiaResourceDialect,
853 0x593dfb6cb3f0f1aa,
854 >(_buf?)?;
855 Ok(_response.map(|x| x))
856 }
857 self.client.send_query_and_decode::<WlanFullmacImplInitRequest, WlanFullmacImplInitResult>(
858 &mut payload,
859 0x593dfb6cb3f0f1aa,
860 fidl::encoding::DynamicFlags::empty(),
861 _decode,
862 )
863 }
864
865 type QueryResponseFut = fidl::client::QueryResponseFut<
866 WlanFullmacImplQueryResult,
867 fidl::encoding::DefaultFuchsiaResourceDialect,
868 >;
869 fn r#query(&self) -> Self::QueryResponseFut {
870 fn _decode(
871 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
872 ) -> Result<WlanFullmacImplQueryResult, fidl::Error> {
873 let _response = fidl::client::decode_transaction_body::<
874 fidl::encoding::ResultType<WlanFullmacImplQueryResponse, i32>,
875 fidl::encoding::DefaultFuchsiaResourceDialect,
876 0x28ac65f9da3941d4,
877 >(_buf?)?;
878 Ok(_response.map(|x| x))
879 }
880 self.client
881 .send_query_and_decode::<fidl::encoding::EmptyPayload, WlanFullmacImplQueryResult>(
882 (),
883 0x28ac65f9da3941d4,
884 fidl::encoding::DynamicFlags::empty(),
885 _decode,
886 )
887 }
888
889 type QueryMacSublayerSupportResponseFut = fidl::client::QueryResponseFut<
890 WlanFullmacImplQueryMacSublayerSupportResult,
891 fidl::encoding::DefaultFuchsiaResourceDialect,
892 >;
893 fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut {
894 fn _decode(
895 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
896 ) -> Result<WlanFullmacImplQueryMacSublayerSupportResult, fidl::Error> {
897 let _response = fidl::client::decode_transaction_body::<
898 fidl::encoding::ResultType<WlanFullmacImplQueryMacSublayerSupportResponse, i32>,
899 fidl::encoding::DefaultFuchsiaResourceDialect,
900 0x2f09187eb87d9bad,
901 >(_buf?)?;
902 Ok(_response.map(|x| x.resp))
903 }
904 self.client.send_query_and_decode::<
905 fidl::encoding::EmptyPayload,
906 WlanFullmacImplQueryMacSublayerSupportResult,
907 >(
908 (),
909 0x2f09187eb87d9bad,
910 fidl::encoding::DynamicFlags::empty(),
911 _decode,
912 )
913 }
914
915 type QuerySecuritySupportResponseFut = fidl::client::QueryResponseFut<
916 WlanFullmacImplQuerySecuritySupportResult,
917 fidl::encoding::DefaultFuchsiaResourceDialect,
918 >;
919 fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut {
920 fn _decode(
921 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
922 ) -> Result<WlanFullmacImplQuerySecuritySupportResult, fidl::Error> {
923 let _response = fidl::client::decode_transaction_body::<
924 fidl::encoding::ResultType<WlanFullmacImplQuerySecuritySupportResponse, i32>,
925 fidl::encoding::DefaultFuchsiaResourceDialect,
926 0x11cf3fa6eeb93f84,
927 >(_buf?)?;
928 Ok(_response.map(|x| x.resp))
929 }
930 self.client.send_query_and_decode::<
931 fidl::encoding::EmptyPayload,
932 WlanFullmacImplQuerySecuritySupportResult,
933 >(
934 (),
935 0x11cf3fa6eeb93f84,
936 fidl::encoding::DynamicFlags::empty(),
937 _decode,
938 )
939 }
940
941 type QuerySpectrumManagementSupportResponseFut = fidl::client::QueryResponseFut<
942 WlanFullmacImplQuerySpectrumManagementSupportResult,
943 fidl::encoding::DefaultFuchsiaResourceDialect,
944 >;
945 fn r#query_spectrum_management_support(
946 &self,
947 ) -> Self::QuerySpectrumManagementSupportResponseFut {
948 fn _decode(
949 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
950 ) -> Result<WlanFullmacImplQuerySpectrumManagementSupportResult, fidl::Error> {
951 let _response = fidl::client::decode_transaction_body::<
952 fidl::encoding::ResultType<
953 WlanFullmacImplQuerySpectrumManagementSupportResponse,
954 i32,
955 >,
956 fidl::encoding::DefaultFuchsiaResourceDialect,
957 0x22ae7551d855b83a,
958 >(_buf?)?;
959 Ok(_response.map(|x| x.resp))
960 }
961 self.client.send_query_and_decode::<
962 fidl::encoding::EmptyPayload,
963 WlanFullmacImplQuerySpectrumManagementSupportResult,
964 >(
965 (),
966 0x22ae7551d855b83a,
967 fidl::encoding::DynamicFlags::empty(),
968 _decode,
969 )
970 }
971
972 type QueryTelemetrySupportResponseFut = fidl::client::QueryResponseFut<
973 WlanFullmacImplQueryTelemetrySupportResult,
974 fidl::encoding::DefaultFuchsiaResourceDialect,
975 >;
976 fn r#query_telemetry_support(&self) -> Self::QueryTelemetrySupportResponseFut {
977 fn _decode(
978 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
979 ) -> Result<WlanFullmacImplQueryTelemetrySupportResult, fidl::Error> {
980 let _response = fidl::client::decode_transaction_body::<
981 fidl::encoding::ResultType<WlanFullmacImplQueryTelemetrySupportResponse, i32>,
982 fidl::encoding::DefaultFuchsiaResourceDialect,
983 0x4561479ca560827f,
984 >(_buf?)?;
985 Ok(_response.map(|x| x.resp))
986 }
987 self.client.send_query_and_decode::<
988 fidl::encoding::EmptyPayload,
989 WlanFullmacImplQueryTelemetrySupportResult,
990 >(
991 (),
992 0x4561479ca560827f,
993 fidl::encoding::DynamicFlags::empty(),
994 _decode,
995 )
996 }
997
998 type StartScanResponseFut =
999 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1000 fn r#start_scan(
1001 &self,
1002 mut payload: &WlanFullmacImplStartScanRequest,
1003 ) -> Self::StartScanResponseFut {
1004 fn _decode(
1005 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1006 ) -> Result<(), fidl::Error> {
1007 let _response = fidl::client::decode_transaction_body::<
1008 fidl::encoding::EmptyPayload,
1009 fidl::encoding::DefaultFuchsiaResourceDialect,
1010 0x26c17bf595aa161c,
1011 >(_buf?)?;
1012 Ok(_response)
1013 }
1014 self.client.send_query_and_decode::<WlanFullmacImplStartScanRequest, ()>(
1015 payload,
1016 0x26c17bf595aa161c,
1017 fidl::encoding::DynamicFlags::empty(),
1018 _decode,
1019 )
1020 }
1021
1022 type ConnectResponseFut =
1023 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1024 fn r#connect(&self, mut payload: &WlanFullmacImplConnectRequest) -> Self::ConnectResponseFut {
1025 fn _decode(
1026 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1027 ) -> Result<(), fidl::Error> {
1028 let _response = fidl::client::decode_transaction_body::<
1029 fidl::encoding::EmptyPayload,
1030 fidl::encoding::DefaultFuchsiaResourceDialect,
1031 0x19eb0322efb07a76,
1032 >(_buf?)?;
1033 Ok(_response)
1034 }
1035 self.client.send_query_and_decode::<WlanFullmacImplConnectRequest, ()>(
1036 payload,
1037 0x19eb0322efb07a76,
1038 fidl::encoding::DynamicFlags::empty(),
1039 _decode,
1040 )
1041 }
1042
1043 type ReconnectResponseFut =
1044 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1045 fn r#reconnect(
1046 &self,
1047 mut payload: &WlanFullmacImplReconnectRequest,
1048 ) -> Self::ReconnectResponseFut {
1049 fn _decode(
1050 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1051 ) -> Result<(), fidl::Error> {
1052 let _response = fidl::client::decode_transaction_body::<
1053 fidl::encoding::EmptyPayload,
1054 fidl::encoding::DefaultFuchsiaResourceDialect,
1055 0x474084c4ef19ee71,
1056 >(_buf?)?;
1057 Ok(_response)
1058 }
1059 self.client.send_query_and_decode::<WlanFullmacImplReconnectRequest, ()>(
1060 payload,
1061 0x474084c4ef19ee71,
1062 fidl::encoding::DynamicFlags::empty(),
1063 _decode,
1064 )
1065 }
1066
1067 type RoamResponseFut =
1068 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1069 fn r#roam(&self, mut payload: &WlanFullmacImplRoamRequest) -> Self::RoamResponseFut {
1070 fn _decode(
1071 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1072 ) -> Result<(), fidl::Error> {
1073 let _response = fidl::client::decode_transaction_body::<
1074 fidl::encoding::EmptyPayload,
1075 fidl::encoding::DefaultFuchsiaResourceDialect,
1076 0x1e35dcc98b124b64,
1077 >(_buf?)?;
1078 Ok(_response)
1079 }
1080 self.client.send_query_and_decode::<WlanFullmacImplRoamRequest, ()>(
1081 payload,
1082 0x1e35dcc98b124b64,
1083 fidl::encoding::DynamicFlags::empty(),
1084 _decode,
1085 )
1086 }
1087
1088 type AuthRespResponseFut =
1089 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1090 fn r#auth_resp(
1091 &self,
1092 mut payload: &WlanFullmacImplAuthRespRequest,
1093 ) -> Self::AuthRespResponseFut {
1094 fn _decode(
1095 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1096 ) -> Result<(), fidl::Error> {
1097 let _response = fidl::client::decode_transaction_body::<
1098 fidl::encoding::EmptyPayload,
1099 fidl::encoding::DefaultFuchsiaResourceDialect,
1100 0x5f7ea24b44a4aaeb,
1101 >(_buf?)?;
1102 Ok(_response)
1103 }
1104 self.client.send_query_and_decode::<WlanFullmacImplAuthRespRequest, ()>(
1105 payload,
1106 0x5f7ea24b44a4aaeb,
1107 fidl::encoding::DynamicFlags::empty(),
1108 _decode,
1109 )
1110 }
1111
1112 type DeauthResponseFut =
1113 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1114 fn r#deauth(&self, mut payload: &WlanFullmacImplDeauthRequest) -> Self::DeauthResponseFut {
1115 fn _decode(
1116 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1117 ) -> Result<(), fidl::Error> {
1118 let _response = fidl::client::decode_transaction_body::<
1119 fidl::encoding::EmptyPayload,
1120 fidl::encoding::DefaultFuchsiaResourceDialect,
1121 0x112786eccbf12f37,
1122 >(_buf?)?;
1123 Ok(_response)
1124 }
1125 self.client.send_query_and_decode::<WlanFullmacImplDeauthRequest, ()>(
1126 payload,
1127 0x112786eccbf12f37,
1128 fidl::encoding::DynamicFlags::empty(),
1129 _decode,
1130 )
1131 }
1132
1133 type AssocRespResponseFut =
1134 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1135 fn r#assoc_resp(
1136 &self,
1137 mut payload: &WlanFullmacImplAssocRespRequest,
1138 ) -> Self::AssocRespResponseFut {
1139 fn _decode(
1140 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1141 ) -> Result<(), fidl::Error> {
1142 let _response = fidl::client::decode_transaction_body::<
1143 fidl::encoding::EmptyPayload,
1144 fidl::encoding::DefaultFuchsiaResourceDialect,
1145 0x5022ce6b8eefec2f,
1146 >(_buf?)?;
1147 Ok(_response)
1148 }
1149 self.client.send_query_and_decode::<WlanFullmacImplAssocRespRequest, ()>(
1150 payload,
1151 0x5022ce6b8eefec2f,
1152 fidl::encoding::DynamicFlags::empty(),
1153 _decode,
1154 )
1155 }
1156
1157 type DisassocResponseFut =
1158 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1159 fn r#disassoc(
1160 &self,
1161 mut payload: &WlanFullmacImplDisassocRequest,
1162 ) -> Self::DisassocResponseFut {
1163 fn _decode(
1164 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1165 ) -> Result<(), fidl::Error> {
1166 let _response = fidl::client::decode_transaction_body::<
1167 fidl::encoding::EmptyPayload,
1168 fidl::encoding::DefaultFuchsiaResourceDialect,
1169 0x9c0fc4e8de53e01,
1170 >(_buf?)?;
1171 Ok(_response)
1172 }
1173 self.client.send_query_and_decode::<WlanFullmacImplDisassocRequest, ()>(
1174 payload,
1175 0x9c0fc4e8de53e01,
1176 fidl::encoding::DynamicFlags::empty(),
1177 _decode,
1178 )
1179 }
1180
1181 type StartBssResponseFut =
1182 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1183 fn r#start_bss(
1184 &self,
1185 mut payload: &WlanFullmacImplStartBssRequest,
1186 ) -> Self::StartBssResponseFut {
1187 fn _decode(
1188 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1189 ) -> Result<(), fidl::Error> {
1190 let _response = fidl::client::decode_transaction_body::<
1191 fidl::encoding::EmptyPayload,
1192 fidl::encoding::DefaultFuchsiaResourceDialect,
1193 0x6922644d6b1d341d,
1194 >(_buf?)?;
1195 Ok(_response)
1196 }
1197 self.client.send_query_and_decode::<WlanFullmacImplStartBssRequest, ()>(
1198 payload,
1199 0x6922644d6b1d341d,
1200 fidl::encoding::DynamicFlags::empty(),
1201 _decode,
1202 )
1203 }
1204
1205 type StopBssResponseFut =
1206 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1207 fn r#stop_bss(&self, mut payload: &WlanFullmacImplStopBssRequest) -> Self::StopBssResponseFut {
1208 fn _decode(
1209 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1210 ) -> Result<(), fidl::Error> {
1211 let _response = fidl::client::decode_transaction_body::<
1212 fidl::encoding::EmptyPayload,
1213 fidl::encoding::DefaultFuchsiaResourceDialect,
1214 0x5aeb9b72e7575268,
1215 >(_buf?)?;
1216 Ok(_response)
1217 }
1218 self.client.send_query_and_decode::<WlanFullmacImplStopBssRequest, ()>(
1219 payload,
1220 0x5aeb9b72e7575268,
1221 fidl::encoding::DynamicFlags::empty(),
1222 _decode,
1223 )
1224 }
1225
1226 type SetKeysResponseFut = fidl::client::QueryResponseFut<
1227 WlanFullmacSetKeysResp,
1228 fidl::encoding::DefaultFuchsiaResourceDialect,
1229 >;
1230 fn r#set_keys(&self, mut payload: &WlanFullmacImplSetKeysRequest) -> Self::SetKeysResponseFut {
1231 fn _decode(
1232 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1233 ) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
1234 let _response = fidl::client::decode_transaction_body::<
1235 WlanFullmacImplSetKeysResponse,
1236 fidl::encoding::DefaultFuchsiaResourceDialect,
1237 0x20f46b1e039f0985,
1238 >(_buf?)?;
1239 Ok(_response.resp)
1240 }
1241 self.client.send_query_and_decode::<WlanFullmacImplSetKeysRequest, WlanFullmacSetKeysResp>(
1242 payload,
1243 0x20f46b1e039f0985,
1244 fidl::encoding::DynamicFlags::empty(),
1245 _decode,
1246 )
1247 }
1248
1249 type EapolTxResponseFut =
1250 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1251 fn r#eapol_tx(&self, mut payload: &WlanFullmacImplEapolTxRequest) -> Self::EapolTxResponseFut {
1252 fn _decode(
1253 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1254 ) -> Result<(), fidl::Error> {
1255 let _response = fidl::client::decode_transaction_body::<
1256 fidl::encoding::EmptyPayload,
1257 fidl::encoding::DefaultFuchsiaResourceDialect,
1258 0x529a2d90fd4c8177,
1259 >(_buf?)?;
1260 Ok(_response)
1261 }
1262 self.client.send_query_and_decode::<WlanFullmacImplEapolTxRequest, ()>(
1263 payload,
1264 0x529a2d90fd4c8177,
1265 fidl::encoding::DynamicFlags::empty(),
1266 _decode,
1267 )
1268 }
1269
1270 type GetIfaceCounterStatsResponseFut = fidl::client::QueryResponseFut<
1271 WlanFullmacImplGetIfaceCounterStatsResult,
1272 fidl::encoding::DefaultFuchsiaResourceDialect,
1273 >;
1274 fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut {
1275 fn _decode(
1276 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1277 ) -> Result<WlanFullmacImplGetIfaceCounterStatsResult, fidl::Error> {
1278 let _response = fidl::client::decode_transaction_body::<
1279 fidl::encoding::ResultType<WlanFullmacImplGetIfaceCounterStatsResponse, i32>,
1280 fidl::encoding::DefaultFuchsiaResourceDialect,
1281 0x6b640d6c69c99225,
1282 >(_buf?)?;
1283 Ok(_response.map(|x| x.stats))
1284 }
1285 self.client.send_query_and_decode::<
1286 fidl::encoding::EmptyPayload,
1287 WlanFullmacImplGetIfaceCounterStatsResult,
1288 >(
1289 (),
1290 0x6b640d6c69c99225,
1291 fidl::encoding::DynamicFlags::empty(),
1292 _decode,
1293 )
1294 }
1295
1296 type GetIfaceHistogramStatsResponseFut = fidl::client::QueryResponseFut<
1297 WlanFullmacImplGetIfaceHistogramStatsResult,
1298 fidl::encoding::DefaultFuchsiaResourceDialect,
1299 >;
1300 fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut {
1301 fn _decode(
1302 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1303 ) -> Result<WlanFullmacImplGetIfaceHistogramStatsResult, fidl::Error> {
1304 let _response = fidl::client::decode_transaction_body::<
1305 fidl::encoding::ResultType<WlanFullmacImplGetIfaceHistogramStatsResponse, i32>,
1306 fidl::encoding::DefaultFuchsiaResourceDialect,
1307 0x503d586f30ccf2cd,
1308 >(_buf?)?;
1309 Ok(_response.map(|x| x.stats))
1310 }
1311 self.client.send_query_and_decode::<
1312 fidl::encoding::EmptyPayload,
1313 WlanFullmacImplGetIfaceHistogramStatsResult,
1314 >(
1315 (),
1316 0x503d586f30ccf2cd,
1317 fidl::encoding::DynamicFlags::empty(),
1318 _decode,
1319 )
1320 }
1321
1322 type SaeHandshakeRespResponseFut =
1323 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1324 fn r#sae_handshake_resp(
1325 &self,
1326 mut payload: &WlanFullmacImplSaeHandshakeRespRequest,
1327 ) -> Self::SaeHandshakeRespResponseFut {
1328 fn _decode(
1329 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1330 ) -> Result<(), fidl::Error> {
1331 let _response = fidl::client::decode_transaction_body::<
1332 fidl::encoding::EmptyPayload,
1333 fidl::encoding::DefaultFuchsiaResourceDialect,
1334 0x72cd3a31ae5a54f6,
1335 >(_buf?)?;
1336 Ok(_response)
1337 }
1338 self.client.send_query_and_decode::<WlanFullmacImplSaeHandshakeRespRequest, ()>(
1339 payload,
1340 0x72cd3a31ae5a54f6,
1341 fidl::encoding::DynamicFlags::empty(),
1342 _decode,
1343 )
1344 }
1345
1346 type SaeFrameTxResponseFut =
1347 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1348 fn r#sae_frame_tx(&self, mut frame: &SaeFrame) -> Self::SaeFrameTxResponseFut {
1349 fn _decode(
1350 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1351 ) -> Result<(), fidl::Error> {
1352 let _response = fidl::client::decode_transaction_body::<
1353 fidl::encoding::EmptyPayload,
1354 fidl::encoding::DefaultFuchsiaResourceDialect,
1355 0x4715ad5dc5a6340f,
1356 >(_buf?)?;
1357 Ok(_response)
1358 }
1359 self.client.send_query_and_decode::<WlanFullmacImplSaeFrameTxRequest, ()>(
1360 (frame,),
1361 0x4715ad5dc5a6340f,
1362 fidl::encoding::DynamicFlags::empty(),
1363 _decode,
1364 )
1365 }
1366
1367 type WmmStatusReqResponseFut =
1368 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1369 fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut {
1370 fn _decode(
1371 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1372 ) -> Result<(), fidl::Error> {
1373 let _response = fidl::client::decode_transaction_body::<
1374 fidl::encoding::EmptyPayload,
1375 fidl::encoding::DefaultFuchsiaResourceDialect,
1376 0x635ecef3beb7a059,
1377 >(_buf?)?;
1378 Ok(_response)
1379 }
1380 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
1381 (),
1382 0x635ecef3beb7a059,
1383 fidl::encoding::DynamicFlags::empty(),
1384 _decode,
1385 )
1386 }
1387
1388 type OnLinkStateChangedResponseFut =
1389 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1390 fn r#on_link_state_changed(
1391 &self,
1392 mut payload: &WlanFullmacImplOnLinkStateChangedRequest,
1393 ) -> Self::OnLinkStateChangedResponseFut {
1394 fn _decode(
1395 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1396 ) -> Result<(), fidl::Error> {
1397 let _response = fidl::client::decode_transaction_body::<
1398 fidl::encoding::EmptyPayload,
1399 fidl::encoding::DefaultFuchsiaResourceDialect,
1400 0x4d896e5b68e488d7,
1401 >(_buf?)?;
1402 Ok(_response)
1403 }
1404 self.client.send_query_and_decode::<WlanFullmacImplOnLinkStateChangedRequest, ()>(
1405 payload,
1406 0x4d896e5b68e488d7,
1407 fidl::encoding::DynamicFlags::empty(),
1408 _decode,
1409 )
1410 }
1411}
1412
1413pub struct WlanFullmacImpl_EventStream {
1414 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1415}
1416
1417impl std::marker::Unpin for WlanFullmacImpl_EventStream {}
1418
1419impl futures::stream::FusedStream for WlanFullmacImpl_EventStream {
1420 fn is_terminated(&self) -> bool {
1421 self.event_receiver.is_terminated()
1422 }
1423}
1424
1425impl futures::Stream for WlanFullmacImpl_EventStream {
1426 type Item = Result<WlanFullmacImpl_Event, fidl::Error>;
1427
1428 fn poll_next(
1429 mut self: std::pin::Pin<&mut Self>,
1430 cx: &mut std::task::Context<'_>,
1431 ) -> std::task::Poll<Option<Self::Item>> {
1432 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1433 &mut self.event_receiver,
1434 cx
1435 )?) {
1436 Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImpl_Event::decode(buf))),
1437 None => std::task::Poll::Ready(None),
1438 }
1439 }
1440}
1441
1442#[derive(Debug)]
1443pub enum WlanFullmacImpl_Event {}
1444
1445impl WlanFullmacImpl_Event {
1446 fn decode(
1448 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1449 ) -> Result<WlanFullmacImpl_Event, fidl::Error> {
1450 let (bytes, _handles) = buf.split_mut();
1451 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1452 debug_assert_eq!(tx_header.tx_id, 0);
1453 match tx_header.ordinal {
1454 _ => Err(fidl::Error::UnknownOrdinal {
1455 ordinal: tx_header.ordinal,
1456 protocol_name:
1457 <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1458 }),
1459 }
1460 }
1461}
1462
1463pub struct WlanFullmacImpl_RequestStream {
1465 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1466 is_terminated: bool,
1467}
1468
1469impl std::marker::Unpin for WlanFullmacImpl_RequestStream {}
1470
1471impl futures::stream::FusedStream for WlanFullmacImpl_RequestStream {
1472 fn is_terminated(&self) -> bool {
1473 self.is_terminated
1474 }
1475}
1476
1477impl fidl::endpoints::RequestStream for WlanFullmacImpl_RequestStream {
1478 type Protocol = WlanFullmacImpl_Marker;
1479 type ControlHandle = WlanFullmacImpl_ControlHandle;
1480
1481 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1482 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1483 }
1484
1485 fn control_handle(&self) -> Self::ControlHandle {
1486 WlanFullmacImpl_ControlHandle { inner: self.inner.clone() }
1487 }
1488
1489 fn into_inner(
1490 self,
1491 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1492 {
1493 (self.inner, self.is_terminated)
1494 }
1495
1496 fn from_inner(
1497 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1498 is_terminated: bool,
1499 ) -> Self {
1500 Self { inner, is_terminated }
1501 }
1502}
1503
1504impl futures::Stream for WlanFullmacImpl_RequestStream {
1505 type Item = Result<WlanFullmacImpl_Request, fidl::Error>;
1506
1507 fn poll_next(
1508 mut self: std::pin::Pin<&mut Self>,
1509 cx: &mut std::task::Context<'_>,
1510 ) -> std::task::Poll<Option<Self::Item>> {
1511 let this = &mut *self;
1512 if this.inner.check_shutdown(cx) {
1513 this.is_terminated = true;
1514 return std::task::Poll::Ready(None);
1515 }
1516 if this.is_terminated {
1517 panic!("polled WlanFullmacImpl_RequestStream after completion");
1518 }
1519 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1520 |bytes, handles| {
1521 match this.inner.channel().read_etc(cx, bytes, handles) {
1522 std::task::Poll::Ready(Ok(())) => {}
1523 std::task::Poll::Pending => return std::task::Poll::Pending,
1524 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1525 this.is_terminated = true;
1526 return std::task::Poll::Ready(None);
1527 }
1528 std::task::Poll::Ready(Err(e)) => {
1529 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1530 e.into(),
1531 ))))
1532 }
1533 }
1534
1535 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1537
1538 std::task::Poll::Ready(Some(match header.ordinal {
1539 0x593dfb6cb3f0f1aa => {
1540 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1541 let mut req = fidl::new_empty!(
1542 WlanFullmacImplInitRequest,
1543 fidl::encoding::DefaultFuchsiaResourceDialect
1544 );
1545 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplInitRequest>(&header, _body_bytes, handles, &mut req)?;
1546 let control_handle =
1547 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1548 Ok(WlanFullmacImpl_Request::Init {
1549 payload: req,
1550 responder: WlanFullmacImpl_InitResponder {
1551 control_handle: std::mem::ManuallyDrop::new(control_handle),
1552 tx_id: header.tx_id,
1553 },
1554 })
1555 }
1556 0x28ac65f9da3941d4 => {
1557 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1558 let mut req = fidl::new_empty!(
1559 fidl::encoding::EmptyPayload,
1560 fidl::encoding::DefaultFuchsiaResourceDialect
1561 );
1562 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1563 let control_handle =
1564 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1565 Ok(WlanFullmacImpl_Request::Query {
1566 responder: WlanFullmacImpl_QueryResponder {
1567 control_handle: std::mem::ManuallyDrop::new(control_handle),
1568 tx_id: header.tx_id,
1569 },
1570 })
1571 }
1572 0x2f09187eb87d9bad => {
1573 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1574 let mut req = fidl::new_empty!(
1575 fidl::encoding::EmptyPayload,
1576 fidl::encoding::DefaultFuchsiaResourceDialect
1577 );
1578 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1579 let control_handle =
1580 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1581 Ok(WlanFullmacImpl_Request::QueryMacSublayerSupport {
1582 responder: WlanFullmacImpl_QueryMacSublayerSupportResponder {
1583 control_handle: std::mem::ManuallyDrop::new(control_handle),
1584 tx_id: header.tx_id,
1585 },
1586 })
1587 }
1588 0x11cf3fa6eeb93f84 => {
1589 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1590 let mut req = fidl::new_empty!(
1591 fidl::encoding::EmptyPayload,
1592 fidl::encoding::DefaultFuchsiaResourceDialect
1593 );
1594 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1595 let control_handle =
1596 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1597 Ok(WlanFullmacImpl_Request::QuerySecuritySupport {
1598 responder: WlanFullmacImpl_QuerySecuritySupportResponder {
1599 control_handle: std::mem::ManuallyDrop::new(control_handle),
1600 tx_id: header.tx_id,
1601 },
1602 })
1603 }
1604 0x22ae7551d855b83a => {
1605 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1606 let mut req = fidl::new_empty!(
1607 fidl::encoding::EmptyPayload,
1608 fidl::encoding::DefaultFuchsiaResourceDialect
1609 );
1610 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1611 let control_handle =
1612 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1613 Ok(WlanFullmacImpl_Request::QuerySpectrumManagementSupport {
1614 responder: WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
1615 control_handle: std::mem::ManuallyDrop::new(control_handle),
1616 tx_id: header.tx_id,
1617 },
1618 })
1619 }
1620 0x4561479ca560827f => {
1621 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1622 let mut req = fidl::new_empty!(
1623 fidl::encoding::EmptyPayload,
1624 fidl::encoding::DefaultFuchsiaResourceDialect
1625 );
1626 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1627 let control_handle =
1628 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1629 Ok(WlanFullmacImpl_Request::QueryTelemetrySupport {
1630 responder: WlanFullmacImpl_QueryTelemetrySupportResponder {
1631 control_handle: std::mem::ManuallyDrop::new(control_handle),
1632 tx_id: header.tx_id,
1633 },
1634 })
1635 }
1636 0x26c17bf595aa161c => {
1637 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1638 let mut req = fidl::new_empty!(
1639 WlanFullmacImplStartScanRequest,
1640 fidl::encoding::DefaultFuchsiaResourceDialect
1641 );
1642 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplStartScanRequest>(&header, _body_bytes, handles, &mut req)?;
1643 let control_handle =
1644 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1645 Ok(WlanFullmacImpl_Request::StartScan {
1646 payload: req,
1647 responder: WlanFullmacImpl_StartScanResponder {
1648 control_handle: std::mem::ManuallyDrop::new(control_handle),
1649 tx_id: header.tx_id,
1650 },
1651 })
1652 }
1653 0x19eb0322efb07a76 => {
1654 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1655 let mut req = fidl::new_empty!(
1656 WlanFullmacImplConnectRequest,
1657 fidl::encoding::DefaultFuchsiaResourceDialect
1658 );
1659 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplConnectRequest>(&header, _body_bytes, handles, &mut req)?;
1660 let control_handle =
1661 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1662 Ok(WlanFullmacImpl_Request::Connect {
1663 payload: req,
1664 responder: WlanFullmacImpl_ConnectResponder {
1665 control_handle: std::mem::ManuallyDrop::new(control_handle),
1666 tx_id: header.tx_id,
1667 },
1668 })
1669 }
1670 0x474084c4ef19ee71 => {
1671 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1672 let mut req = fidl::new_empty!(
1673 WlanFullmacImplReconnectRequest,
1674 fidl::encoding::DefaultFuchsiaResourceDialect
1675 );
1676 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplReconnectRequest>(&header, _body_bytes, handles, &mut req)?;
1677 let control_handle =
1678 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1679 Ok(WlanFullmacImpl_Request::Reconnect {
1680 payload: req,
1681 responder: WlanFullmacImpl_ReconnectResponder {
1682 control_handle: std::mem::ManuallyDrop::new(control_handle),
1683 tx_id: header.tx_id,
1684 },
1685 })
1686 }
1687 0x1e35dcc98b124b64 => {
1688 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1689 let mut req = fidl::new_empty!(
1690 WlanFullmacImplRoamRequest,
1691 fidl::encoding::DefaultFuchsiaResourceDialect
1692 );
1693 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplRoamRequest>(&header, _body_bytes, handles, &mut req)?;
1694 let control_handle =
1695 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1696 Ok(WlanFullmacImpl_Request::Roam {
1697 payload: req,
1698 responder: WlanFullmacImpl_RoamResponder {
1699 control_handle: std::mem::ManuallyDrop::new(control_handle),
1700 tx_id: header.tx_id,
1701 },
1702 })
1703 }
1704 0x5f7ea24b44a4aaeb => {
1705 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1706 let mut req = fidl::new_empty!(
1707 WlanFullmacImplAuthRespRequest,
1708 fidl::encoding::DefaultFuchsiaResourceDialect
1709 );
1710 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplAuthRespRequest>(&header, _body_bytes, handles, &mut req)?;
1711 let control_handle =
1712 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1713 Ok(WlanFullmacImpl_Request::AuthResp {
1714 payload: req,
1715 responder: WlanFullmacImpl_AuthRespResponder {
1716 control_handle: std::mem::ManuallyDrop::new(control_handle),
1717 tx_id: header.tx_id,
1718 },
1719 })
1720 }
1721 0x112786eccbf12f37 => {
1722 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1723 let mut req = fidl::new_empty!(
1724 WlanFullmacImplDeauthRequest,
1725 fidl::encoding::DefaultFuchsiaResourceDialect
1726 );
1727 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplDeauthRequest>(&header, _body_bytes, handles, &mut req)?;
1728 let control_handle =
1729 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1730 Ok(WlanFullmacImpl_Request::Deauth {
1731 payload: req,
1732 responder: WlanFullmacImpl_DeauthResponder {
1733 control_handle: std::mem::ManuallyDrop::new(control_handle),
1734 tx_id: header.tx_id,
1735 },
1736 })
1737 }
1738 0x5022ce6b8eefec2f => {
1739 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1740 let mut req = fidl::new_empty!(
1741 WlanFullmacImplAssocRespRequest,
1742 fidl::encoding::DefaultFuchsiaResourceDialect
1743 );
1744 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplAssocRespRequest>(&header, _body_bytes, handles, &mut req)?;
1745 let control_handle =
1746 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1747 Ok(WlanFullmacImpl_Request::AssocResp {
1748 payload: req,
1749 responder: WlanFullmacImpl_AssocRespResponder {
1750 control_handle: std::mem::ManuallyDrop::new(control_handle),
1751 tx_id: header.tx_id,
1752 },
1753 })
1754 }
1755 0x9c0fc4e8de53e01 => {
1756 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1757 let mut req = fidl::new_empty!(
1758 WlanFullmacImplDisassocRequest,
1759 fidl::encoding::DefaultFuchsiaResourceDialect
1760 );
1761 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplDisassocRequest>(&header, _body_bytes, handles, &mut req)?;
1762 let control_handle =
1763 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1764 Ok(WlanFullmacImpl_Request::Disassoc {
1765 payload: req,
1766 responder: WlanFullmacImpl_DisassocResponder {
1767 control_handle: std::mem::ManuallyDrop::new(control_handle),
1768 tx_id: header.tx_id,
1769 },
1770 })
1771 }
1772 0x6922644d6b1d341d => {
1773 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1774 let mut req = fidl::new_empty!(
1775 WlanFullmacImplStartBssRequest,
1776 fidl::encoding::DefaultFuchsiaResourceDialect
1777 );
1778 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplStartBssRequest>(&header, _body_bytes, handles, &mut req)?;
1779 let control_handle =
1780 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1781 Ok(WlanFullmacImpl_Request::StartBss {
1782 payload: req,
1783 responder: WlanFullmacImpl_StartBssResponder {
1784 control_handle: std::mem::ManuallyDrop::new(control_handle),
1785 tx_id: header.tx_id,
1786 },
1787 })
1788 }
1789 0x5aeb9b72e7575268 => {
1790 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1791 let mut req = fidl::new_empty!(
1792 WlanFullmacImplStopBssRequest,
1793 fidl::encoding::DefaultFuchsiaResourceDialect
1794 );
1795 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplStopBssRequest>(&header, _body_bytes, handles, &mut req)?;
1796 let control_handle =
1797 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1798 Ok(WlanFullmacImpl_Request::StopBss {
1799 payload: req,
1800 responder: WlanFullmacImpl_StopBssResponder {
1801 control_handle: std::mem::ManuallyDrop::new(control_handle),
1802 tx_id: header.tx_id,
1803 },
1804 })
1805 }
1806 0x20f46b1e039f0985 => {
1807 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1808 let mut req = fidl::new_empty!(
1809 WlanFullmacImplSetKeysRequest,
1810 fidl::encoding::DefaultFuchsiaResourceDialect
1811 );
1812 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplSetKeysRequest>(&header, _body_bytes, handles, &mut req)?;
1813 let control_handle =
1814 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1815 Ok(WlanFullmacImpl_Request::SetKeys {
1816 payload: req,
1817 responder: WlanFullmacImpl_SetKeysResponder {
1818 control_handle: std::mem::ManuallyDrop::new(control_handle),
1819 tx_id: header.tx_id,
1820 },
1821 })
1822 }
1823 0x529a2d90fd4c8177 => {
1824 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1825 let mut req = fidl::new_empty!(
1826 WlanFullmacImplEapolTxRequest,
1827 fidl::encoding::DefaultFuchsiaResourceDialect
1828 );
1829 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplEapolTxRequest>(&header, _body_bytes, handles, &mut req)?;
1830 let control_handle =
1831 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1832 Ok(WlanFullmacImpl_Request::EapolTx {
1833 payload: req,
1834 responder: WlanFullmacImpl_EapolTxResponder {
1835 control_handle: std::mem::ManuallyDrop::new(control_handle),
1836 tx_id: header.tx_id,
1837 },
1838 })
1839 }
1840 0x6b640d6c69c99225 => {
1841 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1842 let mut req = fidl::new_empty!(
1843 fidl::encoding::EmptyPayload,
1844 fidl::encoding::DefaultFuchsiaResourceDialect
1845 );
1846 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1847 let control_handle =
1848 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1849 Ok(WlanFullmacImpl_Request::GetIfaceCounterStats {
1850 responder: WlanFullmacImpl_GetIfaceCounterStatsResponder {
1851 control_handle: std::mem::ManuallyDrop::new(control_handle),
1852 tx_id: header.tx_id,
1853 },
1854 })
1855 }
1856 0x503d586f30ccf2cd => {
1857 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1858 let mut req = fidl::new_empty!(
1859 fidl::encoding::EmptyPayload,
1860 fidl::encoding::DefaultFuchsiaResourceDialect
1861 );
1862 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1863 let control_handle =
1864 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1865 Ok(WlanFullmacImpl_Request::GetIfaceHistogramStats {
1866 responder: WlanFullmacImpl_GetIfaceHistogramStatsResponder {
1867 control_handle: std::mem::ManuallyDrop::new(control_handle),
1868 tx_id: header.tx_id,
1869 },
1870 })
1871 }
1872 0x72cd3a31ae5a54f6 => {
1873 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1874 let mut req = fidl::new_empty!(
1875 WlanFullmacImplSaeHandshakeRespRequest,
1876 fidl::encoding::DefaultFuchsiaResourceDialect
1877 );
1878 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplSaeHandshakeRespRequest>(&header, _body_bytes, handles, &mut req)?;
1879 let control_handle =
1880 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1881 Ok(WlanFullmacImpl_Request::SaeHandshakeResp {
1882 payload: req,
1883 responder: WlanFullmacImpl_SaeHandshakeRespResponder {
1884 control_handle: std::mem::ManuallyDrop::new(control_handle),
1885 tx_id: header.tx_id,
1886 },
1887 })
1888 }
1889 0x4715ad5dc5a6340f => {
1890 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1891 let mut req = fidl::new_empty!(
1892 WlanFullmacImplSaeFrameTxRequest,
1893 fidl::encoding::DefaultFuchsiaResourceDialect
1894 );
1895 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplSaeFrameTxRequest>(&header, _body_bytes, handles, &mut req)?;
1896 let control_handle =
1897 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1898 Ok(WlanFullmacImpl_Request::SaeFrameTx {
1899 frame: req.frame,
1900
1901 responder: WlanFullmacImpl_SaeFrameTxResponder {
1902 control_handle: std::mem::ManuallyDrop::new(control_handle),
1903 tx_id: header.tx_id,
1904 },
1905 })
1906 }
1907 0x635ecef3beb7a059 => {
1908 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1909 let mut req = fidl::new_empty!(
1910 fidl::encoding::EmptyPayload,
1911 fidl::encoding::DefaultFuchsiaResourceDialect
1912 );
1913 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1914 let control_handle =
1915 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1916 Ok(WlanFullmacImpl_Request::WmmStatusReq {
1917 responder: WlanFullmacImpl_WmmStatusReqResponder {
1918 control_handle: std::mem::ManuallyDrop::new(control_handle),
1919 tx_id: header.tx_id,
1920 },
1921 })
1922 }
1923 0x4d896e5b68e488d7 => {
1924 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1925 let mut req = fidl::new_empty!(
1926 WlanFullmacImplOnLinkStateChangedRequest,
1927 fidl::encoding::DefaultFuchsiaResourceDialect
1928 );
1929 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplOnLinkStateChangedRequest>(&header, _body_bytes, handles, &mut req)?;
1930 let control_handle =
1931 WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1932 Ok(WlanFullmacImpl_Request::OnLinkStateChanged {
1933 payload: req,
1934 responder: WlanFullmacImpl_OnLinkStateChangedResponder {
1935 control_handle: std::mem::ManuallyDrop::new(control_handle),
1936 tx_id: header.tx_id,
1937 },
1938 })
1939 }
1940 _ => Err(fidl::Error::UnknownOrdinal {
1941 ordinal: header.ordinal,
1942 protocol_name:
1943 <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1944 }),
1945 }))
1946 },
1947 )
1948 }
1949}
1950
1951#[derive(Debug)]
1954pub enum WlanFullmacImpl_Request {
1955 Init {
1971 payload: WlanFullmacImplInitRequest,
1972 responder: WlanFullmacImpl_InitResponder,
1973 },
1974 Query {
1977 responder: WlanFullmacImpl_QueryResponder,
1978 },
1979 QueryMacSublayerSupport {
1980 responder: WlanFullmacImpl_QueryMacSublayerSupportResponder,
1981 },
1982 QuerySecuritySupport {
1983 responder: WlanFullmacImpl_QuerySecuritySupportResponder,
1984 },
1985 QuerySpectrumManagementSupport {
1986 responder: WlanFullmacImpl_QuerySpectrumManagementSupportResponder,
1987 },
1988 QueryTelemetrySupport {
1989 responder: WlanFullmacImpl_QueryTelemetrySupportResponder,
1990 },
1991 StartScan {
1992 payload: WlanFullmacImplStartScanRequest,
1993 responder: WlanFullmacImpl_StartScanResponder,
1994 },
1995 Connect {
1996 payload: WlanFullmacImplConnectRequest,
1997 responder: WlanFullmacImpl_ConnectResponder,
1998 },
1999 Reconnect {
2000 payload: WlanFullmacImplReconnectRequest,
2001 responder: WlanFullmacImpl_ReconnectResponder,
2002 },
2003 Roam {
2005 payload: WlanFullmacImplRoamRequest,
2006 responder: WlanFullmacImpl_RoamResponder,
2007 },
2008 AuthResp {
2009 payload: WlanFullmacImplAuthRespRequest,
2010 responder: WlanFullmacImpl_AuthRespResponder,
2011 },
2012 Deauth {
2013 payload: WlanFullmacImplDeauthRequest,
2014 responder: WlanFullmacImpl_DeauthResponder,
2015 },
2016 AssocResp {
2017 payload: WlanFullmacImplAssocRespRequest,
2018 responder: WlanFullmacImpl_AssocRespResponder,
2019 },
2020 Disassoc {
2021 payload: WlanFullmacImplDisassocRequest,
2022 responder: WlanFullmacImpl_DisassocResponder,
2023 },
2024 StartBss {
2025 payload: WlanFullmacImplStartBssRequest,
2026 responder: WlanFullmacImpl_StartBssResponder,
2027 },
2028 StopBss {
2029 payload: WlanFullmacImplStopBssRequest,
2030 responder: WlanFullmacImpl_StopBssResponder,
2031 },
2032 SetKeys {
2038 payload: WlanFullmacImplSetKeysRequest,
2039 responder: WlanFullmacImpl_SetKeysResponder,
2040 },
2041 EapolTx {
2042 payload: WlanFullmacImplEapolTxRequest,
2043 responder: WlanFullmacImpl_EapolTxResponder,
2044 },
2045 GetIfaceCounterStats {
2046 responder: WlanFullmacImpl_GetIfaceCounterStatsResponder,
2047 },
2048 GetIfaceHistogramStats {
2049 responder: WlanFullmacImpl_GetIfaceHistogramStatsResponder,
2050 },
2051 SaeHandshakeResp {
2053 payload: WlanFullmacImplSaeHandshakeRespRequest,
2054 responder: WlanFullmacImpl_SaeHandshakeRespResponder,
2055 },
2056 SaeFrameTx {
2058 frame: SaeFrame,
2059 responder: WlanFullmacImpl_SaeFrameTxResponder,
2060 },
2061 WmmStatusReq {
2062 responder: WlanFullmacImpl_WmmStatusReqResponder,
2063 },
2064 OnLinkStateChanged {
2065 payload: WlanFullmacImplOnLinkStateChangedRequest,
2066 responder: WlanFullmacImpl_OnLinkStateChangedResponder,
2067 },
2068}
2069
2070impl WlanFullmacImpl_Request {
2071 #[allow(irrefutable_let_patterns)]
2072 pub fn into_init(self) -> Option<(WlanFullmacImplInitRequest, WlanFullmacImpl_InitResponder)> {
2073 if let WlanFullmacImpl_Request::Init { payload, responder } = self {
2074 Some((payload, responder))
2075 } else {
2076 None
2077 }
2078 }
2079
2080 #[allow(irrefutable_let_patterns)]
2081 pub fn into_query(self) -> Option<(WlanFullmacImpl_QueryResponder)> {
2082 if let WlanFullmacImpl_Request::Query { responder } = self {
2083 Some((responder))
2084 } else {
2085 None
2086 }
2087 }
2088
2089 #[allow(irrefutable_let_patterns)]
2090 pub fn into_query_mac_sublayer_support(
2091 self,
2092 ) -> Option<(WlanFullmacImpl_QueryMacSublayerSupportResponder)> {
2093 if let WlanFullmacImpl_Request::QueryMacSublayerSupport { responder } = self {
2094 Some((responder))
2095 } else {
2096 None
2097 }
2098 }
2099
2100 #[allow(irrefutable_let_patterns)]
2101 pub fn into_query_security_support(
2102 self,
2103 ) -> Option<(WlanFullmacImpl_QuerySecuritySupportResponder)> {
2104 if let WlanFullmacImpl_Request::QuerySecuritySupport { responder } = self {
2105 Some((responder))
2106 } else {
2107 None
2108 }
2109 }
2110
2111 #[allow(irrefutable_let_patterns)]
2112 pub fn into_query_spectrum_management_support(
2113 self,
2114 ) -> Option<(WlanFullmacImpl_QuerySpectrumManagementSupportResponder)> {
2115 if let WlanFullmacImpl_Request::QuerySpectrumManagementSupport { responder } = self {
2116 Some((responder))
2117 } else {
2118 None
2119 }
2120 }
2121
2122 #[allow(irrefutable_let_patterns)]
2123 pub fn into_query_telemetry_support(
2124 self,
2125 ) -> Option<(WlanFullmacImpl_QueryTelemetrySupportResponder)> {
2126 if let WlanFullmacImpl_Request::QueryTelemetrySupport { responder } = self {
2127 Some((responder))
2128 } else {
2129 None
2130 }
2131 }
2132
2133 #[allow(irrefutable_let_patterns)]
2134 pub fn into_start_scan(
2135 self,
2136 ) -> Option<(WlanFullmacImplStartScanRequest, WlanFullmacImpl_StartScanResponder)> {
2137 if let WlanFullmacImpl_Request::StartScan { payload, responder } = self {
2138 Some((payload, responder))
2139 } else {
2140 None
2141 }
2142 }
2143
2144 #[allow(irrefutable_let_patterns)]
2145 pub fn into_connect(
2146 self,
2147 ) -> Option<(WlanFullmacImplConnectRequest, WlanFullmacImpl_ConnectResponder)> {
2148 if let WlanFullmacImpl_Request::Connect { payload, responder } = self {
2149 Some((payload, responder))
2150 } else {
2151 None
2152 }
2153 }
2154
2155 #[allow(irrefutable_let_patterns)]
2156 pub fn into_reconnect(
2157 self,
2158 ) -> Option<(WlanFullmacImplReconnectRequest, WlanFullmacImpl_ReconnectResponder)> {
2159 if let WlanFullmacImpl_Request::Reconnect { payload, responder } = self {
2160 Some((payload, responder))
2161 } else {
2162 None
2163 }
2164 }
2165
2166 #[allow(irrefutable_let_patterns)]
2167 pub fn into_roam(self) -> Option<(WlanFullmacImplRoamRequest, WlanFullmacImpl_RoamResponder)> {
2168 if let WlanFullmacImpl_Request::Roam { payload, responder } = self {
2169 Some((payload, responder))
2170 } else {
2171 None
2172 }
2173 }
2174
2175 #[allow(irrefutable_let_patterns)]
2176 pub fn into_auth_resp(
2177 self,
2178 ) -> Option<(WlanFullmacImplAuthRespRequest, WlanFullmacImpl_AuthRespResponder)> {
2179 if let WlanFullmacImpl_Request::AuthResp { payload, responder } = self {
2180 Some((payload, responder))
2181 } else {
2182 None
2183 }
2184 }
2185
2186 #[allow(irrefutable_let_patterns)]
2187 pub fn into_deauth(
2188 self,
2189 ) -> Option<(WlanFullmacImplDeauthRequest, WlanFullmacImpl_DeauthResponder)> {
2190 if let WlanFullmacImpl_Request::Deauth { payload, responder } = self {
2191 Some((payload, responder))
2192 } else {
2193 None
2194 }
2195 }
2196
2197 #[allow(irrefutable_let_patterns)]
2198 pub fn into_assoc_resp(
2199 self,
2200 ) -> Option<(WlanFullmacImplAssocRespRequest, WlanFullmacImpl_AssocRespResponder)> {
2201 if let WlanFullmacImpl_Request::AssocResp { payload, responder } = self {
2202 Some((payload, responder))
2203 } else {
2204 None
2205 }
2206 }
2207
2208 #[allow(irrefutable_let_patterns)]
2209 pub fn into_disassoc(
2210 self,
2211 ) -> Option<(WlanFullmacImplDisassocRequest, WlanFullmacImpl_DisassocResponder)> {
2212 if let WlanFullmacImpl_Request::Disassoc { payload, responder } = self {
2213 Some((payload, responder))
2214 } else {
2215 None
2216 }
2217 }
2218
2219 #[allow(irrefutable_let_patterns)]
2220 pub fn into_start_bss(
2221 self,
2222 ) -> Option<(WlanFullmacImplStartBssRequest, WlanFullmacImpl_StartBssResponder)> {
2223 if let WlanFullmacImpl_Request::StartBss { payload, responder } = self {
2224 Some((payload, responder))
2225 } else {
2226 None
2227 }
2228 }
2229
2230 #[allow(irrefutable_let_patterns)]
2231 pub fn into_stop_bss(
2232 self,
2233 ) -> Option<(WlanFullmacImplStopBssRequest, WlanFullmacImpl_StopBssResponder)> {
2234 if let WlanFullmacImpl_Request::StopBss { payload, responder } = self {
2235 Some((payload, responder))
2236 } else {
2237 None
2238 }
2239 }
2240
2241 #[allow(irrefutable_let_patterns)]
2242 pub fn into_set_keys(
2243 self,
2244 ) -> Option<(WlanFullmacImplSetKeysRequest, WlanFullmacImpl_SetKeysResponder)> {
2245 if let WlanFullmacImpl_Request::SetKeys { payload, responder } = self {
2246 Some((payload, responder))
2247 } else {
2248 None
2249 }
2250 }
2251
2252 #[allow(irrefutable_let_patterns)]
2253 pub fn into_eapol_tx(
2254 self,
2255 ) -> Option<(WlanFullmacImplEapolTxRequest, WlanFullmacImpl_EapolTxResponder)> {
2256 if let WlanFullmacImpl_Request::EapolTx { payload, responder } = self {
2257 Some((payload, responder))
2258 } else {
2259 None
2260 }
2261 }
2262
2263 #[allow(irrefutable_let_patterns)]
2264 pub fn into_get_iface_counter_stats(
2265 self,
2266 ) -> Option<(WlanFullmacImpl_GetIfaceCounterStatsResponder)> {
2267 if let WlanFullmacImpl_Request::GetIfaceCounterStats { responder } = self {
2268 Some((responder))
2269 } else {
2270 None
2271 }
2272 }
2273
2274 #[allow(irrefutable_let_patterns)]
2275 pub fn into_get_iface_histogram_stats(
2276 self,
2277 ) -> Option<(WlanFullmacImpl_GetIfaceHistogramStatsResponder)> {
2278 if let WlanFullmacImpl_Request::GetIfaceHistogramStats { responder } = self {
2279 Some((responder))
2280 } else {
2281 None
2282 }
2283 }
2284
2285 #[allow(irrefutable_let_patterns)]
2286 pub fn into_sae_handshake_resp(
2287 self,
2288 ) -> Option<(WlanFullmacImplSaeHandshakeRespRequest, WlanFullmacImpl_SaeHandshakeRespResponder)>
2289 {
2290 if let WlanFullmacImpl_Request::SaeHandshakeResp { payload, responder } = self {
2291 Some((payload, responder))
2292 } else {
2293 None
2294 }
2295 }
2296
2297 #[allow(irrefutable_let_patterns)]
2298 pub fn into_sae_frame_tx(self) -> Option<(SaeFrame, WlanFullmacImpl_SaeFrameTxResponder)> {
2299 if let WlanFullmacImpl_Request::SaeFrameTx { frame, responder } = self {
2300 Some((frame, responder))
2301 } else {
2302 None
2303 }
2304 }
2305
2306 #[allow(irrefutable_let_patterns)]
2307 pub fn into_wmm_status_req(self) -> Option<(WlanFullmacImpl_WmmStatusReqResponder)> {
2308 if let WlanFullmacImpl_Request::WmmStatusReq { responder } = self {
2309 Some((responder))
2310 } else {
2311 None
2312 }
2313 }
2314
2315 #[allow(irrefutable_let_patterns)]
2316 pub fn into_on_link_state_changed(
2317 self,
2318 ) -> Option<(
2319 WlanFullmacImplOnLinkStateChangedRequest,
2320 WlanFullmacImpl_OnLinkStateChangedResponder,
2321 )> {
2322 if let WlanFullmacImpl_Request::OnLinkStateChanged { payload, responder } = self {
2323 Some((payload, responder))
2324 } else {
2325 None
2326 }
2327 }
2328
2329 pub fn method_name(&self) -> &'static str {
2331 match *self {
2332 WlanFullmacImpl_Request::Init { .. } => "init",
2333 WlanFullmacImpl_Request::Query { .. } => "query",
2334 WlanFullmacImpl_Request::QueryMacSublayerSupport { .. } => "query_mac_sublayer_support",
2335 WlanFullmacImpl_Request::QuerySecuritySupport { .. } => "query_security_support",
2336 WlanFullmacImpl_Request::QuerySpectrumManagementSupport { .. } => {
2337 "query_spectrum_management_support"
2338 }
2339 WlanFullmacImpl_Request::QueryTelemetrySupport { .. } => "query_telemetry_support",
2340 WlanFullmacImpl_Request::StartScan { .. } => "start_scan",
2341 WlanFullmacImpl_Request::Connect { .. } => "connect",
2342 WlanFullmacImpl_Request::Reconnect { .. } => "reconnect",
2343 WlanFullmacImpl_Request::Roam { .. } => "roam",
2344 WlanFullmacImpl_Request::AuthResp { .. } => "auth_resp",
2345 WlanFullmacImpl_Request::Deauth { .. } => "deauth",
2346 WlanFullmacImpl_Request::AssocResp { .. } => "assoc_resp",
2347 WlanFullmacImpl_Request::Disassoc { .. } => "disassoc",
2348 WlanFullmacImpl_Request::StartBss { .. } => "start_bss",
2349 WlanFullmacImpl_Request::StopBss { .. } => "stop_bss",
2350 WlanFullmacImpl_Request::SetKeys { .. } => "set_keys",
2351 WlanFullmacImpl_Request::EapolTx { .. } => "eapol_tx",
2352 WlanFullmacImpl_Request::GetIfaceCounterStats { .. } => "get_iface_counter_stats",
2353 WlanFullmacImpl_Request::GetIfaceHistogramStats { .. } => "get_iface_histogram_stats",
2354 WlanFullmacImpl_Request::SaeHandshakeResp { .. } => "sae_handshake_resp",
2355 WlanFullmacImpl_Request::SaeFrameTx { .. } => "sae_frame_tx",
2356 WlanFullmacImpl_Request::WmmStatusReq { .. } => "wmm_status_req",
2357 WlanFullmacImpl_Request::OnLinkStateChanged { .. } => "on_link_state_changed",
2358 }
2359 }
2360}
2361
2362#[derive(Debug, Clone)]
2363pub struct WlanFullmacImpl_ControlHandle {
2364 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2365}
2366
2367impl fidl::endpoints::ControlHandle for WlanFullmacImpl_ControlHandle {
2368 fn shutdown(&self) {
2369 self.inner.shutdown()
2370 }
2371 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
2372 self.inner.shutdown_with_epitaph(status)
2373 }
2374
2375 fn is_closed(&self) -> bool {
2376 self.inner.channel().is_closed()
2377 }
2378 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2379 self.inner.channel().on_closed()
2380 }
2381
2382 #[cfg(target_os = "fuchsia")]
2383 fn signal_peer(
2384 &self,
2385 clear_mask: zx::Signals,
2386 set_mask: zx::Signals,
2387 ) -> Result<(), zx_status::Status> {
2388 use fidl::Peered;
2389 self.inner.channel().signal_peer(clear_mask, set_mask)
2390 }
2391}
2392
2393impl WlanFullmacImpl_ControlHandle {}
2394
2395#[must_use = "FIDL methods require a response to be sent"]
2396#[derive(Debug)]
2397pub struct WlanFullmacImpl_InitResponder {
2398 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2399 tx_id: u32,
2400}
2401
2402impl std::ops::Drop for WlanFullmacImpl_InitResponder {
2406 fn drop(&mut self) {
2407 self.control_handle.shutdown();
2408 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2410 }
2411}
2412
2413impl fidl::endpoints::Responder for WlanFullmacImpl_InitResponder {
2414 type ControlHandle = WlanFullmacImpl_ControlHandle;
2415
2416 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2417 &self.control_handle
2418 }
2419
2420 fn drop_without_shutdown(mut self) {
2421 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2423 std::mem::forget(self);
2425 }
2426}
2427
2428impl WlanFullmacImpl_InitResponder {
2429 pub fn send(
2433 self,
2434 mut result: Result<WlanFullmacImplInitResponse, i32>,
2435 ) -> Result<(), fidl::Error> {
2436 let _result = self.send_raw(result);
2437 if _result.is_err() {
2438 self.control_handle.shutdown();
2439 }
2440 self.drop_without_shutdown();
2441 _result
2442 }
2443
2444 pub fn send_no_shutdown_on_err(
2446 self,
2447 mut result: Result<WlanFullmacImplInitResponse, i32>,
2448 ) -> Result<(), fidl::Error> {
2449 let _result = self.send_raw(result);
2450 self.drop_without_shutdown();
2451 _result
2452 }
2453
2454 fn send_raw(
2455 &self,
2456 mut result: Result<WlanFullmacImplInitResponse, i32>,
2457 ) -> Result<(), fidl::Error> {
2458 self.control_handle
2459 .inner
2460 .send::<fidl::encoding::ResultType<WlanFullmacImplInitResponse, i32>>(
2461 result.as_mut().map_err(|e| *e),
2462 self.tx_id,
2463 0x593dfb6cb3f0f1aa,
2464 fidl::encoding::DynamicFlags::empty(),
2465 )
2466 }
2467}
2468
2469#[must_use = "FIDL methods require a response to be sent"]
2470#[derive(Debug)]
2471pub struct WlanFullmacImpl_QueryResponder {
2472 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2473 tx_id: u32,
2474}
2475
2476impl std::ops::Drop for WlanFullmacImpl_QueryResponder {
2480 fn drop(&mut self) {
2481 self.control_handle.shutdown();
2482 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2484 }
2485}
2486
2487impl fidl::endpoints::Responder for WlanFullmacImpl_QueryResponder {
2488 type ControlHandle = WlanFullmacImpl_ControlHandle;
2489
2490 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2491 &self.control_handle
2492 }
2493
2494 fn drop_without_shutdown(mut self) {
2495 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2497 std::mem::forget(self);
2499 }
2500}
2501
2502impl WlanFullmacImpl_QueryResponder {
2503 pub fn send(
2507 self,
2508 mut result: Result<&WlanFullmacImplQueryResponse, i32>,
2509 ) -> Result<(), fidl::Error> {
2510 let _result = self.send_raw(result);
2511 if _result.is_err() {
2512 self.control_handle.shutdown();
2513 }
2514 self.drop_without_shutdown();
2515 _result
2516 }
2517
2518 pub fn send_no_shutdown_on_err(
2520 self,
2521 mut result: Result<&WlanFullmacImplQueryResponse, i32>,
2522 ) -> Result<(), fidl::Error> {
2523 let _result = self.send_raw(result);
2524 self.drop_without_shutdown();
2525 _result
2526 }
2527
2528 fn send_raw(
2529 &self,
2530 mut result: Result<&WlanFullmacImplQueryResponse, i32>,
2531 ) -> Result<(), fidl::Error> {
2532 self.control_handle
2533 .inner
2534 .send::<fidl::encoding::ResultType<WlanFullmacImplQueryResponse, i32>>(
2535 result,
2536 self.tx_id,
2537 0x28ac65f9da3941d4,
2538 fidl::encoding::DynamicFlags::empty(),
2539 )
2540 }
2541}
2542
2543#[must_use = "FIDL methods require a response to be sent"]
2544#[derive(Debug)]
2545pub struct WlanFullmacImpl_QueryMacSublayerSupportResponder {
2546 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2547 tx_id: u32,
2548}
2549
2550impl std::ops::Drop for WlanFullmacImpl_QueryMacSublayerSupportResponder {
2554 fn drop(&mut self) {
2555 self.control_handle.shutdown();
2556 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2558 }
2559}
2560
2561impl fidl::endpoints::Responder for WlanFullmacImpl_QueryMacSublayerSupportResponder {
2562 type ControlHandle = WlanFullmacImpl_ControlHandle;
2563
2564 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2565 &self.control_handle
2566 }
2567
2568 fn drop_without_shutdown(mut self) {
2569 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2571 std::mem::forget(self);
2573 }
2574}
2575
2576impl WlanFullmacImpl_QueryMacSublayerSupportResponder {
2577 pub fn send(
2581 self,
2582 mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
2583 ) -> Result<(), fidl::Error> {
2584 let _result = self.send_raw(result);
2585 if _result.is_err() {
2586 self.control_handle.shutdown();
2587 }
2588 self.drop_without_shutdown();
2589 _result
2590 }
2591
2592 pub fn send_no_shutdown_on_err(
2594 self,
2595 mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
2596 ) -> Result<(), fidl::Error> {
2597 let _result = self.send_raw(result);
2598 self.drop_without_shutdown();
2599 _result
2600 }
2601
2602 fn send_raw(
2603 &self,
2604 mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
2605 ) -> Result<(), fidl::Error> {
2606 self.control_handle.inner.send::<fidl::encoding::ResultType<
2607 WlanFullmacImplQueryMacSublayerSupportResponse,
2608 i32,
2609 >>(
2610 result.map(|resp| (resp,)),
2611 self.tx_id,
2612 0x2f09187eb87d9bad,
2613 fidl::encoding::DynamicFlags::empty(),
2614 )
2615 }
2616}
2617
2618#[must_use = "FIDL methods require a response to be sent"]
2619#[derive(Debug)]
2620pub struct WlanFullmacImpl_QuerySecuritySupportResponder {
2621 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2622 tx_id: u32,
2623}
2624
2625impl std::ops::Drop for WlanFullmacImpl_QuerySecuritySupportResponder {
2629 fn drop(&mut self) {
2630 self.control_handle.shutdown();
2631 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2633 }
2634}
2635
2636impl fidl::endpoints::Responder for WlanFullmacImpl_QuerySecuritySupportResponder {
2637 type ControlHandle = WlanFullmacImpl_ControlHandle;
2638
2639 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2640 &self.control_handle
2641 }
2642
2643 fn drop_without_shutdown(mut self) {
2644 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2646 std::mem::forget(self);
2648 }
2649}
2650
2651impl WlanFullmacImpl_QuerySecuritySupportResponder {
2652 pub fn send(
2656 self,
2657 mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
2658 ) -> Result<(), fidl::Error> {
2659 let _result = self.send_raw(result);
2660 if _result.is_err() {
2661 self.control_handle.shutdown();
2662 }
2663 self.drop_without_shutdown();
2664 _result
2665 }
2666
2667 pub fn send_no_shutdown_on_err(
2669 self,
2670 mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
2671 ) -> Result<(), fidl::Error> {
2672 let _result = self.send_raw(result);
2673 self.drop_without_shutdown();
2674 _result
2675 }
2676
2677 fn send_raw(
2678 &self,
2679 mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
2680 ) -> Result<(), fidl::Error> {
2681 self.control_handle.inner.send::<fidl::encoding::ResultType<
2682 WlanFullmacImplQuerySecuritySupportResponse,
2683 i32,
2684 >>(
2685 result.map(|resp| (resp,)),
2686 self.tx_id,
2687 0x11cf3fa6eeb93f84,
2688 fidl::encoding::DynamicFlags::empty(),
2689 )
2690 }
2691}
2692
2693#[must_use = "FIDL methods require a response to be sent"]
2694#[derive(Debug)]
2695pub struct WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2696 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2697 tx_id: u32,
2698}
2699
2700impl std::ops::Drop for WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2704 fn drop(&mut self) {
2705 self.control_handle.shutdown();
2706 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2708 }
2709}
2710
2711impl fidl::endpoints::Responder for WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2712 type ControlHandle = WlanFullmacImpl_ControlHandle;
2713
2714 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2715 &self.control_handle
2716 }
2717
2718 fn drop_without_shutdown(mut self) {
2719 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2721 std::mem::forget(self);
2723 }
2724}
2725
2726impl WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2727 pub fn send(
2731 self,
2732 mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
2733 ) -> Result<(), fidl::Error> {
2734 let _result = self.send_raw(result);
2735 if _result.is_err() {
2736 self.control_handle.shutdown();
2737 }
2738 self.drop_without_shutdown();
2739 _result
2740 }
2741
2742 pub fn send_no_shutdown_on_err(
2744 self,
2745 mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
2746 ) -> Result<(), fidl::Error> {
2747 let _result = self.send_raw(result);
2748 self.drop_without_shutdown();
2749 _result
2750 }
2751
2752 fn send_raw(
2753 &self,
2754 mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
2755 ) -> Result<(), fidl::Error> {
2756 self.control_handle.inner.send::<fidl::encoding::ResultType<
2757 WlanFullmacImplQuerySpectrumManagementSupportResponse,
2758 i32,
2759 >>(
2760 result.map(|resp| (resp,)),
2761 self.tx_id,
2762 0x22ae7551d855b83a,
2763 fidl::encoding::DynamicFlags::empty(),
2764 )
2765 }
2766}
2767
2768#[must_use = "FIDL methods require a response to be sent"]
2769#[derive(Debug)]
2770pub struct WlanFullmacImpl_QueryTelemetrySupportResponder {
2771 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2772 tx_id: u32,
2773}
2774
2775impl std::ops::Drop for WlanFullmacImpl_QueryTelemetrySupportResponder {
2779 fn drop(&mut self) {
2780 self.control_handle.shutdown();
2781 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2783 }
2784}
2785
2786impl fidl::endpoints::Responder for WlanFullmacImpl_QueryTelemetrySupportResponder {
2787 type ControlHandle = WlanFullmacImpl_ControlHandle;
2788
2789 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2790 &self.control_handle
2791 }
2792
2793 fn drop_without_shutdown(mut self) {
2794 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2796 std::mem::forget(self);
2798 }
2799}
2800
2801impl WlanFullmacImpl_QueryTelemetrySupportResponder {
2802 pub fn send(
2806 self,
2807 mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
2808 ) -> Result<(), fidl::Error> {
2809 let _result = self.send_raw(result);
2810 if _result.is_err() {
2811 self.control_handle.shutdown();
2812 }
2813 self.drop_without_shutdown();
2814 _result
2815 }
2816
2817 pub fn send_no_shutdown_on_err(
2819 self,
2820 mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
2821 ) -> Result<(), fidl::Error> {
2822 let _result = self.send_raw(result);
2823 self.drop_without_shutdown();
2824 _result
2825 }
2826
2827 fn send_raw(
2828 &self,
2829 mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
2830 ) -> Result<(), fidl::Error> {
2831 self.control_handle.inner.send::<fidl::encoding::ResultType<
2832 WlanFullmacImplQueryTelemetrySupportResponse,
2833 i32,
2834 >>(
2835 result.map(|resp| (resp,)),
2836 self.tx_id,
2837 0x4561479ca560827f,
2838 fidl::encoding::DynamicFlags::empty(),
2839 )
2840 }
2841}
2842
2843#[must_use = "FIDL methods require a response to be sent"]
2844#[derive(Debug)]
2845pub struct WlanFullmacImpl_StartScanResponder {
2846 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2847 tx_id: u32,
2848}
2849
2850impl std::ops::Drop for WlanFullmacImpl_StartScanResponder {
2854 fn drop(&mut self) {
2855 self.control_handle.shutdown();
2856 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2858 }
2859}
2860
2861impl fidl::endpoints::Responder for WlanFullmacImpl_StartScanResponder {
2862 type ControlHandle = WlanFullmacImpl_ControlHandle;
2863
2864 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2865 &self.control_handle
2866 }
2867
2868 fn drop_without_shutdown(mut self) {
2869 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2871 std::mem::forget(self);
2873 }
2874}
2875
2876impl WlanFullmacImpl_StartScanResponder {
2877 pub fn send(self) -> Result<(), fidl::Error> {
2881 let _result = self.send_raw();
2882 if _result.is_err() {
2883 self.control_handle.shutdown();
2884 }
2885 self.drop_without_shutdown();
2886 _result
2887 }
2888
2889 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
2891 let _result = self.send_raw();
2892 self.drop_without_shutdown();
2893 _result
2894 }
2895
2896 fn send_raw(&self) -> Result<(), fidl::Error> {
2897 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
2898 (),
2899 self.tx_id,
2900 0x26c17bf595aa161c,
2901 fidl::encoding::DynamicFlags::empty(),
2902 )
2903 }
2904}
2905
2906#[must_use = "FIDL methods require a response to be sent"]
2907#[derive(Debug)]
2908pub struct WlanFullmacImpl_ConnectResponder {
2909 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2910 tx_id: u32,
2911}
2912
2913impl std::ops::Drop for WlanFullmacImpl_ConnectResponder {
2917 fn drop(&mut self) {
2918 self.control_handle.shutdown();
2919 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2921 }
2922}
2923
2924impl fidl::endpoints::Responder for WlanFullmacImpl_ConnectResponder {
2925 type ControlHandle = WlanFullmacImpl_ControlHandle;
2926
2927 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2928 &self.control_handle
2929 }
2930
2931 fn drop_without_shutdown(mut self) {
2932 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2934 std::mem::forget(self);
2936 }
2937}
2938
2939impl WlanFullmacImpl_ConnectResponder {
2940 pub fn send(self) -> Result<(), fidl::Error> {
2944 let _result = self.send_raw();
2945 if _result.is_err() {
2946 self.control_handle.shutdown();
2947 }
2948 self.drop_without_shutdown();
2949 _result
2950 }
2951
2952 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
2954 let _result = self.send_raw();
2955 self.drop_without_shutdown();
2956 _result
2957 }
2958
2959 fn send_raw(&self) -> Result<(), fidl::Error> {
2960 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
2961 (),
2962 self.tx_id,
2963 0x19eb0322efb07a76,
2964 fidl::encoding::DynamicFlags::empty(),
2965 )
2966 }
2967}
2968
2969#[must_use = "FIDL methods require a response to be sent"]
2970#[derive(Debug)]
2971pub struct WlanFullmacImpl_ReconnectResponder {
2972 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2973 tx_id: u32,
2974}
2975
2976impl std::ops::Drop for WlanFullmacImpl_ReconnectResponder {
2980 fn drop(&mut self) {
2981 self.control_handle.shutdown();
2982 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2984 }
2985}
2986
2987impl fidl::endpoints::Responder for WlanFullmacImpl_ReconnectResponder {
2988 type ControlHandle = WlanFullmacImpl_ControlHandle;
2989
2990 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2991 &self.control_handle
2992 }
2993
2994 fn drop_without_shutdown(mut self) {
2995 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2997 std::mem::forget(self);
2999 }
3000}
3001
3002impl WlanFullmacImpl_ReconnectResponder {
3003 pub fn send(self) -> Result<(), fidl::Error> {
3007 let _result = self.send_raw();
3008 if _result.is_err() {
3009 self.control_handle.shutdown();
3010 }
3011 self.drop_without_shutdown();
3012 _result
3013 }
3014
3015 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3017 let _result = self.send_raw();
3018 self.drop_without_shutdown();
3019 _result
3020 }
3021
3022 fn send_raw(&self) -> Result<(), fidl::Error> {
3023 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3024 (),
3025 self.tx_id,
3026 0x474084c4ef19ee71,
3027 fidl::encoding::DynamicFlags::empty(),
3028 )
3029 }
3030}
3031
3032#[must_use = "FIDL methods require a response to be sent"]
3033#[derive(Debug)]
3034pub struct WlanFullmacImpl_RoamResponder {
3035 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3036 tx_id: u32,
3037}
3038
3039impl std::ops::Drop for WlanFullmacImpl_RoamResponder {
3043 fn drop(&mut self) {
3044 self.control_handle.shutdown();
3045 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3047 }
3048}
3049
3050impl fidl::endpoints::Responder for WlanFullmacImpl_RoamResponder {
3051 type ControlHandle = WlanFullmacImpl_ControlHandle;
3052
3053 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3054 &self.control_handle
3055 }
3056
3057 fn drop_without_shutdown(mut self) {
3058 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3060 std::mem::forget(self);
3062 }
3063}
3064
3065impl WlanFullmacImpl_RoamResponder {
3066 pub fn send(self) -> Result<(), fidl::Error> {
3070 let _result = self.send_raw();
3071 if _result.is_err() {
3072 self.control_handle.shutdown();
3073 }
3074 self.drop_without_shutdown();
3075 _result
3076 }
3077
3078 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3080 let _result = self.send_raw();
3081 self.drop_without_shutdown();
3082 _result
3083 }
3084
3085 fn send_raw(&self) -> Result<(), fidl::Error> {
3086 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3087 (),
3088 self.tx_id,
3089 0x1e35dcc98b124b64,
3090 fidl::encoding::DynamicFlags::empty(),
3091 )
3092 }
3093}
3094
3095#[must_use = "FIDL methods require a response to be sent"]
3096#[derive(Debug)]
3097pub struct WlanFullmacImpl_AuthRespResponder {
3098 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3099 tx_id: u32,
3100}
3101
3102impl std::ops::Drop for WlanFullmacImpl_AuthRespResponder {
3106 fn drop(&mut self) {
3107 self.control_handle.shutdown();
3108 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3110 }
3111}
3112
3113impl fidl::endpoints::Responder for WlanFullmacImpl_AuthRespResponder {
3114 type ControlHandle = WlanFullmacImpl_ControlHandle;
3115
3116 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3117 &self.control_handle
3118 }
3119
3120 fn drop_without_shutdown(mut self) {
3121 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3123 std::mem::forget(self);
3125 }
3126}
3127
3128impl WlanFullmacImpl_AuthRespResponder {
3129 pub fn send(self) -> Result<(), fidl::Error> {
3133 let _result = self.send_raw();
3134 if _result.is_err() {
3135 self.control_handle.shutdown();
3136 }
3137 self.drop_without_shutdown();
3138 _result
3139 }
3140
3141 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3143 let _result = self.send_raw();
3144 self.drop_without_shutdown();
3145 _result
3146 }
3147
3148 fn send_raw(&self) -> Result<(), fidl::Error> {
3149 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3150 (),
3151 self.tx_id,
3152 0x5f7ea24b44a4aaeb,
3153 fidl::encoding::DynamicFlags::empty(),
3154 )
3155 }
3156}
3157
3158#[must_use = "FIDL methods require a response to be sent"]
3159#[derive(Debug)]
3160pub struct WlanFullmacImpl_DeauthResponder {
3161 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3162 tx_id: u32,
3163}
3164
3165impl std::ops::Drop for WlanFullmacImpl_DeauthResponder {
3169 fn drop(&mut self) {
3170 self.control_handle.shutdown();
3171 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3173 }
3174}
3175
3176impl fidl::endpoints::Responder for WlanFullmacImpl_DeauthResponder {
3177 type ControlHandle = WlanFullmacImpl_ControlHandle;
3178
3179 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3180 &self.control_handle
3181 }
3182
3183 fn drop_without_shutdown(mut self) {
3184 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3186 std::mem::forget(self);
3188 }
3189}
3190
3191impl WlanFullmacImpl_DeauthResponder {
3192 pub fn send(self) -> Result<(), fidl::Error> {
3196 let _result = self.send_raw();
3197 if _result.is_err() {
3198 self.control_handle.shutdown();
3199 }
3200 self.drop_without_shutdown();
3201 _result
3202 }
3203
3204 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3206 let _result = self.send_raw();
3207 self.drop_without_shutdown();
3208 _result
3209 }
3210
3211 fn send_raw(&self) -> Result<(), fidl::Error> {
3212 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3213 (),
3214 self.tx_id,
3215 0x112786eccbf12f37,
3216 fidl::encoding::DynamicFlags::empty(),
3217 )
3218 }
3219}
3220
3221#[must_use = "FIDL methods require a response to be sent"]
3222#[derive(Debug)]
3223pub struct WlanFullmacImpl_AssocRespResponder {
3224 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3225 tx_id: u32,
3226}
3227
3228impl std::ops::Drop for WlanFullmacImpl_AssocRespResponder {
3232 fn drop(&mut self) {
3233 self.control_handle.shutdown();
3234 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3236 }
3237}
3238
3239impl fidl::endpoints::Responder for WlanFullmacImpl_AssocRespResponder {
3240 type ControlHandle = WlanFullmacImpl_ControlHandle;
3241
3242 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3243 &self.control_handle
3244 }
3245
3246 fn drop_without_shutdown(mut self) {
3247 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3249 std::mem::forget(self);
3251 }
3252}
3253
3254impl WlanFullmacImpl_AssocRespResponder {
3255 pub fn send(self) -> Result<(), fidl::Error> {
3259 let _result = self.send_raw();
3260 if _result.is_err() {
3261 self.control_handle.shutdown();
3262 }
3263 self.drop_without_shutdown();
3264 _result
3265 }
3266
3267 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3269 let _result = self.send_raw();
3270 self.drop_without_shutdown();
3271 _result
3272 }
3273
3274 fn send_raw(&self) -> Result<(), fidl::Error> {
3275 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3276 (),
3277 self.tx_id,
3278 0x5022ce6b8eefec2f,
3279 fidl::encoding::DynamicFlags::empty(),
3280 )
3281 }
3282}
3283
3284#[must_use = "FIDL methods require a response to be sent"]
3285#[derive(Debug)]
3286pub struct WlanFullmacImpl_DisassocResponder {
3287 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3288 tx_id: u32,
3289}
3290
3291impl std::ops::Drop for WlanFullmacImpl_DisassocResponder {
3295 fn drop(&mut self) {
3296 self.control_handle.shutdown();
3297 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3299 }
3300}
3301
3302impl fidl::endpoints::Responder for WlanFullmacImpl_DisassocResponder {
3303 type ControlHandle = WlanFullmacImpl_ControlHandle;
3304
3305 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3306 &self.control_handle
3307 }
3308
3309 fn drop_without_shutdown(mut self) {
3310 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3312 std::mem::forget(self);
3314 }
3315}
3316
3317impl WlanFullmacImpl_DisassocResponder {
3318 pub fn send(self) -> Result<(), fidl::Error> {
3322 let _result = self.send_raw();
3323 if _result.is_err() {
3324 self.control_handle.shutdown();
3325 }
3326 self.drop_without_shutdown();
3327 _result
3328 }
3329
3330 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3332 let _result = self.send_raw();
3333 self.drop_without_shutdown();
3334 _result
3335 }
3336
3337 fn send_raw(&self) -> Result<(), fidl::Error> {
3338 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3339 (),
3340 self.tx_id,
3341 0x9c0fc4e8de53e01,
3342 fidl::encoding::DynamicFlags::empty(),
3343 )
3344 }
3345}
3346
3347#[must_use = "FIDL methods require a response to be sent"]
3348#[derive(Debug)]
3349pub struct WlanFullmacImpl_StartBssResponder {
3350 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3351 tx_id: u32,
3352}
3353
3354impl std::ops::Drop for WlanFullmacImpl_StartBssResponder {
3358 fn drop(&mut self) {
3359 self.control_handle.shutdown();
3360 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3362 }
3363}
3364
3365impl fidl::endpoints::Responder for WlanFullmacImpl_StartBssResponder {
3366 type ControlHandle = WlanFullmacImpl_ControlHandle;
3367
3368 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3369 &self.control_handle
3370 }
3371
3372 fn drop_without_shutdown(mut self) {
3373 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3375 std::mem::forget(self);
3377 }
3378}
3379
3380impl WlanFullmacImpl_StartBssResponder {
3381 pub fn send(self) -> Result<(), fidl::Error> {
3385 let _result = self.send_raw();
3386 if _result.is_err() {
3387 self.control_handle.shutdown();
3388 }
3389 self.drop_without_shutdown();
3390 _result
3391 }
3392
3393 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3395 let _result = self.send_raw();
3396 self.drop_without_shutdown();
3397 _result
3398 }
3399
3400 fn send_raw(&self) -> Result<(), fidl::Error> {
3401 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3402 (),
3403 self.tx_id,
3404 0x6922644d6b1d341d,
3405 fidl::encoding::DynamicFlags::empty(),
3406 )
3407 }
3408}
3409
3410#[must_use = "FIDL methods require a response to be sent"]
3411#[derive(Debug)]
3412pub struct WlanFullmacImpl_StopBssResponder {
3413 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3414 tx_id: u32,
3415}
3416
3417impl std::ops::Drop for WlanFullmacImpl_StopBssResponder {
3421 fn drop(&mut self) {
3422 self.control_handle.shutdown();
3423 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3425 }
3426}
3427
3428impl fidl::endpoints::Responder for WlanFullmacImpl_StopBssResponder {
3429 type ControlHandle = WlanFullmacImpl_ControlHandle;
3430
3431 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3432 &self.control_handle
3433 }
3434
3435 fn drop_without_shutdown(mut self) {
3436 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3438 std::mem::forget(self);
3440 }
3441}
3442
3443impl WlanFullmacImpl_StopBssResponder {
3444 pub fn send(self) -> Result<(), fidl::Error> {
3448 let _result = self.send_raw();
3449 if _result.is_err() {
3450 self.control_handle.shutdown();
3451 }
3452 self.drop_without_shutdown();
3453 _result
3454 }
3455
3456 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3458 let _result = self.send_raw();
3459 self.drop_without_shutdown();
3460 _result
3461 }
3462
3463 fn send_raw(&self) -> Result<(), fidl::Error> {
3464 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3465 (),
3466 self.tx_id,
3467 0x5aeb9b72e7575268,
3468 fidl::encoding::DynamicFlags::empty(),
3469 )
3470 }
3471}
3472
3473#[must_use = "FIDL methods require a response to be sent"]
3474#[derive(Debug)]
3475pub struct WlanFullmacImpl_SetKeysResponder {
3476 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3477 tx_id: u32,
3478}
3479
3480impl std::ops::Drop for WlanFullmacImpl_SetKeysResponder {
3484 fn drop(&mut self) {
3485 self.control_handle.shutdown();
3486 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3488 }
3489}
3490
3491impl fidl::endpoints::Responder for WlanFullmacImpl_SetKeysResponder {
3492 type ControlHandle = WlanFullmacImpl_ControlHandle;
3493
3494 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3495 &self.control_handle
3496 }
3497
3498 fn drop_without_shutdown(mut self) {
3499 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3501 std::mem::forget(self);
3503 }
3504}
3505
3506impl WlanFullmacImpl_SetKeysResponder {
3507 pub fn send(self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
3511 let _result = self.send_raw(resp);
3512 if _result.is_err() {
3513 self.control_handle.shutdown();
3514 }
3515 self.drop_without_shutdown();
3516 _result
3517 }
3518
3519 pub fn send_no_shutdown_on_err(
3521 self,
3522 mut resp: &WlanFullmacSetKeysResp,
3523 ) -> Result<(), fidl::Error> {
3524 let _result = self.send_raw(resp);
3525 self.drop_without_shutdown();
3526 _result
3527 }
3528
3529 fn send_raw(&self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
3530 self.control_handle.inner.send::<WlanFullmacImplSetKeysResponse>(
3531 (resp,),
3532 self.tx_id,
3533 0x20f46b1e039f0985,
3534 fidl::encoding::DynamicFlags::empty(),
3535 )
3536 }
3537}
3538
3539#[must_use = "FIDL methods require a response to be sent"]
3540#[derive(Debug)]
3541pub struct WlanFullmacImpl_EapolTxResponder {
3542 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3543 tx_id: u32,
3544}
3545
3546impl std::ops::Drop for WlanFullmacImpl_EapolTxResponder {
3550 fn drop(&mut self) {
3551 self.control_handle.shutdown();
3552 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3554 }
3555}
3556
3557impl fidl::endpoints::Responder for WlanFullmacImpl_EapolTxResponder {
3558 type ControlHandle = WlanFullmacImpl_ControlHandle;
3559
3560 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3561 &self.control_handle
3562 }
3563
3564 fn drop_without_shutdown(mut self) {
3565 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3567 std::mem::forget(self);
3569 }
3570}
3571
3572impl WlanFullmacImpl_EapolTxResponder {
3573 pub fn send(self) -> Result<(), fidl::Error> {
3577 let _result = self.send_raw();
3578 if _result.is_err() {
3579 self.control_handle.shutdown();
3580 }
3581 self.drop_without_shutdown();
3582 _result
3583 }
3584
3585 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3587 let _result = self.send_raw();
3588 self.drop_without_shutdown();
3589 _result
3590 }
3591
3592 fn send_raw(&self) -> Result<(), fidl::Error> {
3593 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3594 (),
3595 self.tx_id,
3596 0x529a2d90fd4c8177,
3597 fidl::encoding::DynamicFlags::empty(),
3598 )
3599 }
3600}
3601
3602#[must_use = "FIDL methods require a response to be sent"]
3603#[derive(Debug)]
3604pub struct WlanFullmacImpl_GetIfaceCounterStatsResponder {
3605 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3606 tx_id: u32,
3607}
3608
3609impl std::ops::Drop for WlanFullmacImpl_GetIfaceCounterStatsResponder {
3613 fn drop(&mut self) {
3614 self.control_handle.shutdown();
3615 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3617 }
3618}
3619
3620impl fidl::endpoints::Responder for WlanFullmacImpl_GetIfaceCounterStatsResponder {
3621 type ControlHandle = WlanFullmacImpl_ControlHandle;
3622
3623 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3624 &self.control_handle
3625 }
3626
3627 fn drop_without_shutdown(mut self) {
3628 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3630 std::mem::forget(self);
3632 }
3633}
3634
3635impl WlanFullmacImpl_GetIfaceCounterStatsResponder {
3636 pub fn send(
3640 self,
3641 mut result: Result<&fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>,
3642 ) -> Result<(), fidl::Error> {
3643 let _result = self.send_raw(result);
3644 if _result.is_err() {
3645 self.control_handle.shutdown();
3646 }
3647 self.drop_without_shutdown();
3648 _result
3649 }
3650
3651 pub fn send_no_shutdown_on_err(
3653 self,
3654 mut result: Result<&fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>,
3655 ) -> Result<(), fidl::Error> {
3656 let _result = self.send_raw(result);
3657 self.drop_without_shutdown();
3658 _result
3659 }
3660
3661 fn send_raw(
3662 &self,
3663 mut result: Result<&fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>,
3664 ) -> Result<(), fidl::Error> {
3665 self.control_handle.inner.send::<fidl::encoding::ResultType<
3666 WlanFullmacImplGetIfaceCounterStatsResponse,
3667 i32,
3668 >>(
3669 result.map(|stats| (stats,)),
3670 self.tx_id,
3671 0x6b640d6c69c99225,
3672 fidl::encoding::DynamicFlags::empty(),
3673 )
3674 }
3675}
3676
3677#[must_use = "FIDL methods require a response to be sent"]
3678#[derive(Debug)]
3679pub struct WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3680 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3681 tx_id: u32,
3682}
3683
3684impl std::ops::Drop for WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3688 fn drop(&mut self) {
3689 self.control_handle.shutdown();
3690 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3692 }
3693}
3694
3695impl fidl::endpoints::Responder for WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3696 type ControlHandle = WlanFullmacImpl_ControlHandle;
3697
3698 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3699 &self.control_handle
3700 }
3701
3702 fn drop_without_shutdown(mut self) {
3703 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3705 std::mem::forget(self);
3707 }
3708}
3709
3710impl WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3711 pub fn send(
3715 self,
3716 mut result: Result<&fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>,
3717 ) -> Result<(), fidl::Error> {
3718 let _result = self.send_raw(result);
3719 if _result.is_err() {
3720 self.control_handle.shutdown();
3721 }
3722 self.drop_without_shutdown();
3723 _result
3724 }
3725
3726 pub fn send_no_shutdown_on_err(
3728 self,
3729 mut result: Result<&fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>,
3730 ) -> Result<(), fidl::Error> {
3731 let _result = self.send_raw(result);
3732 self.drop_without_shutdown();
3733 _result
3734 }
3735
3736 fn send_raw(
3737 &self,
3738 mut result: Result<&fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>,
3739 ) -> Result<(), fidl::Error> {
3740 self.control_handle.inner.send::<fidl::encoding::ResultType<
3741 WlanFullmacImplGetIfaceHistogramStatsResponse,
3742 i32,
3743 >>(
3744 result.map(|stats| (stats,)),
3745 self.tx_id,
3746 0x503d586f30ccf2cd,
3747 fidl::encoding::DynamicFlags::empty(),
3748 )
3749 }
3750}
3751
3752#[must_use = "FIDL methods require a response to be sent"]
3753#[derive(Debug)]
3754pub struct WlanFullmacImpl_SaeHandshakeRespResponder {
3755 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3756 tx_id: u32,
3757}
3758
3759impl std::ops::Drop for WlanFullmacImpl_SaeHandshakeRespResponder {
3763 fn drop(&mut self) {
3764 self.control_handle.shutdown();
3765 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3767 }
3768}
3769
3770impl fidl::endpoints::Responder for WlanFullmacImpl_SaeHandshakeRespResponder {
3771 type ControlHandle = WlanFullmacImpl_ControlHandle;
3772
3773 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3774 &self.control_handle
3775 }
3776
3777 fn drop_without_shutdown(mut self) {
3778 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3780 std::mem::forget(self);
3782 }
3783}
3784
3785impl WlanFullmacImpl_SaeHandshakeRespResponder {
3786 pub fn send(self) -> Result<(), fidl::Error> {
3790 let _result = self.send_raw();
3791 if _result.is_err() {
3792 self.control_handle.shutdown();
3793 }
3794 self.drop_without_shutdown();
3795 _result
3796 }
3797
3798 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3800 let _result = self.send_raw();
3801 self.drop_without_shutdown();
3802 _result
3803 }
3804
3805 fn send_raw(&self) -> Result<(), fidl::Error> {
3806 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3807 (),
3808 self.tx_id,
3809 0x72cd3a31ae5a54f6,
3810 fidl::encoding::DynamicFlags::empty(),
3811 )
3812 }
3813}
3814
3815#[must_use = "FIDL methods require a response to be sent"]
3816#[derive(Debug)]
3817pub struct WlanFullmacImpl_SaeFrameTxResponder {
3818 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3819 tx_id: u32,
3820}
3821
3822impl std::ops::Drop for WlanFullmacImpl_SaeFrameTxResponder {
3826 fn drop(&mut self) {
3827 self.control_handle.shutdown();
3828 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3830 }
3831}
3832
3833impl fidl::endpoints::Responder for WlanFullmacImpl_SaeFrameTxResponder {
3834 type ControlHandle = WlanFullmacImpl_ControlHandle;
3835
3836 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3837 &self.control_handle
3838 }
3839
3840 fn drop_without_shutdown(mut self) {
3841 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3843 std::mem::forget(self);
3845 }
3846}
3847
3848impl WlanFullmacImpl_SaeFrameTxResponder {
3849 pub fn send(self) -> Result<(), fidl::Error> {
3853 let _result = self.send_raw();
3854 if _result.is_err() {
3855 self.control_handle.shutdown();
3856 }
3857 self.drop_without_shutdown();
3858 _result
3859 }
3860
3861 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3863 let _result = self.send_raw();
3864 self.drop_without_shutdown();
3865 _result
3866 }
3867
3868 fn send_raw(&self) -> Result<(), fidl::Error> {
3869 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3870 (),
3871 self.tx_id,
3872 0x4715ad5dc5a6340f,
3873 fidl::encoding::DynamicFlags::empty(),
3874 )
3875 }
3876}
3877
3878#[must_use = "FIDL methods require a response to be sent"]
3879#[derive(Debug)]
3880pub struct WlanFullmacImpl_WmmStatusReqResponder {
3881 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3882 tx_id: u32,
3883}
3884
3885impl std::ops::Drop for WlanFullmacImpl_WmmStatusReqResponder {
3889 fn drop(&mut self) {
3890 self.control_handle.shutdown();
3891 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3893 }
3894}
3895
3896impl fidl::endpoints::Responder for WlanFullmacImpl_WmmStatusReqResponder {
3897 type ControlHandle = WlanFullmacImpl_ControlHandle;
3898
3899 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3900 &self.control_handle
3901 }
3902
3903 fn drop_without_shutdown(mut self) {
3904 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3906 std::mem::forget(self);
3908 }
3909}
3910
3911impl WlanFullmacImpl_WmmStatusReqResponder {
3912 pub fn send(self) -> Result<(), fidl::Error> {
3916 let _result = self.send_raw();
3917 if _result.is_err() {
3918 self.control_handle.shutdown();
3919 }
3920 self.drop_without_shutdown();
3921 _result
3922 }
3923
3924 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3926 let _result = self.send_raw();
3927 self.drop_without_shutdown();
3928 _result
3929 }
3930
3931 fn send_raw(&self) -> Result<(), fidl::Error> {
3932 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3933 (),
3934 self.tx_id,
3935 0x635ecef3beb7a059,
3936 fidl::encoding::DynamicFlags::empty(),
3937 )
3938 }
3939}
3940
3941#[must_use = "FIDL methods require a response to be sent"]
3942#[derive(Debug)]
3943pub struct WlanFullmacImpl_OnLinkStateChangedResponder {
3944 control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3945 tx_id: u32,
3946}
3947
3948impl std::ops::Drop for WlanFullmacImpl_OnLinkStateChangedResponder {
3952 fn drop(&mut self) {
3953 self.control_handle.shutdown();
3954 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3956 }
3957}
3958
3959impl fidl::endpoints::Responder for WlanFullmacImpl_OnLinkStateChangedResponder {
3960 type ControlHandle = WlanFullmacImpl_ControlHandle;
3961
3962 fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3963 &self.control_handle
3964 }
3965
3966 fn drop_without_shutdown(mut self) {
3967 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3969 std::mem::forget(self);
3971 }
3972}
3973
3974impl WlanFullmacImpl_OnLinkStateChangedResponder {
3975 pub fn send(self) -> Result<(), fidl::Error> {
3979 let _result = self.send_raw();
3980 if _result.is_err() {
3981 self.control_handle.shutdown();
3982 }
3983 self.drop_without_shutdown();
3984 _result
3985 }
3986
3987 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3989 let _result = self.send_raw();
3990 self.drop_without_shutdown();
3991 _result
3992 }
3993
3994 fn send_raw(&self) -> Result<(), fidl::Error> {
3995 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3996 (),
3997 self.tx_id,
3998 0x4d896e5b68e488d7,
3999 fidl::encoding::DynamicFlags::empty(),
4000 )
4001 }
4002}
4003
4004#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
4005pub struct WlanFullmacImplIfcMarker;
4006
4007impl fidl::endpoints::ProtocolMarker for WlanFullmacImplIfcMarker {
4008 type Proxy = WlanFullmacImplIfcProxy;
4009 type RequestStream = WlanFullmacImplIfcRequestStream;
4010 #[cfg(target_os = "fuchsia")]
4011 type SynchronousProxy = WlanFullmacImplIfcSynchronousProxy;
4012
4013 const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImplIfc";
4014}
4015impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImplIfcMarker {}
4016
4017pub trait WlanFullmacImplIfcProxyInterface: Send + Sync {
4018 type OnScanResultResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4019 fn r#on_scan_result(
4020 &self,
4021 payload: &WlanFullmacImplIfcOnScanResultRequest,
4022 ) -> Self::OnScanResultResponseFut;
4023 type OnScanEndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4024 fn r#on_scan_end(
4025 &self,
4026 payload: &WlanFullmacImplIfcOnScanEndRequest,
4027 ) -> Self::OnScanEndResponseFut;
4028 type ConnectConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4029 fn r#connect_conf(
4030 &self,
4031 payload: &WlanFullmacImplIfcConnectConfRequest,
4032 ) -> Self::ConnectConfResponseFut;
4033 type RoamConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4034 fn r#roam_conf(&self, payload: &WlanFullmacImplIfcRoamConfRequest)
4035 -> Self::RoamConfResponseFut;
4036 type RoamStartIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4037 fn r#roam_start_ind(
4038 &self,
4039 payload: &WlanFullmacImplIfcRoamStartIndRequest,
4040 ) -> Self::RoamStartIndResponseFut;
4041 type RoamResultIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4042 fn r#roam_result_ind(
4043 &self,
4044 payload: &WlanFullmacImplIfcRoamResultIndRequest,
4045 ) -> Self::RoamResultIndResponseFut;
4046 type AuthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4047 fn r#auth_ind(&self, payload: &WlanFullmacImplIfcAuthIndRequest) -> Self::AuthIndResponseFut;
4048 type DeauthConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4049 fn r#deauth_conf(
4050 &self,
4051 payload: &WlanFullmacImplIfcDeauthConfRequest,
4052 ) -> Self::DeauthConfResponseFut;
4053 type DeauthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4054 fn r#deauth_ind(
4055 &self,
4056 payload: &WlanFullmacImplIfcDeauthIndRequest,
4057 ) -> Self::DeauthIndResponseFut;
4058 type AssocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4059 fn r#assoc_ind(&self, payload: &WlanFullmacImplIfcAssocIndRequest)
4060 -> Self::AssocIndResponseFut;
4061 type DisassocConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4062 fn r#disassoc_conf(
4063 &self,
4064 payload: &WlanFullmacImplIfcDisassocConfRequest,
4065 ) -> Self::DisassocConfResponseFut;
4066 type DisassocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4067 fn r#disassoc_ind(
4068 &self,
4069 payload: &WlanFullmacImplIfcDisassocIndRequest,
4070 ) -> Self::DisassocIndResponseFut;
4071 type StartConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4072 fn r#start_conf(
4073 &self,
4074 payload: &WlanFullmacImplIfcStartConfRequest,
4075 ) -> Self::StartConfResponseFut;
4076 type StopConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4077 fn r#stop_conf(&self, payload: &WlanFullmacImplIfcStopConfRequest)
4078 -> Self::StopConfResponseFut;
4079 type EapolConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4080 fn r#eapol_conf(
4081 &self,
4082 payload: &WlanFullmacImplIfcEapolConfRequest,
4083 ) -> Self::EapolConfResponseFut;
4084 type OnChannelSwitchResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4085 fn r#on_channel_switch(
4086 &self,
4087 ind: &WlanFullmacChannelSwitchInfo,
4088 ) -> Self::OnChannelSwitchResponseFut;
4089 type SignalReportResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4090 fn r#signal_report(
4091 &self,
4092 ind: &WlanFullmacSignalReportIndication,
4093 ) -> Self::SignalReportResponseFut;
4094 type EapolIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4095 fn r#eapol_ind(&self, payload: &WlanFullmacImplIfcEapolIndRequest)
4096 -> Self::EapolIndResponseFut;
4097 type OnPmkAvailableResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4098 fn r#on_pmk_available(
4099 &self,
4100 payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
4101 ) -> Self::OnPmkAvailableResponseFut;
4102 type SaeHandshakeIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4103 fn r#sae_handshake_ind(
4104 &self,
4105 payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
4106 ) -> Self::SaeHandshakeIndResponseFut;
4107 type SaeFrameRxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4108 fn r#sae_frame_rx(&self, frame: &SaeFrame) -> Self::SaeFrameRxResponseFut;
4109 type OnWmmStatusRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4110 fn r#on_wmm_status_resp(
4111 &self,
4112 status: i32,
4113 wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
4114 ) -> Self::OnWmmStatusRespResponseFut;
4115}
4116#[derive(Debug)]
4117#[cfg(target_os = "fuchsia")]
4118pub struct WlanFullmacImplIfcSynchronousProxy {
4119 client: fidl::client::sync::Client,
4120}
4121
4122#[cfg(target_os = "fuchsia")]
4123impl fidl::endpoints::SynchronousProxy for WlanFullmacImplIfcSynchronousProxy {
4124 type Proxy = WlanFullmacImplIfcProxy;
4125 type Protocol = WlanFullmacImplIfcMarker;
4126
4127 fn from_channel(inner: fidl::Channel) -> Self {
4128 Self::new(inner)
4129 }
4130
4131 fn into_channel(self) -> fidl::Channel {
4132 self.client.into_channel()
4133 }
4134
4135 fn as_channel(&self) -> &fidl::Channel {
4136 self.client.as_channel()
4137 }
4138}
4139
4140#[cfg(target_os = "fuchsia")]
4141impl WlanFullmacImplIfcSynchronousProxy {
4142 pub fn new(channel: fidl::Channel) -> Self {
4143 let protocol_name =
4144 <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
4145 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
4146 }
4147
4148 pub fn into_channel(self) -> fidl::Channel {
4149 self.client.into_channel()
4150 }
4151
4152 pub fn wait_for_event(
4155 &self,
4156 deadline: zx::MonotonicInstant,
4157 ) -> Result<WlanFullmacImplIfcEvent, fidl::Error> {
4158 WlanFullmacImplIfcEvent::decode(self.client.wait_for_event(deadline)?)
4159 }
4160
4161 pub fn r#on_scan_result(
4162 &self,
4163 mut payload: &WlanFullmacImplIfcOnScanResultRequest,
4164 ___deadline: zx::MonotonicInstant,
4165 ) -> Result<(), fidl::Error> {
4166 let _response = self
4167 .client
4168 .send_query::<WlanFullmacImplIfcOnScanResultRequest, fidl::encoding::EmptyPayload>(
4169 payload,
4170 0x29aa81dc570f7a3e,
4171 fidl::encoding::DynamicFlags::empty(),
4172 ___deadline,
4173 )?;
4174 Ok(_response)
4175 }
4176
4177 pub fn r#on_scan_end(
4178 &self,
4179 mut payload: &WlanFullmacImplIfcOnScanEndRequest,
4180 ___deadline: zx::MonotonicInstant,
4181 ) -> Result<(), fidl::Error> {
4182 let _response = self
4183 .client
4184 .send_query::<WlanFullmacImplIfcOnScanEndRequest, fidl::encoding::EmptyPayload>(
4185 payload,
4186 0x7cd8aff80d27073c,
4187 fidl::encoding::DynamicFlags::empty(),
4188 ___deadline,
4189 )?;
4190 Ok(_response)
4191 }
4192
4193 pub fn r#connect_conf(
4194 &self,
4195 mut payload: &WlanFullmacImplIfcConnectConfRequest,
4196 ___deadline: zx::MonotonicInstant,
4197 ) -> Result<(), fidl::Error> {
4198 let _response = self
4199 .client
4200 .send_query::<WlanFullmacImplIfcConnectConfRequest, fidl::encoding::EmptyPayload>(
4201 payload,
4202 0x3c22c6d80b2a2759,
4203 fidl::encoding::DynamicFlags::empty(),
4204 ___deadline,
4205 )?;
4206 Ok(_response)
4207 }
4208
4209 pub fn r#roam_conf(
4211 &self,
4212 mut payload: &WlanFullmacImplIfcRoamConfRequest,
4213 ___deadline: zx::MonotonicInstant,
4214 ) -> Result<(), fidl::Error> {
4215 let _response = self
4216 .client
4217 .send_query::<WlanFullmacImplIfcRoamConfRequest, fidl::encoding::EmptyPayload>(
4218 payload,
4219 0x368b2a5b903b3f7b,
4220 fidl::encoding::DynamicFlags::empty(),
4221 ___deadline,
4222 )?;
4223 Ok(_response)
4224 }
4225
4226 pub fn r#roam_start_ind(
4229 &self,
4230 mut payload: &WlanFullmacImplIfcRoamStartIndRequest,
4231 ___deadline: zx::MonotonicInstant,
4232 ) -> Result<(), fidl::Error> {
4233 let _response = self
4234 .client
4235 .send_query::<WlanFullmacImplIfcRoamStartIndRequest, fidl::encoding::EmptyPayload>(
4236 payload,
4237 0x23e1d9368935e7e4,
4238 fidl::encoding::DynamicFlags::empty(),
4239 ___deadline,
4240 )?;
4241 Ok(_response)
4242 }
4243
4244 pub fn r#roam_result_ind(
4246 &self,
4247 mut payload: &WlanFullmacImplIfcRoamResultIndRequest,
4248 ___deadline: zx::MonotonicInstant,
4249 ) -> Result<(), fidl::Error> {
4250 let _response = self
4251 .client
4252 .send_query::<WlanFullmacImplIfcRoamResultIndRequest, fidl::encoding::EmptyPayload>(
4253 payload,
4254 0x7081c1b1ceea4914,
4255 fidl::encoding::DynamicFlags::empty(),
4256 ___deadline,
4257 )?;
4258 Ok(_response)
4259 }
4260
4261 pub fn r#auth_ind(
4262 &self,
4263 mut payload: &WlanFullmacImplIfcAuthIndRequest,
4264 ___deadline: zx::MonotonicInstant,
4265 ) -> Result<(), fidl::Error> {
4266 let _response = self
4267 .client
4268 .send_query::<WlanFullmacImplIfcAuthIndRequest, fidl::encoding::EmptyPayload>(
4269 payload,
4270 0x270e1f8889650d0b,
4271 fidl::encoding::DynamicFlags::empty(),
4272 ___deadline,
4273 )?;
4274 Ok(_response)
4275 }
4276
4277 pub fn r#deauth_conf(
4278 &self,
4279 mut payload: &WlanFullmacImplIfcDeauthConfRequest,
4280 ___deadline: zx::MonotonicInstant,
4281 ) -> Result<(), fidl::Error> {
4282 let _response = self
4283 .client
4284 .send_query::<WlanFullmacImplIfcDeauthConfRequest, fidl::encoding::EmptyPayload>(
4285 payload,
4286 0x2c94b0d7258111b7,
4287 fidl::encoding::DynamicFlags::empty(),
4288 ___deadline,
4289 )?;
4290 Ok(_response)
4291 }
4292
4293 pub fn r#deauth_ind(
4295 &self,
4296 mut payload: &WlanFullmacImplIfcDeauthIndRequest,
4297 ___deadline: zx::MonotonicInstant,
4298 ) -> Result<(), fidl::Error> {
4299 let _response = self
4300 .client
4301 .send_query::<WlanFullmacImplIfcDeauthIndRequest, fidl::encoding::EmptyPayload>(
4302 payload,
4303 0x26cd27cdadd8dbaf,
4304 fidl::encoding::DynamicFlags::empty(),
4305 ___deadline,
4306 )?;
4307 Ok(_response)
4308 }
4309
4310 pub fn r#assoc_ind(
4311 &self,
4312 mut payload: &WlanFullmacImplIfcAssocIndRequest,
4313 ___deadline: zx::MonotonicInstant,
4314 ) -> Result<(), fidl::Error> {
4315 let _response = self
4316 .client
4317 .send_query::<WlanFullmacImplIfcAssocIndRequest, fidl::encoding::EmptyPayload>(
4318 payload,
4319 0x3e44529e3dc179ce,
4320 fidl::encoding::DynamicFlags::empty(),
4321 ___deadline,
4322 )?;
4323 Ok(_response)
4324 }
4325
4326 pub fn r#disassoc_conf(
4328 &self,
4329 mut payload: &WlanFullmacImplIfcDisassocConfRequest,
4330 ___deadline: zx::MonotonicInstant,
4331 ) -> Result<(), fidl::Error> {
4332 let _response = self
4333 .client
4334 .send_query::<WlanFullmacImplIfcDisassocConfRequest, fidl::encoding::EmptyPayload>(
4335 payload,
4336 0x7c713bcd58a76cb3,
4337 fidl::encoding::DynamicFlags::empty(),
4338 ___deadline,
4339 )?;
4340 Ok(_response)
4341 }
4342
4343 pub fn r#disassoc_ind(
4345 &self,
4346 mut payload: &WlanFullmacImplIfcDisassocIndRequest,
4347 ___deadline: zx::MonotonicInstant,
4348 ) -> Result<(), fidl::Error> {
4349 let _response = self
4350 .client
4351 .send_query::<WlanFullmacImplIfcDisassocIndRequest, fidl::encoding::EmptyPayload>(
4352 payload,
4353 0x6667b381b7f3990f,
4354 fidl::encoding::DynamicFlags::empty(),
4355 ___deadline,
4356 )?;
4357 Ok(_response)
4358 }
4359
4360 pub fn r#start_conf(
4362 &self,
4363 mut payload: &WlanFullmacImplIfcStartConfRequest,
4364 ___deadline: zx::MonotonicInstant,
4365 ) -> Result<(), fidl::Error> {
4366 let _response = self
4367 .client
4368 .send_query::<WlanFullmacImplIfcStartConfRequest, fidl::encoding::EmptyPayload>(
4369 payload,
4370 0x3e9b9641f3ddc7fc,
4371 fidl::encoding::DynamicFlags::empty(),
4372 ___deadline,
4373 )?;
4374 Ok(_response)
4375 }
4376
4377 pub fn r#stop_conf(
4379 &self,
4380 mut payload: &WlanFullmacImplIfcStopConfRequest,
4381 ___deadline: zx::MonotonicInstant,
4382 ) -> Result<(), fidl::Error> {
4383 let _response = self
4384 .client
4385 .send_query::<WlanFullmacImplIfcStopConfRequest, fidl::encoding::EmptyPayload>(
4386 payload,
4387 0x320a5ff227a4e9df,
4388 fidl::encoding::DynamicFlags::empty(),
4389 ___deadline,
4390 )?;
4391 Ok(_response)
4392 }
4393
4394 pub fn r#eapol_conf(
4397 &self,
4398 mut payload: &WlanFullmacImplIfcEapolConfRequest,
4399 ___deadline: zx::MonotonicInstant,
4400 ) -> Result<(), fidl::Error> {
4401 let _response = self
4402 .client
4403 .send_query::<WlanFullmacImplIfcEapolConfRequest, fidl::encoding::EmptyPayload>(
4404 payload,
4405 0x77364db9cc3970ec,
4406 fidl::encoding::DynamicFlags::empty(),
4407 ___deadline,
4408 )?;
4409 Ok(_response)
4410 }
4411
4412 pub fn r#on_channel_switch(
4413 &self,
4414 mut ind: &WlanFullmacChannelSwitchInfo,
4415 ___deadline: zx::MonotonicInstant,
4416 ) -> Result<(), fidl::Error> {
4417 let _response = self
4418 .client
4419 .send_query::<WlanFullmacImplIfcOnChannelSwitchRequest, fidl::encoding::EmptyPayload>(
4420 (ind,),
4421 0x21db0b8f71cae647,
4422 fidl::encoding::DynamicFlags::empty(),
4423 ___deadline,
4424 )?;
4425 Ok(_response)
4426 }
4427
4428 pub fn r#signal_report(
4429 &self,
4430 mut ind: &WlanFullmacSignalReportIndication,
4431 ___deadline: zx::MonotonicInstant,
4432 ) -> Result<(), fidl::Error> {
4433 let _response = self
4434 .client
4435 .send_query::<WlanFullmacImplIfcSignalReportRequest, fidl::encoding::EmptyPayload>(
4436 (ind,),
4437 0x79679fa8789c3d9f,
4438 fidl::encoding::DynamicFlags::empty(),
4439 ___deadline,
4440 )?;
4441 Ok(_response)
4442 }
4443
4444 pub fn r#eapol_ind(
4446 &self,
4447 mut payload: &WlanFullmacImplIfcEapolIndRequest,
4448 ___deadline: zx::MonotonicInstant,
4449 ) -> Result<(), fidl::Error> {
4450 let _response = self
4451 .client
4452 .send_query::<WlanFullmacImplIfcEapolIndRequest, fidl::encoding::EmptyPayload>(
4453 payload,
4454 0x3de8ec1eda10d1d0,
4455 fidl::encoding::DynamicFlags::empty(),
4456 ___deadline,
4457 )?;
4458 Ok(_response)
4459 }
4460
4461 pub fn r#on_pmk_available(
4463 &self,
4464 mut payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
4465 ___deadline: zx::MonotonicInstant,
4466 ) -> Result<(), fidl::Error> {
4467 let _response = self
4468 .client
4469 .send_query::<WlanFullmacImplIfcOnPmkAvailableRequest, fidl::encoding::EmptyPayload>(
4470 payload,
4471 0x5cedd8d9be28a17e,
4472 fidl::encoding::DynamicFlags::empty(),
4473 ___deadline,
4474 )?;
4475 Ok(_response)
4476 }
4477
4478 pub fn r#sae_handshake_ind(
4479 &self,
4480 mut payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
4481 ___deadline: zx::MonotonicInstant,
4482 ) -> Result<(), fidl::Error> {
4483 let _response = self
4484 .client
4485 .send_query::<WlanFullmacImplIfcSaeHandshakeIndRequest, fidl::encoding::EmptyPayload>(
4486 payload,
4487 0x4f3d53885503a1d8,
4488 fidl::encoding::DynamicFlags::empty(),
4489 ___deadline,
4490 )?;
4491 Ok(_response)
4492 }
4493
4494 pub fn r#sae_frame_rx(
4496 &self,
4497 mut frame: &SaeFrame,
4498 ___deadline: zx::MonotonicInstant,
4499 ) -> Result<(), fidl::Error> {
4500 let _response = self
4501 .client
4502 .send_query::<WlanFullmacImplIfcSaeFrameRxRequest, fidl::encoding::EmptyPayload>(
4503 (frame,),
4504 0x51650906857ed4d4,
4505 fidl::encoding::DynamicFlags::empty(),
4506 ___deadline,
4507 )?;
4508 Ok(_response)
4509 }
4510
4511 pub fn r#on_wmm_status_resp(
4512 &self,
4513 mut status: i32,
4514 mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
4515 ___deadline: zx::MonotonicInstant,
4516 ) -> Result<(), fidl::Error> {
4517 let _response = self
4518 .client
4519 .send_query::<WlanFullmacImplIfcOnWmmStatusRespRequest, fidl::encoding::EmptyPayload>(
4520 (status, wmm_params),
4521 0x6823a88bf3ba8b2a,
4522 fidl::encoding::DynamicFlags::empty(),
4523 ___deadline,
4524 )?;
4525 Ok(_response)
4526 }
4527}
4528
4529#[derive(Debug, Clone)]
4530pub struct WlanFullmacImplIfcProxy {
4531 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
4532}
4533
4534impl fidl::endpoints::Proxy for WlanFullmacImplIfcProxy {
4535 type Protocol = WlanFullmacImplIfcMarker;
4536
4537 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
4538 Self::new(inner)
4539 }
4540
4541 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
4542 self.client.into_channel().map_err(|client| Self { client })
4543 }
4544
4545 fn as_channel(&self) -> &::fidl::AsyncChannel {
4546 self.client.as_channel()
4547 }
4548}
4549
4550impl WlanFullmacImplIfcProxy {
4551 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
4553 let protocol_name =
4554 <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
4555 Self { client: fidl::client::Client::new(channel, protocol_name) }
4556 }
4557
4558 pub fn take_event_stream(&self) -> WlanFullmacImplIfcEventStream {
4564 WlanFullmacImplIfcEventStream { event_receiver: self.client.take_event_receiver() }
4565 }
4566
4567 pub fn r#on_scan_result(
4568 &self,
4569 mut payload: &WlanFullmacImplIfcOnScanResultRequest,
4570 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4571 WlanFullmacImplIfcProxyInterface::r#on_scan_result(self, payload)
4572 }
4573
4574 pub fn r#on_scan_end(
4575 &self,
4576 mut payload: &WlanFullmacImplIfcOnScanEndRequest,
4577 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4578 WlanFullmacImplIfcProxyInterface::r#on_scan_end(self, payload)
4579 }
4580
4581 pub fn r#connect_conf(
4582 &self,
4583 mut payload: &WlanFullmacImplIfcConnectConfRequest,
4584 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4585 WlanFullmacImplIfcProxyInterface::r#connect_conf(self, payload)
4586 }
4587
4588 pub fn r#roam_conf(
4590 &self,
4591 mut payload: &WlanFullmacImplIfcRoamConfRequest,
4592 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4593 WlanFullmacImplIfcProxyInterface::r#roam_conf(self, payload)
4594 }
4595
4596 pub fn r#roam_start_ind(
4599 &self,
4600 mut payload: &WlanFullmacImplIfcRoamStartIndRequest,
4601 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4602 WlanFullmacImplIfcProxyInterface::r#roam_start_ind(self, payload)
4603 }
4604
4605 pub fn r#roam_result_ind(
4607 &self,
4608 mut payload: &WlanFullmacImplIfcRoamResultIndRequest,
4609 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4610 WlanFullmacImplIfcProxyInterface::r#roam_result_ind(self, payload)
4611 }
4612
4613 pub fn r#auth_ind(
4614 &self,
4615 mut payload: &WlanFullmacImplIfcAuthIndRequest,
4616 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4617 WlanFullmacImplIfcProxyInterface::r#auth_ind(self, payload)
4618 }
4619
4620 pub fn r#deauth_conf(
4621 &self,
4622 mut payload: &WlanFullmacImplIfcDeauthConfRequest,
4623 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4624 WlanFullmacImplIfcProxyInterface::r#deauth_conf(self, payload)
4625 }
4626
4627 pub fn r#deauth_ind(
4629 &self,
4630 mut payload: &WlanFullmacImplIfcDeauthIndRequest,
4631 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4632 WlanFullmacImplIfcProxyInterface::r#deauth_ind(self, payload)
4633 }
4634
4635 pub fn r#assoc_ind(
4636 &self,
4637 mut payload: &WlanFullmacImplIfcAssocIndRequest,
4638 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4639 WlanFullmacImplIfcProxyInterface::r#assoc_ind(self, payload)
4640 }
4641
4642 pub fn r#disassoc_conf(
4644 &self,
4645 mut payload: &WlanFullmacImplIfcDisassocConfRequest,
4646 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4647 WlanFullmacImplIfcProxyInterface::r#disassoc_conf(self, payload)
4648 }
4649
4650 pub fn r#disassoc_ind(
4652 &self,
4653 mut payload: &WlanFullmacImplIfcDisassocIndRequest,
4654 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4655 WlanFullmacImplIfcProxyInterface::r#disassoc_ind(self, payload)
4656 }
4657
4658 pub fn r#start_conf(
4660 &self,
4661 mut payload: &WlanFullmacImplIfcStartConfRequest,
4662 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4663 WlanFullmacImplIfcProxyInterface::r#start_conf(self, payload)
4664 }
4665
4666 pub fn r#stop_conf(
4668 &self,
4669 mut payload: &WlanFullmacImplIfcStopConfRequest,
4670 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4671 WlanFullmacImplIfcProxyInterface::r#stop_conf(self, payload)
4672 }
4673
4674 pub fn r#eapol_conf(
4677 &self,
4678 mut payload: &WlanFullmacImplIfcEapolConfRequest,
4679 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4680 WlanFullmacImplIfcProxyInterface::r#eapol_conf(self, payload)
4681 }
4682
4683 pub fn r#on_channel_switch(
4684 &self,
4685 mut ind: &WlanFullmacChannelSwitchInfo,
4686 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4687 WlanFullmacImplIfcProxyInterface::r#on_channel_switch(self, ind)
4688 }
4689
4690 pub fn r#signal_report(
4691 &self,
4692 mut ind: &WlanFullmacSignalReportIndication,
4693 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4694 WlanFullmacImplIfcProxyInterface::r#signal_report(self, ind)
4695 }
4696
4697 pub fn r#eapol_ind(
4699 &self,
4700 mut payload: &WlanFullmacImplIfcEapolIndRequest,
4701 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4702 WlanFullmacImplIfcProxyInterface::r#eapol_ind(self, payload)
4703 }
4704
4705 pub fn r#on_pmk_available(
4707 &self,
4708 mut payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
4709 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4710 WlanFullmacImplIfcProxyInterface::r#on_pmk_available(self, payload)
4711 }
4712
4713 pub fn r#sae_handshake_ind(
4714 &self,
4715 mut payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
4716 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4717 WlanFullmacImplIfcProxyInterface::r#sae_handshake_ind(self, payload)
4718 }
4719
4720 pub fn r#sae_frame_rx(
4722 &self,
4723 mut frame: &SaeFrame,
4724 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4725 WlanFullmacImplIfcProxyInterface::r#sae_frame_rx(self, frame)
4726 }
4727
4728 pub fn r#on_wmm_status_resp(
4729 &self,
4730 mut status: i32,
4731 mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
4732 ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4733 WlanFullmacImplIfcProxyInterface::r#on_wmm_status_resp(self, status, wmm_params)
4734 }
4735}
4736
4737impl WlanFullmacImplIfcProxyInterface for WlanFullmacImplIfcProxy {
4738 type OnScanResultResponseFut =
4739 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4740 fn r#on_scan_result(
4741 &self,
4742 mut payload: &WlanFullmacImplIfcOnScanResultRequest,
4743 ) -> Self::OnScanResultResponseFut {
4744 fn _decode(
4745 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4746 ) -> Result<(), fidl::Error> {
4747 let _response = fidl::client::decode_transaction_body::<
4748 fidl::encoding::EmptyPayload,
4749 fidl::encoding::DefaultFuchsiaResourceDialect,
4750 0x29aa81dc570f7a3e,
4751 >(_buf?)?;
4752 Ok(_response)
4753 }
4754 self.client.send_query_and_decode::<WlanFullmacImplIfcOnScanResultRequest, ()>(
4755 payload,
4756 0x29aa81dc570f7a3e,
4757 fidl::encoding::DynamicFlags::empty(),
4758 _decode,
4759 )
4760 }
4761
4762 type OnScanEndResponseFut =
4763 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4764 fn r#on_scan_end(
4765 &self,
4766 mut payload: &WlanFullmacImplIfcOnScanEndRequest,
4767 ) -> Self::OnScanEndResponseFut {
4768 fn _decode(
4769 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4770 ) -> Result<(), fidl::Error> {
4771 let _response = fidl::client::decode_transaction_body::<
4772 fidl::encoding::EmptyPayload,
4773 fidl::encoding::DefaultFuchsiaResourceDialect,
4774 0x7cd8aff80d27073c,
4775 >(_buf?)?;
4776 Ok(_response)
4777 }
4778 self.client.send_query_and_decode::<WlanFullmacImplIfcOnScanEndRequest, ()>(
4779 payload,
4780 0x7cd8aff80d27073c,
4781 fidl::encoding::DynamicFlags::empty(),
4782 _decode,
4783 )
4784 }
4785
4786 type ConnectConfResponseFut =
4787 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4788 fn r#connect_conf(
4789 &self,
4790 mut payload: &WlanFullmacImplIfcConnectConfRequest,
4791 ) -> Self::ConnectConfResponseFut {
4792 fn _decode(
4793 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4794 ) -> Result<(), fidl::Error> {
4795 let _response = fidl::client::decode_transaction_body::<
4796 fidl::encoding::EmptyPayload,
4797 fidl::encoding::DefaultFuchsiaResourceDialect,
4798 0x3c22c6d80b2a2759,
4799 >(_buf?)?;
4800 Ok(_response)
4801 }
4802 self.client.send_query_and_decode::<WlanFullmacImplIfcConnectConfRequest, ()>(
4803 payload,
4804 0x3c22c6d80b2a2759,
4805 fidl::encoding::DynamicFlags::empty(),
4806 _decode,
4807 )
4808 }
4809
4810 type RoamConfResponseFut =
4811 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4812 fn r#roam_conf(
4813 &self,
4814 mut payload: &WlanFullmacImplIfcRoamConfRequest,
4815 ) -> Self::RoamConfResponseFut {
4816 fn _decode(
4817 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4818 ) -> Result<(), fidl::Error> {
4819 let _response = fidl::client::decode_transaction_body::<
4820 fidl::encoding::EmptyPayload,
4821 fidl::encoding::DefaultFuchsiaResourceDialect,
4822 0x368b2a5b903b3f7b,
4823 >(_buf?)?;
4824 Ok(_response)
4825 }
4826 self.client.send_query_and_decode::<WlanFullmacImplIfcRoamConfRequest, ()>(
4827 payload,
4828 0x368b2a5b903b3f7b,
4829 fidl::encoding::DynamicFlags::empty(),
4830 _decode,
4831 )
4832 }
4833
4834 type RoamStartIndResponseFut =
4835 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4836 fn r#roam_start_ind(
4837 &self,
4838 mut payload: &WlanFullmacImplIfcRoamStartIndRequest,
4839 ) -> Self::RoamStartIndResponseFut {
4840 fn _decode(
4841 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4842 ) -> Result<(), fidl::Error> {
4843 let _response = fidl::client::decode_transaction_body::<
4844 fidl::encoding::EmptyPayload,
4845 fidl::encoding::DefaultFuchsiaResourceDialect,
4846 0x23e1d9368935e7e4,
4847 >(_buf?)?;
4848 Ok(_response)
4849 }
4850 self.client.send_query_and_decode::<WlanFullmacImplIfcRoamStartIndRequest, ()>(
4851 payload,
4852 0x23e1d9368935e7e4,
4853 fidl::encoding::DynamicFlags::empty(),
4854 _decode,
4855 )
4856 }
4857
4858 type RoamResultIndResponseFut =
4859 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4860 fn r#roam_result_ind(
4861 &self,
4862 mut payload: &WlanFullmacImplIfcRoamResultIndRequest,
4863 ) -> Self::RoamResultIndResponseFut {
4864 fn _decode(
4865 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4866 ) -> Result<(), fidl::Error> {
4867 let _response = fidl::client::decode_transaction_body::<
4868 fidl::encoding::EmptyPayload,
4869 fidl::encoding::DefaultFuchsiaResourceDialect,
4870 0x7081c1b1ceea4914,
4871 >(_buf?)?;
4872 Ok(_response)
4873 }
4874 self.client.send_query_and_decode::<WlanFullmacImplIfcRoamResultIndRequest, ()>(
4875 payload,
4876 0x7081c1b1ceea4914,
4877 fidl::encoding::DynamicFlags::empty(),
4878 _decode,
4879 )
4880 }
4881
4882 type AuthIndResponseFut =
4883 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4884 fn r#auth_ind(
4885 &self,
4886 mut payload: &WlanFullmacImplIfcAuthIndRequest,
4887 ) -> Self::AuthIndResponseFut {
4888 fn _decode(
4889 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4890 ) -> Result<(), fidl::Error> {
4891 let _response = fidl::client::decode_transaction_body::<
4892 fidl::encoding::EmptyPayload,
4893 fidl::encoding::DefaultFuchsiaResourceDialect,
4894 0x270e1f8889650d0b,
4895 >(_buf?)?;
4896 Ok(_response)
4897 }
4898 self.client.send_query_and_decode::<WlanFullmacImplIfcAuthIndRequest, ()>(
4899 payload,
4900 0x270e1f8889650d0b,
4901 fidl::encoding::DynamicFlags::empty(),
4902 _decode,
4903 )
4904 }
4905
4906 type DeauthConfResponseFut =
4907 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4908 fn r#deauth_conf(
4909 &self,
4910 mut payload: &WlanFullmacImplIfcDeauthConfRequest,
4911 ) -> Self::DeauthConfResponseFut {
4912 fn _decode(
4913 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4914 ) -> Result<(), fidl::Error> {
4915 let _response = fidl::client::decode_transaction_body::<
4916 fidl::encoding::EmptyPayload,
4917 fidl::encoding::DefaultFuchsiaResourceDialect,
4918 0x2c94b0d7258111b7,
4919 >(_buf?)?;
4920 Ok(_response)
4921 }
4922 self.client.send_query_and_decode::<WlanFullmacImplIfcDeauthConfRequest, ()>(
4923 payload,
4924 0x2c94b0d7258111b7,
4925 fidl::encoding::DynamicFlags::empty(),
4926 _decode,
4927 )
4928 }
4929
4930 type DeauthIndResponseFut =
4931 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4932 fn r#deauth_ind(
4933 &self,
4934 mut payload: &WlanFullmacImplIfcDeauthIndRequest,
4935 ) -> Self::DeauthIndResponseFut {
4936 fn _decode(
4937 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4938 ) -> Result<(), fidl::Error> {
4939 let _response = fidl::client::decode_transaction_body::<
4940 fidl::encoding::EmptyPayload,
4941 fidl::encoding::DefaultFuchsiaResourceDialect,
4942 0x26cd27cdadd8dbaf,
4943 >(_buf?)?;
4944 Ok(_response)
4945 }
4946 self.client.send_query_and_decode::<WlanFullmacImplIfcDeauthIndRequest, ()>(
4947 payload,
4948 0x26cd27cdadd8dbaf,
4949 fidl::encoding::DynamicFlags::empty(),
4950 _decode,
4951 )
4952 }
4953
4954 type AssocIndResponseFut =
4955 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4956 fn r#assoc_ind(
4957 &self,
4958 mut payload: &WlanFullmacImplIfcAssocIndRequest,
4959 ) -> Self::AssocIndResponseFut {
4960 fn _decode(
4961 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4962 ) -> Result<(), fidl::Error> {
4963 let _response = fidl::client::decode_transaction_body::<
4964 fidl::encoding::EmptyPayload,
4965 fidl::encoding::DefaultFuchsiaResourceDialect,
4966 0x3e44529e3dc179ce,
4967 >(_buf?)?;
4968 Ok(_response)
4969 }
4970 self.client.send_query_and_decode::<WlanFullmacImplIfcAssocIndRequest, ()>(
4971 payload,
4972 0x3e44529e3dc179ce,
4973 fidl::encoding::DynamicFlags::empty(),
4974 _decode,
4975 )
4976 }
4977
4978 type DisassocConfResponseFut =
4979 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4980 fn r#disassoc_conf(
4981 &self,
4982 mut payload: &WlanFullmacImplIfcDisassocConfRequest,
4983 ) -> Self::DisassocConfResponseFut {
4984 fn _decode(
4985 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4986 ) -> Result<(), fidl::Error> {
4987 let _response = fidl::client::decode_transaction_body::<
4988 fidl::encoding::EmptyPayload,
4989 fidl::encoding::DefaultFuchsiaResourceDialect,
4990 0x7c713bcd58a76cb3,
4991 >(_buf?)?;
4992 Ok(_response)
4993 }
4994 self.client.send_query_and_decode::<WlanFullmacImplIfcDisassocConfRequest, ()>(
4995 payload,
4996 0x7c713bcd58a76cb3,
4997 fidl::encoding::DynamicFlags::empty(),
4998 _decode,
4999 )
5000 }
5001
5002 type DisassocIndResponseFut =
5003 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5004 fn r#disassoc_ind(
5005 &self,
5006 mut payload: &WlanFullmacImplIfcDisassocIndRequest,
5007 ) -> Self::DisassocIndResponseFut {
5008 fn _decode(
5009 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5010 ) -> Result<(), fidl::Error> {
5011 let _response = fidl::client::decode_transaction_body::<
5012 fidl::encoding::EmptyPayload,
5013 fidl::encoding::DefaultFuchsiaResourceDialect,
5014 0x6667b381b7f3990f,
5015 >(_buf?)?;
5016 Ok(_response)
5017 }
5018 self.client.send_query_and_decode::<WlanFullmacImplIfcDisassocIndRequest, ()>(
5019 payload,
5020 0x6667b381b7f3990f,
5021 fidl::encoding::DynamicFlags::empty(),
5022 _decode,
5023 )
5024 }
5025
5026 type StartConfResponseFut =
5027 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5028 fn r#start_conf(
5029 &self,
5030 mut payload: &WlanFullmacImplIfcStartConfRequest,
5031 ) -> Self::StartConfResponseFut {
5032 fn _decode(
5033 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5034 ) -> Result<(), fidl::Error> {
5035 let _response = fidl::client::decode_transaction_body::<
5036 fidl::encoding::EmptyPayload,
5037 fidl::encoding::DefaultFuchsiaResourceDialect,
5038 0x3e9b9641f3ddc7fc,
5039 >(_buf?)?;
5040 Ok(_response)
5041 }
5042 self.client.send_query_and_decode::<WlanFullmacImplIfcStartConfRequest, ()>(
5043 payload,
5044 0x3e9b9641f3ddc7fc,
5045 fidl::encoding::DynamicFlags::empty(),
5046 _decode,
5047 )
5048 }
5049
5050 type StopConfResponseFut =
5051 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5052 fn r#stop_conf(
5053 &self,
5054 mut payload: &WlanFullmacImplIfcStopConfRequest,
5055 ) -> Self::StopConfResponseFut {
5056 fn _decode(
5057 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5058 ) -> Result<(), fidl::Error> {
5059 let _response = fidl::client::decode_transaction_body::<
5060 fidl::encoding::EmptyPayload,
5061 fidl::encoding::DefaultFuchsiaResourceDialect,
5062 0x320a5ff227a4e9df,
5063 >(_buf?)?;
5064 Ok(_response)
5065 }
5066 self.client.send_query_and_decode::<WlanFullmacImplIfcStopConfRequest, ()>(
5067 payload,
5068 0x320a5ff227a4e9df,
5069 fidl::encoding::DynamicFlags::empty(),
5070 _decode,
5071 )
5072 }
5073
5074 type EapolConfResponseFut =
5075 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5076 fn r#eapol_conf(
5077 &self,
5078 mut payload: &WlanFullmacImplIfcEapolConfRequest,
5079 ) -> Self::EapolConfResponseFut {
5080 fn _decode(
5081 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5082 ) -> Result<(), fidl::Error> {
5083 let _response = fidl::client::decode_transaction_body::<
5084 fidl::encoding::EmptyPayload,
5085 fidl::encoding::DefaultFuchsiaResourceDialect,
5086 0x77364db9cc3970ec,
5087 >(_buf?)?;
5088 Ok(_response)
5089 }
5090 self.client.send_query_and_decode::<WlanFullmacImplIfcEapolConfRequest, ()>(
5091 payload,
5092 0x77364db9cc3970ec,
5093 fidl::encoding::DynamicFlags::empty(),
5094 _decode,
5095 )
5096 }
5097
5098 type OnChannelSwitchResponseFut =
5099 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5100 fn r#on_channel_switch(
5101 &self,
5102 mut ind: &WlanFullmacChannelSwitchInfo,
5103 ) -> Self::OnChannelSwitchResponseFut {
5104 fn _decode(
5105 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5106 ) -> Result<(), fidl::Error> {
5107 let _response = fidl::client::decode_transaction_body::<
5108 fidl::encoding::EmptyPayload,
5109 fidl::encoding::DefaultFuchsiaResourceDialect,
5110 0x21db0b8f71cae647,
5111 >(_buf?)?;
5112 Ok(_response)
5113 }
5114 self.client.send_query_and_decode::<WlanFullmacImplIfcOnChannelSwitchRequest, ()>(
5115 (ind,),
5116 0x21db0b8f71cae647,
5117 fidl::encoding::DynamicFlags::empty(),
5118 _decode,
5119 )
5120 }
5121
5122 type SignalReportResponseFut =
5123 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5124 fn r#signal_report(
5125 &self,
5126 mut ind: &WlanFullmacSignalReportIndication,
5127 ) -> Self::SignalReportResponseFut {
5128 fn _decode(
5129 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5130 ) -> Result<(), fidl::Error> {
5131 let _response = fidl::client::decode_transaction_body::<
5132 fidl::encoding::EmptyPayload,
5133 fidl::encoding::DefaultFuchsiaResourceDialect,
5134 0x79679fa8789c3d9f,
5135 >(_buf?)?;
5136 Ok(_response)
5137 }
5138 self.client.send_query_and_decode::<WlanFullmacImplIfcSignalReportRequest, ()>(
5139 (ind,),
5140 0x79679fa8789c3d9f,
5141 fidl::encoding::DynamicFlags::empty(),
5142 _decode,
5143 )
5144 }
5145
5146 type EapolIndResponseFut =
5147 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5148 fn r#eapol_ind(
5149 &self,
5150 mut payload: &WlanFullmacImplIfcEapolIndRequest,
5151 ) -> Self::EapolIndResponseFut {
5152 fn _decode(
5153 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5154 ) -> Result<(), fidl::Error> {
5155 let _response = fidl::client::decode_transaction_body::<
5156 fidl::encoding::EmptyPayload,
5157 fidl::encoding::DefaultFuchsiaResourceDialect,
5158 0x3de8ec1eda10d1d0,
5159 >(_buf?)?;
5160 Ok(_response)
5161 }
5162 self.client.send_query_and_decode::<WlanFullmacImplIfcEapolIndRequest, ()>(
5163 payload,
5164 0x3de8ec1eda10d1d0,
5165 fidl::encoding::DynamicFlags::empty(),
5166 _decode,
5167 )
5168 }
5169
5170 type OnPmkAvailableResponseFut =
5171 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5172 fn r#on_pmk_available(
5173 &self,
5174 mut payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
5175 ) -> Self::OnPmkAvailableResponseFut {
5176 fn _decode(
5177 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5178 ) -> Result<(), fidl::Error> {
5179 let _response = fidl::client::decode_transaction_body::<
5180 fidl::encoding::EmptyPayload,
5181 fidl::encoding::DefaultFuchsiaResourceDialect,
5182 0x5cedd8d9be28a17e,
5183 >(_buf?)?;
5184 Ok(_response)
5185 }
5186 self.client.send_query_and_decode::<WlanFullmacImplIfcOnPmkAvailableRequest, ()>(
5187 payload,
5188 0x5cedd8d9be28a17e,
5189 fidl::encoding::DynamicFlags::empty(),
5190 _decode,
5191 )
5192 }
5193
5194 type SaeHandshakeIndResponseFut =
5195 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5196 fn r#sae_handshake_ind(
5197 &self,
5198 mut payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
5199 ) -> Self::SaeHandshakeIndResponseFut {
5200 fn _decode(
5201 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5202 ) -> Result<(), fidl::Error> {
5203 let _response = fidl::client::decode_transaction_body::<
5204 fidl::encoding::EmptyPayload,
5205 fidl::encoding::DefaultFuchsiaResourceDialect,
5206 0x4f3d53885503a1d8,
5207 >(_buf?)?;
5208 Ok(_response)
5209 }
5210 self.client.send_query_and_decode::<WlanFullmacImplIfcSaeHandshakeIndRequest, ()>(
5211 payload,
5212 0x4f3d53885503a1d8,
5213 fidl::encoding::DynamicFlags::empty(),
5214 _decode,
5215 )
5216 }
5217
5218 type SaeFrameRxResponseFut =
5219 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5220 fn r#sae_frame_rx(&self, mut frame: &SaeFrame) -> Self::SaeFrameRxResponseFut {
5221 fn _decode(
5222 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5223 ) -> Result<(), fidl::Error> {
5224 let _response = fidl::client::decode_transaction_body::<
5225 fidl::encoding::EmptyPayload,
5226 fidl::encoding::DefaultFuchsiaResourceDialect,
5227 0x51650906857ed4d4,
5228 >(_buf?)?;
5229 Ok(_response)
5230 }
5231 self.client.send_query_and_decode::<WlanFullmacImplIfcSaeFrameRxRequest, ()>(
5232 (frame,),
5233 0x51650906857ed4d4,
5234 fidl::encoding::DynamicFlags::empty(),
5235 _decode,
5236 )
5237 }
5238
5239 type OnWmmStatusRespResponseFut =
5240 fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5241 fn r#on_wmm_status_resp(
5242 &self,
5243 mut status: i32,
5244 mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
5245 ) -> Self::OnWmmStatusRespResponseFut {
5246 fn _decode(
5247 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5248 ) -> Result<(), fidl::Error> {
5249 let _response = fidl::client::decode_transaction_body::<
5250 fidl::encoding::EmptyPayload,
5251 fidl::encoding::DefaultFuchsiaResourceDialect,
5252 0x6823a88bf3ba8b2a,
5253 >(_buf?)?;
5254 Ok(_response)
5255 }
5256 self.client.send_query_and_decode::<WlanFullmacImplIfcOnWmmStatusRespRequest, ()>(
5257 (status, wmm_params),
5258 0x6823a88bf3ba8b2a,
5259 fidl::encoding::DynamicFlags::empty(),
5260 _decode,
5261 )
5262 }
5263}
5264
5265pub struct WlanFullmacImplIfcEventStream {
5266 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
5267}
5268
5269impl std::marker::Unpin for WlanFullmacImplIfcEventStream {}
5270
5271impl futures::stream::FusedStream for WlanFullmacImplIfcEventStream {
5272 fn is_terminated(&self) -> bool {
5273 self.event_receiver.is_terminated()
5274 }
5275}
5276
5277impl futures::Stream for WlanFullmacImplIfcEventStream {
5278 type Item = Result<WlanFullmacImplIfcEvent, fidl::Error>;
5279
5280 fn poll_next(
5281 mut self: std::pin::Pin<&mut Self>,
5282 cx: &mut std::task::Context<'_>,
5283 ) -> std::task::Poll<Option<Self::Item>> {
5284 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
5285 &mut self.event_receiver,
5286 cx
5287 )?) {
5288 Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImplIfcEvent::decode(buf))),
5289 None => std::task::Poll::Ready(None),
5290 }
5291 }
5292}
5293
5294#[derive(Debug)]
5295pub enum WlanFullmacImplIfcEvent {}
5296
5297impl WlanFullmacImplIfcEvent {
5298 fn decode(
5300 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
5301 ) -> Result<WlanFullmacImplIfcEvent, fidl::Error> {
5302 let (bytes, _handles) = buf.split_mut();
5303 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5304 debug_assert_eq!(tx_header.tx_id, 0);
5305 match tx_header.ordinal {
5306 _ => Err(fidl::Error::UnknownOrdinal {
5307 ordinal: tx_header.ordinal,
5308 protocol_name:
5309 <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5310 }),
5311 }
5312 }
5313}
5314
5315pub struct WlanFullmacImplIfcRequestStream {
5317 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5318 is_terminated: bool,
5319}
5320
5321impl std::marker::Unpin for WlanFullmacImplIfcRequestStream {}
5322
5323impl futures::stream::FusedStream for WlanFullmacImplIfcRequestStream {
5324 fn is_terminated(&self) -> bool {
5325 self.is_terminated
5326 }
5327}
5328
5329impl fidl::endpoints::RequestStream for WlanFullmacImplIfcRequestStream {
5330 type Protocol = WlanFullmacImplIfcMarker;
5331 type ControlHandle = WlanFullmacImplIfcControlHandle;
5332
5333 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
5334 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
5335 }
5336
5337 fn control_handle(&self) -> Self::ControlHandle {
5338 WlanFullmacImplIfcControlHandle { inner: self.inner.clone() }
5339 }
5340
5341 fn into_inner(
5342 self,
5343 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
5344 {
5345 (self.inner, self.is_terminated)
5346 }
5347
5348 fn from_inner(
5349 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5350 is_terminated: bool,
5351 ) -> Self {
5352 Self { inner, is_terminated }
5353 }
5354}
5355
5356impl futures::Stream for WlanFullmacImplIfcRequestStream {
5357 type Item = Result<WlanFullmacImplIfcRequest, fidl::Error>;
5358
5359 fn poll_next(
5360 mut self: std::pin::Pin<&mut Self>,
5361 cx: &mut std::task::Context<'_>,
5362 ) -> std::task::Poll<Option<Self::Item>> {
5363 let this = &mut *self;
5364 if this.inner.check_shutdown(cx) {
5365 this.is_terminated = true;
5366 return std::task::Poll::Ready(None);
5367 }
5368 if this.is_terminated {
5369 panic!("polled WlanFullmacImplIfcRequestStream after completion");
5370 }
5371 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
5372 |bytes, handles| {
5373 match this.inner.channel().read_etc(cx, bytes, handles) {
5374 std::task::Poll::Ready(Ok(())) => {}
5375 std::task::Poll::Pending => return std::task::Poll::Pending,
5376 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
5377 this.is_terminated = true;
5378 return std::task::Poll::Ready(None);
5379 }
5380 std::task::Poll::Ready(Err(e)) => {
5381 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
5382 e.into(),
5383 ))))
5384 }
5385 }
5386
5387 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5389
5390 std::task::Poll::Ready(Some(match header.ordinal {
5391 0x29aa81dc570f7a3e => {
5392 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5393 let mut req = fidl::new_empty!(WlanFullmacImplIfcOnScanResultRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5394 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnScanResultRequest>(&header, _body_bytes, handles, &mut req)?;
5395 let control_handle = WlanFullmacImplIfcControlHandle {
5396 inner: this.inner.clone(),
5397 };
5398 Ok(WlanFullmacImplIfcRequest::OnScanResult {payload: req,
5399 responder: WlanFullmacImplIfcOnScanResultResponder {
5400 control_handle: std::mem::ManuallyDrop::new(control_handle),
5401 tx_id: header.tx_id,
5402 },
5403 })
5404 }
5405 0x7cd8aff80d27073c => {
5406 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5407 let mut req = fidl::new_empty!(WlanFullmacImplIfcOnScanEndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5408 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnScanEndRequest>(&header, _body_bytes, handles, &mut req)?;
5409 let control_handle = WlanFullmacImplIfcControlHandle {
5410 inner: this.inner.clone(),
5411 };
5412 Ok(WlanFullmacImplIfcRequest::OnScanEnd {payload: req,
5413 responder: WlanFullmacImplIfcOnScanEndResponder {
5414 control_handle: std::mem::ManuallyDrop::new(control_handle),
5415 tx_id: header.tx_id,
5416 },
5417 })
5418 }
5419 0x3c22c6d80b2a2759 => {
5420 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5421 let mut req = fidl::new_empty!(WlanFullmacImplIfcConnectConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5422 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcConnectConfRequest>(&header, _body_bytes, handles, &mut req)?;
5423 let control_handle = WlanFullmacImplIfcControlHandle {
5424 inner: this.inner.clone(),
5425 };
5426 Ok(WlanFullmacImplIfcRequest::ConnectConf {payload: req,
5427 responder: WlanFullmacImplIfcConnectConfResponder {
5428 control_handle: std::mem::ManuallyDrop::new(control_handle),
5429 tx_id: header.tx_id,
5430 },
5431 })
5432 }
5433 0x368b2a5b903b3f7b => {
5434 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5435 let mut req = fidl::new_empty!(WlanFullmacImplIfcRoamConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5436 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcRoamConfRequest>(&header, _body_bytes, handles, &mut req)?;
5437 let control_handle = WlanFullmacImplIfcControlHandle {
5438 inner: this.inner.clone(),
5439 };
5440 Ok(WlanFullmacImplIfcRequest::RoamConf {payload: req,
5441 responder: WlanFullmacImplIfcRoamConfResponder {
5442 control_handle: std::mem::ManuallyDrop::new(control_handle),
5443 tx_id: header.tx_id,
5444 },
5445 })
5446 }
5447 0x23e1d9368935e7e4 => {
5448 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5449 let mut req = fidl::new_empty!(WlanFullmacImplIfcRoamStartIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5450 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcRoamStartIndRequest>(&header, _body_bytes, handles, &mut req)?;
5451 let control_handle = WlanFullmacImplIfcControlHandle {
5452 inner: this.inner.clone(),
5453 };
5454 Ok(WlanFullmacImplIfcRequest::RoamStartInd {payload: req,
5455 responder: WlanFullmacImplIfcRoamStartIndResponder {
5456 control_handle: std::mem::ManuallyDrop::new(control_handle),
5457 tx_id: header.tx_id,
5458 },
5459 })
5460 }
5461 0x7081c1b1ceea4914 => {
5462 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5463 let mut req = fidl::new_empty!(WlanFullmacImplIfcRoamResultIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5464 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcRoamResultIndRequest>(&header, _body_bytes, handles, &mut req)?;
5465 let control_handle = WlanFullmacImplIfcControlHandle {
5466 inner: this.inner.clone(),
5467 };
5468 Ok(WlanFullmacImplIfcRequest::RoamResultInd {payload: req,
5469 responder: WlanFullmacImplIfcRoamResultIndResponder {
5470 control_handle: std::mem::ManuallyDrop::new(control_handle),
5471 tx_id: header.tx_id,
5472 },
5473 })
5474 }
5475 0x270e1f8889650d0b => {
5476 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5477 let mut req = fidl::new_empty!(WlanFullmacImplIfcAuthIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5478 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcAuthIndRequest>(&header, _body_bytes, handles, &mut req)?;
5479 let control_handle = WlanFullmacImplIfcControlHandle {
5480 inner: this.inner.clone(),
5481 };
5482 Ok(WlanFullmacImplIfcRequest::AuthInd {payload: req,
5483 responder: WlanFullmacImplIfcAuthIndResponder {
5484 control_handle: std::mem::ManuallyDrop::new(control_handle),
5485 tx_id: header.tx_id,
5486 },
5487 })
5488 }
5489 0x2c94b0d7258111b7 => {
5490 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5491 let mut req = fidl::new_empty!(WlanFullmacImplIfcDeauthConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5492 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDeauthConfRequest>(&header, _body_bytes, handles, &mut req)?;
5493 let control_handle = WlanFullmacImplIfcControlHandle {
5494 inner: this.inner.clone(),
5495 };
5496 Ok(WlanFullmacImplIfcRequest::DeauthConf {payload: req,
5497 responder: WlanFullmacImplIfcDeauthConfResponder {
5498 control_handle: std::mem::ManuallyDrop::new(control_handle),
5499 tx_id: header.tx_id,
5500 },
5501 })
5502 }
5503 0x26cd27cdadd8dbaf => {
5504 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5505 let mut req = fidl::new_empty!(WlanFullmacImplIfcDeauthIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5506 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDeauthIndRequest>(&header, _body_bytes, handles, &mut req)?;
5507 let control_handle = WlanFullmacImplIfcControlHandle {
5508 inner: this.inner.clone(),
5509 };
5510 Ok(WlanFullmacImplIfcRequest::DeauthInd {payload: req,
5511 responder: WlanFullmacImplIfcDeauthIndResponder {
5512 control_handle: std::mem::ManuallyDrop::new(control_handle),
5513 tx_id: header.tx_id,
5514 },
5515 })
5516 }
5517 0x3e44529e3dc179ce => {
5518 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5519 let mut req = fidl::new_empty!(WlanFullmacImplIfcAssocIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5520 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcAssocIndRequest>(&header, _body_bytes, handles, &mut req)?;
5521 let control_handle = WlanFullmacImplIfcControlHandle {
5522 inner: this.inner.clone(),
5523 };
5524 Ok(WlanFullmacImplIfcRequest::AssocInd {payload: req,
5525 responder: WlanFullmacImplIfcAssocIndResponder {
5526 control_handle: std::mem::ManuallyDrop::new(control_handle),
5527 tx_id: header.tx_id,
5528 },
5529 })
5530 }
5531 0x7c713bcd58a76cb3 => {
5532 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5533 let mut req = fidl::new_empty!(WlanFullmacImplIfcDisassocConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5534 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDisassocConfRequest>(&header, _body_bytes, handles, &mut req)?;
5535 let control_handle = WlanFullmacImplIfcControlHandle {
5536 inner: this.inner.clone(),
5537 };
5538 Ok(WlanFullmacImplIfcRequest::DisassocConf {payload: req,
5539 responder: WlanFullmacImplIfcDisassocConfResponder {
5540 control_handle: std::mem::ManuallyDrop::new(control_handle),
5541 tx_id: header.tx_id,
5542 },
5543 })
5544 }
5545 0x6667b381b7f3990f => {
5546 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5547 let mut req = fidl::new_empty!(WlanFullmacImplIfcDisassocIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5548 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDisassocIndRequest>(&header, _body_bytes, handles, &mut req)?;
5549 let control_handle = WlanFullmacImplIfcControlHandle {
5550 inner: this.inner.clone(),
5551 };
5552 Ok(WlanFullmacImplIfcRequest::DisassocInd {payload: req,
5553 responder: WlanFullmacImplIfcDisassocIndResponder {
5554 control_handle: std::mem::ManuallyDrop::new(control_handle),
5555 tx_id: header.tx_id,
5556 },
5557 })
5558 }
5559 0x3e9b9641f3ddc7fc => {
5560 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5561 let mut req = fidl::new_empty!(WlanFullmacImplIfcStartConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5562 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcStartConfRequest>(&header, _body_bytes, handles, &mut req)?;
5563 let control_handle = WlanFullmacImplIfcControlHandle {
5564 inner: this.inner.clone(),
5565 };
5566 Ok(WlanFullmacImplIfcRequest::StartConf {payload: req,
5567 responder: WlanFullmacImplIfcStartConfResponder {
5568 control_handle: std::mem::ManuallyDrop::new(control_handle),
5569 tx_id: header.tx_id,
5570 },
5571 })
5572 }
5573 0x320a5ff227a4e9df => {
5574 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5575 let mut req = fidl::new_empty!(WlanFullmacImplIfcStopConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5576 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcStopConfRequest>(&header, _body_bytes, handles, &mut req)?;
5577 let control_handle = WlanFullmacImplIfcControlHandle {
5578 inner: this.inner.clone(),
5579 };
5580 Ok(WlanFullmacImplIfcRequest::StopConf {payload: req,
5581 responder: WlanFullmacImplIfcStopConfResponder {
5582 control_handle: std::mem::ManuallyDrop::new(control_handle),
5583 tx_id: header.tx_id,
5584 },
5585 })
5586 }
5587 0x77364db9cc3970ec => {
5588 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5589 let mut req = fidl::new_empty!(WlanFullmacImplIfcEapolConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5590 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcEapolConfRequest>(&header, _body_bytes, handles, &mut req)?;
5591 let control_handle = WlanFullmacImplIfcControlHandle {
5592 inner: this.inner.clone(),
5593 };
5594 Ok(WlanFullmacImplIfcRequest::EapolConf {payload: req,
5595 responder: WlanFullmacImplIfcEapolConfResponder {
5596 control_handle: std::mem::ManuallyDrop::new(control_handle),
5597 tx_id: header.tx_id,
5598 },
5599 })
5600 }
5601 0x21db0b8f71cae647 => {
5602 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5603 let mut req = fidl::new_empty!(WlanFullmacImplIfcOnChannelSwitchRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5604 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnChannelSwitchRequest>(&header, _body_bytes, handles, &mut req)?;
5605 let control_handle = WlanFullmacImplIfcControlHandle {
5606 inner: this.inner.clone(),
5607 };
5608 Ok(WlanFullmacImplIfcRequest::OnChannelSwitch {ind: req.ind,
5609
5610 responder: WlanFullmacImplIfcOnChannelSwitchResponder {
5611 control_handle: std::mem::ManuallyDrop::new(control_handle),
5612 tx_id: header.tx_id,
5613 },
5614 })
5615 }
5616 0x79679fa8789c3d9f => {
5617 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5618 let mut req = fidl::new_empty!(WlanFullmacImplIfcSignalReportRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5619 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcSignalReportRequest>(&header, _body_bytes, handles, &mut req)?;
5620 let control_handle = WlanFullmacImplIfcControlHandle {
5621 inner: this.inner.clone(),
5622 };
5623 Ok(WlanFullmacImplIfcRequest::SignalReport {ind: req.ind,
5624
5625 responder: WlanFullmacImplIfcSignalReportResponder {
5626 control_handle: std::mem::ManuallyDrop::new(control_handle),
5627 tx_id: header.tx_id,
5628 },
5629 })
5630 }
5631 0x3de8ec1eda10d1d0 => {
5632 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5633 let mut req = fidl::new_empty!(WlanFullmacImplIfcEapolIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5634 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcEapolIndRequest>(&header, _body_bytes, handles, &mut req)?;
5635 let control_handle = WlanFullmacImplIfcControlHandle {
5636 inner: this.inner.clone(),
5637 };
5638 Ok(WlanFullmacImplIfcRequest::EapolInd {payload: req,
5639 responder: WlanFullmacImplIfcEapolIndResponder {
5640 control_handle: std::mem::ManuallyDrop::new(control_handle),
5641 tx_id: header.tx_id,
5642 },
5643 })
5644 }
5645 0x5cedd8d9be28a17e => {
5646 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5647 let mut req = fidl::new_empty!(WlanFullmacImplIfcOnPmkAvailableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5648 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnPmkAvailableRequest>(&header, _body_bytes, handles, &mut req)?;
5649 let control_handle = WlanFullmacImplIfcControlHandle {
5650 inner: this.inner.clone(),
5651 };
5652 Ok(WlanFullmacImplIfcRequest::OnPmkAvailable {payload: req,
5653 responder: WlanFullmacImplIfcOnPmkAvailableResponder {
5654 control_handle: std::mem::ManuallyDrop::new(control_handle),
5655 tx_id: header.tx_id,
5656 },
5657 })
5658 }
5659 0x4f3d53885503a1d8 => {
5660 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5661 let mut req = fidl::new_empty!(WlanFullmacImplIfcSaeHandshakeIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5662 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcSaeHandshakeIndRequest>(&header, _body_bytes, handles, &mut req)?;
5663 let control_handle = WlanFullmacImplIfcControlHandle {
5664 inner: this.inner.clone(),
5665 };
5666 Ok(WlanFullmacImplIfcRequest::SaeHandshakeInd {payload: req,
5667 responder: WlanFullmacImplIfcSaeHandshakeIndResponder {
5668 control_handle: std::mem::ManuallyDrop::new(control_handle),
5669 tx_id: header.tx_id,
5670 },
5671 })
5672 }
5673 0x51650906857ed4d4 => {
5674 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5675 let mut req = fidl::new_empty!(WlanFullmacImplIfcSaeFrameRxRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5676 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcSaeFrameRxRequest>(&header, _body_bytes, handles, &mut req)?;
5677 let control_handle = WlanFullmacImplIfcControlHandle {
5678 inner: this.inner.clone(),
5679 };
5680 Ok(WlanFullmacImplIfcRequest::SaeFrameRx {frame: req.frame,
5681
5682 responder: WlanFullmacImplIfcSaeFrameRxResponder {
5683 control_handle: std::mem::ManuallyDrop::new(control_handle),
5684 tx_id: header.tx_id,
5685 },
5686 })
5687 }
5688 0x6823a88bf3ba8b2a => {
5689 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5690 let mut req = fidl::new_empty!(WlanFullmacImplIfcOnWmmStatusRespRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5691 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnWmmStatusRespRequest>(&header, _body_bytes, handles, &mut req)?;
5692 let control_handle = WlanFullmacImplIfcControlHandle {
5693 inner: this.inner.clone(),
5694 };
5695 Ok(WlanFullmacImplIfcRequest::OnWmmStatusResp {status: req.status,
5696wmm_params: req.wmm_params,
5697
5698 responder: WlanFullmacImplIfcOnWmmStatusRespResponder {
5699 control_handle: std::mem::ManuallyDrop::new(control_handle),
5700 tx_id: header.tx_id,
5701 },
5702 })
5703 }
5704 _ => Err(fidl::Error::UnknownOrdinal {
5705 ordinal: header.ordinal,
5706 protocol_name: <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5707 }),
5708 }))
5709 },
5710 )
5711 }
5712}
5713
5714#[derive(Debug)]
5716pub enum WlanFullmacImplIfcRequest {
5717 OnScanResult {
5718 payload: WlanFullmacImplIfcOnScanResultRequest,
5719 responder: WlanFullmacImplIfcOnScanResultResponder,
5720 },
5721 OnScanEnd {
5722 payload: WlanFullmacImplIfcOnScanEndRequest,
5723 responder: WlanFullmacImplIfcOnScanEndResponder,
5724 },
5725 ConnectConf {
5726 payload: WlanFullmacImplIfcConnectConfRequest,
5727 responder: WlanFullmacImplIfcConnectConfResponder,
5728 },
5729 RoamConf {
5731 payload: WlanFullmacImplIfcRoamConfRequest,
5732 responder: WlanFullmacImplIfcRoamConfResponder,
5733 },
5734 RoamStartInd {
5737 payload: WlanFullmacImplIfcRoamStartIndRequest,
5738 responder: WlanFullmacImplIfcRoamStartIndResponder,
5739 },
5740 RoamResultInd {
5742 payload: WlanFullmacImplIfcRoamResultIndRequest,
5743 responder: WlanFullmacImplIfcRoamResultIndResponder,
5744 },
5745 AuthInd {
5746 payload: WlanFullmacImplIfcAuthIndRequest,
5747 responder: WlanFullmacImplIfcAuthIndResponder,
5748 },
5749 DeauthConf {
5750 payload: WlanFullmacImplIfcDeauthConfRequest,
5751 responder: WlanFullmacImplIfcDeauthConfResponder,
5752 },
5753 DeauthInd {
5755 payload: WlanFullmacImplIfcDeauthIndRequest,
5756 responder: WlanFullmacImplIfcDeauthIndResponder,
5757 },
5758 AssocInd {
5759 payload: WlanFullmacImplIfcAssocIndRequest,
5760 responder: WlanFullmacImplIfcAssocIndResponder,
5761 },
5762 DisassocConf {
5764 payload: WlanFullmacImplIfcDisassocConfRequest,
5765 responder: WlanFullmacImplIfcDisassocConfResponder,
5766 },
5767 DisassocInd {
5769 payload: WlanFullmacImplIfcDisassocIndRequest,
5770 responder: WlanFullmacImplIfcDisassocIndResponder,
5771 },
5772 StartConf {
5774 payload: WlanFullmacImplIfcStartConfRequest,
5775 responder: WlanFullmacImplIfcStartConfResponder,
5776 },
5777 StopConf {
5779 payload: WlanFullmacImplIfcStopConfRequest,
5780 responder: WlanFullmacImplIfcStopConfResponder,
5781 },
5782 EapolConf {
5785 payload: WlanFullmacImplIfcEapolConfRequest,
5786 responder: WlanFullmacImplIfcEapolConfResponder,
5787 },
5788 OnChannelSwitch {
5789 ind: WlanFullmacChannelSwitchInfo,
5790 responder: WlanFullmacImplIfcOnChannelSwitchResponder,
5791 },
5792 SignalReport {
5793 ind: WlanFullmacSignalReportIndication,
5794 responder: WlanFullmacImplIfcSignalReportResponder,
5795 },
5796 EapolInd {
5798 payload: WlanFullmacImplIfcEapolIndRequest,
5799 responder: WlanFullmacImplIfcEapolIndResponder,
5800 },
5801 OnPmkAvailable {
5803 payload: WlanFullmacImplIfcOnPmkAvailableRequest,
5804 responder: WlanFullmacImplIfcOnPmkAvailableResponder,
5805 },
5806 SaeHandshakeInd {
5807 payload: WlanFullmacImplIfcSaeHandshakeIndRequest,
5808 responder: WlanFullmacImplIfcSaeHandshakeIndResponder,
5809 },
5810 SaeFrameRx { frame: SaeFrame, responder: WlanFullmacImplIfcSaeFrameRxResponder },
5812 OnWmmStatusResp {
5813 status: i32,
5814 wmm_params: fidl_fuchsia_wlan_common::WlanWmmParameters,
5815 responder: WlanFullmacImplIfcOnWmmStatusRespResponder,
5816 },
5817}
5818
5819impl WlanFullmacImplIfcRequest {
5820 #[allow(irrefutable_let_patterns)]
5821 pub fn into_on_scan_result(
5822 self,
5823 ) -> Option<(WlanFullmacImplIfcOnScanResultRequest, WlanFullmacImplIfcOnScanResultResponder)>
5824 {
5825 if let WlanFullmacImplIfcRequest::OnScanResult { payload, responder } = self {
5826 Some((payload, responder))
5827 } else {
5828 None
5829 }
5830 }
5831
5832 #[allow(irrefutable_let_patterns)]
5833 pub fn into_on_scan_end(
5834 self,
5835 ) -> Option<(WlanFullmacImplIfcOnScanEndRequest, WlanFullmacImplIfcOnScanEndResponder)> {
5836 if let WlanFullmacImplIfcRequest::OnScanEnd { payload, responder } = self {
5837 Some((payload, responder))
5838 } else {
5839 None
5840 }
5841 }
5842
5843 #[allow(irrefutable_let_patterns)]
5844 pub fn into_connect_conf(
5845 self,
5846 ) -> Option<(WlanFullmacImplIfcConnectConfRequest, WlanFullmacImplIfcConnectConfResponder)>
5847 {
5848 if let WlanFullmacImplIfcRequest::ConnectConf { payload, responder } = self {
5849 Some((payload, responder))
5850 } else {
5851 None
5852 }
5853 }
5854
5855 #[allow(irrefutable_let_patterns)]
5856 pub fn into_roam_conf(
5857 self,
5858 ) -> Option<(WlanFullmacImplIfcRoamConfRequest, WlanFullmacImplIfcRoamConfResponder)> {
5859 if let WlanFullmacImplIfcRequest::RoamConf { payload, responder } = self {
5860 Some((payload, responder))
5861 } else {
5862 None
5863 }
5864 }
5865
5866 #[allow(irrefutable_let_patterns)]
5867 pub fn into_roam_start_ind(
5868 self,
5869 ) -> Option<(WlanFullmacImplIfcRoamStartIndRequest, WlanFullmacImplIfcRoamStartIndResponder)>
5870 {
5871 if let WlanFullmacImplIfcRequest::RoamStartInd { payload, responder } = self {
5872 Some((payload, responder))
5873 } else {
5874 None
5875 }
5876 }
5877
5878 #[allow(irrefutable_let_patterns)]
5879 pub fn into_roam_result_ind(
5880 self,
5881 ) -> Option<(WlanFullmacImplIfcRoamResultIndRequest, WlanFullmacImplIfcRoamResultIndResponder)>
5882 {
5883 if let WlanFullmacImplIfcRequest::RoamResultInd { payload, responder } = self {
5884 Some((payload, responder))
5885 } else {
5886 None
5887 }
5888 }
5889
5890 #[allow(irrefutable_let_patterns)]
5891 pub fn into_auth_ind(
5892 self,
5893 ) -> Option<(WlanFullmacImplIfcAuthIndRequest, WlanFullmacImplIfcAuthIndResponder)> {
5894 if let WlanFullmacImplIfcRequest::AuthInd { payload, responder } = self {
5895 Some((payload, responder))
5896 } else {
5897 None
5898 }
5899 }
5900
5901 #[allow(irrefutable_let_patterns)]
5902 pub fn into_deauth_conf(
5903 self,
5904 ) -> Option<(WlanFullmacImplIfcDeauthConfRequest, WlanFullmacImplIfcDeauthConfResponder)> {
5905 if let WlanFullmacImplIfcRequest::DeauthConf { payload, responder } = self {
5906 Some((payload, responder))
5907 } else {
5908 None
5909 }
5910 }
5911
5912 #[allow(irrefutable_let_patterns)]
5913 pub fn into_deauth_ind(
5914 self,
5915 ) -> Option<(WlanFullmacImplIfcDeauthIndRequest, WlanFullmacImplIfcDeauthIndResponder)> {
5916 if let WlanFullmacImplIfcRequest::DeauthInd { payload, responder } = self {
5917 Some((payload, responder))
5918 } else {
5919 None
5920 }
5921 }
5922
5923 #[allow(irrefutable_let_patterns)]
5924 pub fn into_assoc_ind(
5925 self,
5926 ) -> Option<(WlanFullmacImplIfcAssocIndRequest, WlanFullmacImplIfcAssocIndResponder)> {
5927 if let WlanFullmacImplIfcRequest::AssocInd { payload, responder } = self {
5928 Some((payload, responder))
5929 } else {
5930 None
5931 }
5932 }
5933
5934 #[allow(irrefutable_let_patterns)]
5935 pub fn into_disassoc_conf(
5936 self,
5937 ) -> Option<(WlanFullmacImplIfcDisassocConfRequest, WlanFullmacImplIfcDisassocConfResponder)>
5938 {
5939 if let WlanFullmacImplIfcRequest::DisassocConf { payload, responder } = self {
5940 Some((payload, responder))
5941 } else {
5942 None
5943 }
5944 }
5945
5946 #[allow(irrefutable_let_patterns)]
5947 pub fn into_disassoc_ind(
5948 self,
5949 ) -> Option<(WlanFullmacImplIfcDisassocIndRequest, WlanFullmacImplIfcDisassocIndResponder)>
5950 {
5951 if let WlanFullmacImplIfcRequest::DisassocInd { payload, responder } = self {
5952 Some((payload, responder))
5953 } else {
5954 None
5955 }
5956 }
5957
5958 #[allow(irrefutable_let_patterns)]
5959 pub fn into_start_conf(
5960 self,
5961 ) -> Option<(WlanFullmacImplIfcStartConfRequest, WlanFullmacImplIfcStartConfResponder)> {
5962 if let WlanFullmacImplIfcRequest::StartConf { payload, responder } = self {
5963 Some((payload, responder))
5964 } else {
5965 None
5966 }
5967 }
5968
5969 #[allow(irrefutable_let_patterns)]
5970 pub fn into_stop_conf(
5971 self,
5972 ) -> Option<(WlanFullmacImplIfcStopConfRequest, WlanFullmacImplIfcStopConfResponder)> {
5973 if let WlanFullmacImplIfcRequest::StopConf { payload, responder } = self {
5974 Some((payload, responder))
5975 } else {
5976 None
5977 }
5978 }
5979
5980 #[allow(irrefutable_let_patterns)]
5981 pub fn into_eapol_conf(
5982 self,
5983 ) -> Option<(WlanFullmacImplIfcEapolConfRequest, WlanFullmacImplIfcEapolConfResponder)> {
5984 if let WlanFullmacImplIfcRequest::EapolConf { payload, responder } = self {
5985 Some((payload, responder))
5986 } else {
5987 None
5988 }
5989 }
5990
5991 #[allow(irrefutable_let_patterns)]
5992 pub fn into_on_channel_switch(
5993 self,
5994 ) -> Option<(WlanFullmacChannelSwitchInfo, WlanFullmacImplIfcOnChannelSwitchResponder)> {
5995 if let WlanFullmacImplIfcRequest::OnChannelSwitch { ind, responder } = self {
5996 Some((ind, responder))
5997 } else {
5998 None
5999 }
6000 }
6001
6002 #[allow(irrefutable_let_patterns)]
6003 pub fn into_signal_report(
6004 self,
6005 ) -> Option<(WlanFullmacSignalReportIndication, WlanFullmacImplIfcSignalReportResponder)> {
6006 if let WlanFullmacImplIfcRequest::SignalReport { ind, responder } = self {
6007 Some((ind, responder))
6008 } else {
6009 None
6010 }
6011 }
6012
6013 #[allow(irrefutable_let_patterns)]
6014 pub fn into_eapol_ind(
6015 self,
6016 ) -> Option<(WlanFullmacImplIfcEapolIndRequest, WlanFullmacImplIfcEapolIndResponder)> {
6017 if let WlanFullmacImplIfcRequest::EapolInd { payload, responder } = self {
6018 Some((payload, responder))
6019 } else {
6020 None
6021 }
6022 }
6023
6024 #[allow(irrefutable_let_patterns)]
6025 pub fn into_on_pmk_available(
6026 self,
6027 ) -> Option<(WlanFullmacImplIfcOnPmkAvailableRequest, WlanFullmacImplIfcOnPmkAvailableResponder)>
6028 {
6029 if let WlanFullmacImplIfcRequest::OnPmkAvailable { payload, responder } = self {
6030 Some((payload, responder))
6031 } else {
6032 None
6033 }
6034 }
6035
6036 #[allow(irrefutable_let_patterns)]
6037 pub fn into_sae_handshake_ind(
6038 self,
6039 ) -> Option<(
6040 WlanFullmacImplIfcSaeHandshakeIndRequest,
6041 WlanFullmacImplIfcSaeHandshakeIndResponder,
6042 )> {
6043 if let WlanFullmacImplIfcRequest::SaeHandshakeInd { payload, responder } = self {
6044 Some((payload, responder))
6045 } else {
6046 None
6047 }
6048 }
6049
6050 #[allow(irrefutable_let_patterns)]
6051 pub fn into_sae_frame_rx(self) -> Option<(SaeFrame, WlanFullmacImplIfcSaeFrameRxResponder)> {
6052 if let WlanFullmacImplIfcRequest::SaeFrameRx { frame, responder } = self {
6053 Some((frame, responder))
6054 } else {
6055 None
6056 }
6057 }
6058
6059 #[allow(irrefutable_let_patterns)]
6060 pub fn into_on_wmm_status_resp(
6061 self,
6062 ) -> Option<(
6063 i32,
6064 fidl_fuchsia_wlan_common::WlanWmmParameters,
6065 WlanFullmacImplIfcOnWmmStatusRespResponder,
6066 )> {
6067 if let WlanFullmacImplIfcRequest::OnWmmStatusResp { status, wmm_params, responder } = self {
6068 Some((status, wmm_params, responder))
6069 } else {
6070 None
6071 }
6072 }
6073
6074 pub fn method_name(&self) -> &'static str {
6076 match *self {
6077 WlanFullmacImplIfcRequest::OnScanResult { .. } => "on_scan_result",
6078 WlanFullmacImplIfcRequest::OnScanEnd { .. } => "on_scan_end",
6079 WlanFullmacImplIfcRequest::ConnectConf { .. } => "connect_conf",
6080 WlanFullmacImplIfcRequest::RoamConf { .. } => "roam_conf",
6081 WlanFullmacImplIfcRequest::RoamStartInd { .. } => "roam_start_ind",
6082 WlanFullmacImplIfcRequest::RoamResultInd { .. } => "roam_result_ind",
6083 WlanFullmacImplIfcRequest::AuthInd { .. } => "auth_ind",
6084 WlanFullmacImplIfcRequest::DeauthConf { .. } => "deauth_conf",
6085 WlanFullmacImplIfcRequest::DeauthInd { .. } => "deauth_ind",
6086 WlanFullmacImplIfcRequest::AssocInd { .. } => "assoc_ind",
6087 WlanFullmacImplIfcRequest::DisassocConf { .. } => "disassoc_conf",
6088 WlanFullmacImplIfcRequest::DisassocInd { .. } => "disassoc_ind",
6089 WlanFullmacImplIfcRequest::StartConf { .. } => "start_conf",
6090 WlanFullmacImplIfcRequest::StopConf { .. } => "stop_conf",
6091 WlanFullmacImplIfcRequest::EapolConf { .. } => "eapol_conf",
6092 WlanFullmacImplIfcRequest::OnChannelSwitch { .. } => "on_channel_switch",
6093 WlanFullmacImplIfcRequest::SignalReport { .. } => "signal_report",
6094 WlanFullmacImplIfcRequest::EapolInd { .. } => "eapol_ind",
6095 WlanFullmacImplIfcRequest::OnPmkAvailable { .. } => "on_pmk_available",
6096 WlanFullmacImplIfcRequest::SaeHandshakeInd { .. } => "sae_handshake_ind",
6097 WlanFullmacImplIfcRequest::SaeFrameRx { .. } => "sae_frame_rx",
6098 WlanFullmacImplIfcRequest::OnWmmStatusResp { .. } => "on_wmm_status_resp",
6099 }
6100 }
6101}
6102
6103#[derive(Debug, Clone)]
6104pub struct WlanFullmacImplIfcControlHandle {
6105 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6106}
6107
6108impl fidl::endpoints::ControlHandle for WlanFullmacImplIfcControlHandle {
6109 fn shutdown(&self) {
6110 self.inner.shutdown()
6111 }
6112 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
6113 self.inner.shutdown_with_epitaph(status)
6114 }
6115
6116 fn is_closed(&self) -> bool {
6117 self.inner.channel().is_closed()
6118 }
6119 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
6120 self.inner.channel().on_closed()
6121 }
6122
6123 #[cfg(target_os = "fuchsia")]
6124 fn signal_peer(
6125 &self,
6126 clear_mask: zx::Signals,
6127 set_mask: zx::Signals,
6128 ) -> Result<(), zx_status::Status> {
6129 use fidl::Peered;
6130 self.inner.channel().signal_peer(clear_mask, set_mask)
6131 }
6132}
6133
6134impl WlanFullmacImplIfcControlHandle {}
6135
6136#[must_use = "FIDL methods require a response to be sent"]
6137#[derive(Debug)]
6138pub struct WlanFullmacImplIfcOnScanResultResponder {
6139 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6140 tx_id: u32,
6141}
6142
6143impl std::ops::Drop for WlanFullmacImplIfcOnScanResultResponder {
6147 fn drop(&mut self) {
6148 self.control_handle.shutdown();
6149 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6151 }
6152}
6153
6154impl fidl::endpoints::Responder for WlanFullmacImplIfcOnScanResultResponder {
6155 type ControlHandle = WlanFullmacImplIfcControlHandle;
6156
6157 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6158 &self.control_handle
6159 }
6160
6161 fn drop_without_shutdown(mut self) {
6162 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6164 std::mem::forget(self);
6166 }
6167}
6168
6169impl WlanFullmacImplIfcOnScanResultResponder {
6170 pub fn send(self) -> Result<(), fidl::Error> {
6174 let _result = self.send_raw();
6175 if _result.is_err() {
6176 self.control_handle.shutdown();
6177 }
6178 self.drop_without_shutdown();
6179 _result
6180 }
6181
6182 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6184 let _result = self.send_raw();
6185 self.drop_without_shutdown();
6186 _result
6187 }
6188
6189 fn send_raw(&self) -> Result<(), fidl::Error> {
6190 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6191 (),
6192 self.tx_id,
6193 0x29aa81dc570f7a3e,
6194 fidl::encoding::DynamicFlags::empty(),
6195 )
6196 }
6197}
6198
6199#[must_use = "FIDL methods require a response to be sent"]
6200#[derive(Debug)]
6201pub struct WlanFullmacImplIfcOnScanEndResponder {
6202 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6203 tx_id: u32,
6204}
6205
6206impl std::ops::Drop for WlanFullmacImplIfcOnScanEndResponder {
6210 fn drop(&mut self) {
6211 self.control_handle.shutdown();
6212 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6214 }
6215}
6216
6217impl fidl::endpoints::Responder for WlanFullmacImplIfcOnScanEndResponder {
6218 type ControlHandle = WlanFullmacImplIfcControlHandle;
6219
6220 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6221 &self.control_handle
6222 }
6223
6224 fn drop_without_shutdown(mut self) {
6225 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6227 std::mem::forget(self);
6229 }
6230}
6231
6232impl WlanFullmacImplIfcOnScanEndResponder {
6233 pub fn send(self) -> Result<(), fidl::Error> {
6237 let _result = self.send_raw();
6238 if _result.is_err() {
6239 self.control_handle.shutdown();
6240 }
6241 self.drop_without_shutdown();
6242 _result
6243 }
6244
6245 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6247 let _result = self.send_raw();
6248 self.drop_without_shutdown();
6249 _result
6250 }
6251
6252 fn send_raw(&self) -> Result<(), fidl::Error> {
6253 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6254 (),
6255 self.tx_id,
6256 0x7cd8aff80d27073c,
6257 fidl::encoding::DynamicFlags::empty(),
6258 )
6259 }
6260}
6261
6262#[must_use = "FIDL methods require a response to be sent"]
6263#[derive(Debug)]
6264pub struct WlanFullmacImplIfcConnectConfResponder {
6265 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6266 tx_id: u32,
6267}
6268
6269impl std::ops::Drop for WlanFullmacImplIfcConnectConfResponder {
6273 fn drop(&mut self) {
6274 self.control_handle.shutdown();
6275 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6277 }
6278}
6279
6280impl fidl::endpoints::Responder for WlanFullmacImplIfcConnectConfResponder {
6281 type ControlHandle = WlanFullmacImplIfcControlHandle;
6282
6283 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6284 &self.control_handle
6285 }
6286
6287 fn drop_without_shutdown(mut self) {
6288 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6290 std::mem::forget(self);
6292 }
6293}
6294
6295impl WlanFullmacImplIfcConnectConfResponder {
6296 pub fn send(self) -> Result<(), fidl::Error> {
6300 let _result = self.send_raw();
6301 if _result.is_err() {
6302 self.control_handle.shutdown();
6303 }
6304 self.drop_without_shutdown();
6305 _result
6306 }
6307
6308 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6310 let _result = self.send_raw();
6311 self.drop_without_shutdown();
6312 _result
6313 }
6314
6315 fn send_raw(&self) -> Result<(), fidl::Error> {
6316 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6317 (),
6318 self.tx_id,
6319 0x3c22c6d80b2a2759,
6320 fidl::encoding::DynamicFlags::empty(),
6321 )
6322 }
6323}
6324
6325#[must_use = "FIDL methods require a response to be sent"]
6326#[derive(Debug)]
6327pub struct WlanFullmacImplIfcRoamConfResponder {
6328 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6329 tx_id: u32,
6330}
6331
6332impl std::ops::Drop for WlanFullmacImplIfcRoamConfResponder {
6336 fn drop(&mut self) {
6337 self.control_handle.shutdown();
6338 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6340 }
6341}
6342
6343impl fidl::endpoints::Responder for WlanFullmacImplIfcRoamConfResponder {
6344 type ControlHandle = WlanFullmacImplIfcControlHandle;
6345
6346 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6347 &self.control_handle
6348 }
6349
6350 fn drop_without_shutdown(mut self) {
6351 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6353 std::mem::forget(self);
6355 }
6356}
6357
6358impl WlanFullmacImplIfcRoamConfResponder {
6359 pub fn send(self) -> Result<(), fidl::Error> {
6363 let _result = self.send_raw();
6364 if _result.is_err() {
6365 self.control_handle.shutdown();
6366 }
6367 self.drop_without_shutdown();
6368 _result
6369 }
6370
6371 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6373 let _result = self.send_raw();
6374 self.drop_without_shutdown();
6375 _result
6376 }
6377
6378 fn send_raw(&self) -> Result<(), fidl::Error> {
6379 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6380 (),
6381 self.tx_id,
6382 0x368b2a5b903b3f7b,
6383 fidl::encoding::DynamicFlags::empty(),
6384 )
6385 }
6386}
6387
6388#[must_use = "FIDL methods require a response to be sent"]
6389#[derive(Debug)]
6390pub struct WlanFullmacImplIfcRoamStartIndResponder {
6391 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6392 tx_id: u32,
6393}
6394
6395impl std::ops::Drop for WlanFullmacImplIfcRoamStartIndResponder {
6399 fn drop(&mut self) {
6400 self.control_handle.shutdown();
6401 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6403 }
6404}
6405
6406impl fidl::endpoints::Responder for WlanFullmacImplIfcRoamStartIndResponder {
6407 type ControlHandle = WlanFullmacImplIfcControlHandle;
6408
6409 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6410 &self.control_handle
6411 }
6412
6413 fn drop_without_shutdown(mut self) {
6414 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6416 std::mem::forget(self);
6418 }
6419}
6420
6421impl WlanFullmacImplIfcRoamStartIndResponder {
6422 pub fn send(self) -> Result<(), fidl::Error> {
6426 let _result = self.send_raw();
6427 if _result.is_err() {
6428 self.control_handle.shutdown();
6429 }
6430 self.drop_without_shutdown();
6431 _result
6432 }
6433
6434 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6436 let _result = self.send_raw();
6437 self.drop_without_shutdown();
6438 _result
6439 }
6440
6441 fn send_raw(&self) -> Result<(), fidl::Error> {
6442 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6443 (),
6444 self.tx_id,
6445 0x23e1d9368935e7e4,
6446 fidl::encoding::DynamicFlags::empty(),
6447 )
6448 }
6449}
6450
6451#[must_use = "FIDL methods require a response to be sent"]
6452#[derive(Debug)]
6453pub struct WlanFullmacImplIfcRoamResultIndResponder {
6454 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6455 tx_id: u32,
6456}
6457
6458impl std::ops::Drop for WlanFullmacImplIfcRoamResultIndResponder {
6462 fn drop(&mut self) {
6463 self.control_handle.shutdown();
6464 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6466 }
6467}
6468
6469impl fidl::endpoints::Responder for WlanFullmacImplIfcRoamResultIndResponder {
6470 type ControlHandle = WlanFullmacImplIfcControlHandle;
6471
6472 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6473 &self.control_handle
6474 }
6475
6476 fn drop_without_shutdown(mut self) {
6477 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6479 std::mem::forget(self);
6481 }
6482}
6483
6484impl WlanFullmacImplIfcRoamResultIndResponder {
6485 pub fn send(self) -> Result<(), fidl::Error> {
6489 let _result = self.send_raw();
6490 if _result.is_err() {
6491 self.control_handle.shutdown();
6492 }
6493 self.drop_without_shutdown();
6494 _result
6495 }
6496
6497 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6499 let _result = self.send_raw();
6500 self.drop_without_shutdown();
6501 _result
6502 }
6503
6504 fn send_raw(&self) -> Result<(), fidl::Error> {
6505 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6506 (),
6507 self.tx_id,
6508 0x7081c1b1ceea4914,
6509 fidl::encoding::DynamicFlags::empty(),
6510 )
6511 }
6512}
6513
6514#[must_use = "FIDL methods require a response to be sent"]
6515#[derive(Debug)]
6516pub struct WlanFullmacImplIfcAuthIndResponder {
6517 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6518 tx_id: u32,
6519}
6520
6521impl std::ops::Drop for WlanFullmacImplIfcAuthIndResponder {
6525 fn drop(&mut self) {
6526 self.control_handle.shutdown();
6527 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6529 }
6530}
6531
6532impl fidl::endpoints::Responder for WlanFullmacImplIfcAuthIndResponder {
6533 type ControlHandle = WlanFullmacImplIfcControlHandle;
6534
6535 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6536 &self.control_handle
6537 }
6538
6539 fn drop_without_shutdown(mut self) {
6540 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6542 std::mem::forget(self);
6544 }
6545}
6546
6547impl WlanFullmacImplIfcAuthIndResponder {
6548 pub fn send(self) -> Result<(), fidl::Error> {
6552 let _result = self.send_raw();
6553 if _result.is_err() {
6554 self.control_handle.shutdown();
6555 }
6556 self.drop_without_shutdown();
6557 _result
6558 }
6559
6560 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6562 let _result = self.send_raw();
6563 self.drop_without_shutdown();
6564 _result
6565 }
6566
6567 fn send_raw(&self) -> Result<(), fidl::Error> {
6568 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6569 (),
6570 self.tx_id,
6571 0x270e1f8889650d0b,
6572 fidl::encoding::DynamicFlags::empty(),
6573 )
6574 }
6575}
6576
6577#[must_use = "FIDL methods require a response to be sent"]
6578#[derive(Debug)]
6579pub struct WlanFullmacImplIfcDeauthConfResponder {
6580 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6581 tx_id: u32,
6582}
6583
6584impl std::ops::Drop for WlanFullmacImplIfcDeauthConfResponder {
6588 fn drop(&mut self) {
6589 self.control_handle.shutdown();
6590 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6592 }
6593}
6594
6595impl fidl::endpoints::Responder for WlanFullmacImplIfcDeauthConfResponder {
6596 type ControlHandle = WlanFullmacImplIfcControlHandle;
6597
6598 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6599 &self.control_handle
6600 }
6601
6602 fn drop_without_shutdown(mut self) {
6603 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6605 std::mem::forget(self);
6607 }
6608}
6609
6610impl WlanFullmacImplIfcDeauthConfResponder {
6611 pub fn send(self) -> Result<(), fidl::Error> {
6615 let _result = self.send_raw();
6616 if _result.is_err() {
6617 self.control_handle.shutdown();
6618 }
6619 self.drop_without_shutdown();
6620 _result
6621 }
6622
6623 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6625 let _result = self.send_raw();
6626 self.drop_without_shutdown();
6627 _result
6628 }
6629
6630 fn send_raw(&self) -> Result<(), fidl::Error> {
6631 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6632 (),
6633 self.tx_id,
6634 0x2c94b0d7258111b7,
6635 fidl::encoding::DynamicFlags::empty(),
6636 )
6637 }
6638}
6639
6640#[must_use = "FIDL methods require a response to be sent"]
6641#[derive(Debug)]
6642pub struct WlanFullmacImplIfcDeauthIndResponder {
6643 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6644 tx_id: u32,
6645}
6646
6647impl std::ops::Drop for WlanFullmacImplIfcDeauthIndResponder {
6651 fn drop(&mut self) {
6652 self.control_handle.shutdown();
6653 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6655 }
6656}
6657
6658impl fidl::endpoints::Responder for WlanFullmacImplIfcDeauthIndResponder {
6659 type ControlHandle = WlanFullmacImplIfcControlHandle;
6660
6661 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6662 &self.control_handle
6663 }
6664
6665 fn drop_without_shutdown(mut self) {
6666 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6668 std::mem::forget(self);
6670 }
6671}
6672
6673impl WlanFullmacImplIfcDeauthIndResponder {
6674 pub fn send(self) -> Result<(), fidl::Error> {
6678 let _result = self.send_raw();
6679 if _result.is_err() {
6680 self.control_handle.shutdown();
6681 }
6682 self.drop_without_shutdown();
6683 _result
6684 }
6685
6686 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6688 let _result = self.send_raw();
6689 self.drop_without_shutdown();
6690 _result
6691 }
6692
6693 fn send_raw(&self) -> Result<(), fidl::Error> {
6694 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6695 (),
6696 self.tx_id,
6697 0x26cd27cdadd8dbaf,
6698 fidl::encoding::DynamicFlags::empty(),
6699 )
6700 }
6701}
6702
6703#[must_use = "FIDL methods require a response to be sent"]
6704#[derive(Debug)]
6705pub struct WlanFullmacImplIfcAssocIndResponder {
6706 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6707 tx_id: u32,
6708}
6709
6710impl std::ops::Drop for WlanFullmacImplIfcAssocIndResponder {
6714 fn drop(&mut self) {
6715 self.control_handle.shutdown();
6716 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6718 }
6719}
6720
6721impl fidl::endpoints::Responder for WlanFullmacImplIfcAssocIndResponder {
6722 type ControlHandle = WlanFullmacImplIfcControlHandle;
6723
6724 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6725 &self.control_handle
6726 }
6727
6728 fn drop_without_shutdown(mut self) {
6729 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6731 std::mem::forget(self);
6733 }
6734}
6735
6736impl WlanFullmacImplIfcAssocIndResponder {
6737 pub fn send(self) -> Result<(), fidl::Error> {
6741 let _result = self.send_raw();
6742 if _result.is_err() {
6743 self.control_handle.shutdown();
6744 }
6745 self.drop_without_shutdown();
6746 _result
6747 }
6748
6749 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6751 let _result = self.send_raw();
6752 self.drop_without_shutdown();
6753 _result
6754 }
6755
6756 fn send_raw(&self) -> Result<(), fidl::Error> {
6757 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6758 (),
6759 self.tx_id,
6760 0x3e44529e3dc179ce,
6761 fidl::encoding::DynamicFlags::empty(),
6762 )
6763 }
6764}
6765
6766#[must_use = "FIDL methods require a response to be sent"]
6767#[derive(Debug)]
6768pub struct WlanFullmacImplIfcDisassocConfResponder {
6769 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6770 tx_id: u32,
6771}
6772
6773impl std::ops::Drop for WlanFullmacImplIfcDisassocConfResponder {
6777 fn drop(&mut self) {
6778 self.control_handle.shutdown();
6779 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6781 }
6782}
6783
6784impl fidl::endpoints::Responder for WlanFullmacImplIfcDisassocConfResponder {
6785 type ControlHandle = WlanFullmacImplIfcControlHandle;
6786
6787 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6788 &self.control_handle
6789 }
6790
6791 fn drop_without_shutdown(mut self) {
6792 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6794 std::mem::forget(self);
6796 }
6797}
6798
6799impl WlanFullmacImplIfcDisassocConfResponder {
6800 pub fn send(self) -> Result<(), fidl::Error> {
6804 let _result = self.send_raw();
6805 if _result.is_err() {
6806 self.control_handle.shutdown();
6807 }
6808 self.drop_without_shutdown();
6809 _result
6810 }
6811
6812 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6814 let _result = self.send_raw();
6815 self.drop_without_shutdown();
6816 _result
6817 }
6818
6819 fn send_raw(&self) -> Result<(), fidl::Error> {
6820 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6821 (),
6822 self.tx_id,
6823 0x7c713bcd58a76cb3,
6824 fidl::encoding::DynamicFlags::empty(),
6825 )
6826 }
6827}
6828
6829#[must_use = "FIDL methods require a response to be sent"]
6830#[derive(Debug)]
6831pub struct WlanFullmacImplIfcDisassocIndResponder {
6832 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6833 tx_id: u32,
6834}
6835
6836impl std::ops::Drop for WlanFullmacImplIfcDisassocIndResponder {
6840 fn drop(&mut self) {
6841 self.control_handle.shutdown();
6842 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6844 }
6845}
6846
6847impl fidl::endpoints::Responder for WlanFullmacImplIfcDisassocIndResponder {
6848 type ControlHandle = WlanFullmacImplIfcControlHandle;
6849
6850 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6851 &self.control_handle
6852 }
6853
6854 fn drop_without_shutdown(mut self) {
6855 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6857 std::mem::forget(self);
6859 }
6860}
6861
6862impl WlanFullmacImplIfcDisassocIndResponder {
6863 pub fn send(self) -> Result<(), fidl::Error> {
6867 let _result = self.send_raw();
6868 if _result.is_err() {
6869 self.control_handle.shutdown();
6870 }
6871 self.drop_without_shutdown();
6872 _result
6873 }
6874
6875 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6877 let _result = self.send_raw();
6878 self.drop_without_shutdown();
6879 _result
6880 }
6881
6882 fn send_raw(&self) -> Result<(), fidl::Error> {
6883 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6884 (),
6885 self.tx_id,
6886 0x6667b381b7f3990f,
6887 fidl::encoding::DynamicFlags::empty(),
6888 )
6889 }
6890}
6891
6892#[must_use = "FIDL methods require a response to be sent"]
6893#[derive(Debug)]
6894pub struct WlanFullmacImplIfcStartConfResponder {
6895 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6896 tx_id: u32,
6897}
6898
6899impl std::ops::Drop for WlanFullmacImplIfcStartConfResponder {
6903 fn drop(&mut self) {
6904 self.control_handle.shutdown();
6905 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6907 }
6908}
6909
6910impl fidl::endpoints::Responder for WlanFullmacImplIfcStartConfResponder {
6911 type ControlHandle = WlanFullmacImplIfcControlHandle;
6912
6913 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6914 &self.control_handle
6915 }
6916
6917 fn drop_without_shutdown(mut self) {
6918 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6920 std::mem::forget(self);
6922 }
6923}
6924
6925impl WlanFullmacImplIfcStartConfResponder {
6926 pub fn send(self) -> Result<(), fidl::Error> {
6930 let _result = self.send_raw();
6931 if _result.is_err() {
6932 self.control_handle.shutdown();
6933 }
6934 self.drop_without_shutdown();
6935 _result
6936 }
6937
6938 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6940 let _result = self.send_raw();
6941 self.drop_without_shutdown();
6942 _result
6943 }
6944
6945 fn send_raw(&self) -> Result<(), fidl::Error> {
6946 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6947 (),
6948 self.tx_id,
6949 0x3e9b9641f3ddc7fc,
6950 fidl::encoding::DynamicFlags::empty(),
6951 )
6952 }
6953}
6954
6955#[must_use = "FIDL methods require a response to be sent"]
6956#[derive(Debug)]
6957pub struct WlanFullmacImplIfcStopConfResponder {
6958 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6959 tx_id: u32,
6960}
6961
6962impl std::ops::Drop for WlanFullmacImplIfcStopConfResponder {
6966 fn drop(&mut self) {
6967 self.control_handle.shutdown();
6968 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6970 }
6971}
6972
6973impl fidl::endpoints::Responder for WlanFullmacImplIfcStopConfResponder {
6974 type ControlHandle = WlanFullmacImplIfcControlHandle;
6975
6976 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6977 &self.control_handle
6978 }
6979
6980 fn drop_without_shutdown(mut self) {
6981 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6983 std::mem::forget(self);
6985 }
6986}
6987
6988impl WlanFullmacImplIfcStopConfResponder {
6989 pub fn send(self) -> Result<(), fidl::Error> {
6993 let _result = self.send_raw();
6994 if _result.is_err() {
6995 self.control_handle.shutdown();
6996 }
6997 self.drop_without_shutdown();
6998 _result
6999 }
7000
7001 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7003 let _result = self.send_raw();
7004 self.drop_without_shutdown();
7005 _result
7006 }
7007
7008 fn send_raw(&self) -> Result<(), fidl::Error> {
7009 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7010 (),
7011 self.tx_id,
7012 0x320a5ff227a4e9df,
7013 fidl::encoding::DynamicFlags::empty(),
7014 )
7015 }
7016}
7017
7018#[must_use = "FIDL methods require a response to be sent"]
7019#[derive(Debug)]
7020pub struct WlanFullmacImplIfcEapolConfResponder {
7021 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7022 tx_id: u32,
7023}
7024
7025impl std::ops::Drop for WlanFullmacImplIfcEapolConfResponder {
7029 fn drop(&mut self) {
7030 self.control_handle.shutdown();
7031 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7033 }
7034}
7035
7036impl fidl::endpoints::Responder for WlanFullmacImplIfcEapolConfResponder {
7037 type ControlHandle = WlanFullmacImplIfcControlHandle;
7038
7039 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7040 &self.control_handle
7041 }
7042
7043 fn drop_without_shutdown(mut self) {
7044 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7046 std::mem::forget(self);
7048 }
7049}
7050
7051impl WlanFullmacImplIfcEapolConfResponder {
7052 pub fn send(self) -> Result<(), fidl::Error> {
7056 let _result = self.send_raw();
7057 if _result.is_err() {
7058 self.control_handle.shutdown();
7059 }
7060 self.drop_without_shutdown();
7061 _result
7062 }
7063
7064 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7066 let _result = self.send_raw();
7067 self.drop_without_shutdown();
7068 _result
7069 }
7070
7071 fn send_raw(&self) -> Result<(), fidl::Error> {
7072 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7073 (),
7074 self.tx_id,
7075 0x77364db9cc3970ec,
7076 fidl::encoding::DynamicFlags::empty(),
7077 )
7078 }
7079}
7080
7081#[must_use = "FIDL methods require a response to be sent"]
7082#[derive(Debug)]
7083pub struct WlanFullmacImplIfcOnChannelSwitchResponder {
7084 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7085 tx_id: u32,
7086}
7087
7088impl std::ops::Drop for WlanFullmacImplIfcOnChannelSwitchResponder {
7092 fn drop(&mut self) {
7093 self.control_handle.shutdown();
7094 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7096 }
7097}
7098
7099impl fidl::endpoints::Responder for WlanFullmacImplIfcOnChannelSwitchResponder {
7100 type ControlHandle = WlanFullmacImplIfcControlHandle;
7101
7102 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7103 &self.control_handle
7104 }
7105
7106 fn drop_without_shutdown(mut self) {
7107 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7109 std::mem::forget(self);
7111 }
7112}
7113
7114impl WlanFullmacImplIfcOnChannelSwitchResponder {
7115 pub fn send(self) -> Result<(), fidl::Error> {
7119 let _result = self.send_raw();
7120 if _result.is_err() {
7121 self.control_handle.shutdown();
7122 }
7123 self.drop_without_shutdown();
7124 _result
7125 }
7126
7127 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7129 let _result = self.send_raw();
7130 self.drop_without_shutdown();
7131 _result
7132 }
7133
7134 fn send_raw(&self) -> Result<(), fidl::Error> {
7135 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7136 (),
7137 self.tx_id,
7138 0x21db0b8f71cae647,
7139 fidl::encoding::DynamicFlags::empty(),
7140 )
7141 }
7142}
7143
7144#[must_use = "FIDL methods require a response to be sent"]
7145#[derive(Debug)]
7146pub struct WlanFullmacImplIfcSignalReportResponder {
7147 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7148 tx_id: u32,
7149}
7150
7151impl std::ops::Drop for WlanFullmacImplIfcSignalReportResponder {
7155 fn drop(&mut self) {
7156 self.control_handle.shutdown();
7157 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7159 }
7160}
7161
7162impl fidl::endpoints::Responder for WlanFullmacImplIfcSignalReportResponder {
7163 type ControlHandle = WlanFullmacImplIfcControlHandle;
7164
7165 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7166 &self.control_handle
7167 }
7168
7169 fn drop_without_shutdown(mut self) {
7170 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7172 std::mem::forget(self);
7174 }
7175}
7176
7177impl WlanFullmacImplIfcSignalReportResponder {
7178 pub fn send(self) -> Result<(), fidl::Error> {
7182 let _result = self.send_raw();
7183 if _result.is_err() {
7184 self.control_handle.shutdown();
7185 }
7186 self.drop_without_shutdown();
7187 _result
7188 }
7189
7190 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7192 let _result = self.send_raw();
7193 self.drop_without_shutdown();
7194 _result
7195 }
7196
7197 fn send_raw(&self) -> Result<(), fidl::Error> {
7198 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7199 (),
7200 self.tx_id,
7201 0x79679fa8789c3d9f,
7202 fidl::encoding::DynamicFlags::empty(),
7203 )
7204 }
7205}
7206
7207#[must_use = "FIDL methods require a response to be sent"]
7208#[derive(Debug)]
7209pub struct WlanFullmacImplIfcEapolIndResponder {
7210 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7211 tx_id: u32,
7212}
7213
7214impl std::ops::Drop for WlanFullmacImplIfcEapolIndResponder {
7218 fn drop(&mut self) {
7219 self.control_handle.shutdown();
7220 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7222 }
7223}
7224
7225impl fidl::endpoints::Responder for WlanFullmacImplIfcEapolIndResponder {
7226 type ControlHandle = WlanFullmacImplIfcControlHandle;
7227
7228 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7229 &self.control_handle
7230 }
7231
7232 fn drop_without_shutdown(mut self) {
7233 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7235 std::mem::forget(self);
7237 }
7238}
7239
7240impl WlanFullmacImplIfcEapolIndResponder {
7241 pub fn send(self) -> Result<(), fidl::Error> {
7245 let _result = self.send_raw();
7246 if _result.is_err() {
7247 self.control_handle.shutdown();
7248 }
7249 self.drop_without_shutdown();
7250 _result
7251 }
7252
7253 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7255 let _result = self.send_raw();
7256 self.drop_without_shutdown();
7257 _result
7258 }
7259
7260 fn send_raw(&self) -> Result<(), fidl::Error> {
7261 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7262 (),
7263 self.tx_id,
7264 0x3de8ec1eda10d1d0,
7265 fidl::encoding::DynamicFlags::empty(),
7266 )
7267 }
7268}
7269
7270#[must_use = "FIDL methods require a response to be sent"]
7271#[derive(Debug)]
7272pub struct WlanFullmacImplIfcOnPmkAvailableResponder {
7273 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7274 tx_id: u32,
7275}
7276
7277impl std::ops::Drop for WlanFullmacImplIfcOnPmkAvailableResponder {
7281 fn drop(&mut self) {
7282 self.control_handle.shutdown();
7283 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7285 }
7286}
7287
7288impl fidl::endpoints::Responder for WlanFullmacImplIfcOnPmkAvailableResponder {
7289 type ControlHandle = WlanFullmacImplIfcControlHandle;
7290
7291 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7292 &self.control_handle
7293 }
7294
7295 fn drop_without_shutdown(mut self) {
7296 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7298 std::mem::forget(self);
7300 }
7301}
7302
7303impl WlanFullmacImplIfcOnPmkAvailableResponder {
7304 pub fn send(self) -> Result<(), fidl::Error> {
7308 let _result = self.send_raw();
7309 if _result.is_err() {
7310 self.control_handle.shutdown();
7311 }
7312 self.drop_without_shutdown();
7313 _result
7314 }
7315
7316 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7318 let _result = self.send_raw();
7319 self.drop_without_shutdown();
7320 _result
7321 }
7322
7323 fn send_raw(&self) -> Result<(), fidl::Error> {
7324 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7325 (),
7326 self.tx_id,
7327 0x5cedd8d9be28a17e,
7328 fidl::encoding::DynamicFlags::empty(),
7329 )
7330 }
7331}
7332
7333#[must_use = "FIDL methods require a response to be sent"]
7334#[derive(Debug)]
7335pub struct WlanFullmacImplIfcSaeHandshakeIndResponder {
7336 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7337 tx_id: u32,
7338}
7339
7340impl std::ops::Drop for WlanFullmacImplIfcSaeHandshakeIndResponder {
7344 fn drop(&mut self) {
7345 self.control_handle.shutdown();
7346 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7348 }
7349}
7350
7351impl fidl::endpoints::Responder for WlanFullmacImplIfcSaeHandshakeIndResponder {
7352 type ControlHandle = WlanFullmacImplIfcControlHandle;
7353
7354 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7355 &self.control_handle
7356 }
7357
7358 fn drop_without_shutdown(mut self) {
7359 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7361 std::mem::forget(self);
7363 }
7364}
7365
7366impl WlanFullmacImplIfcSaeHandshakeIndResponder {
7367 pub fn send(self) -> Result<(), fidl::Error> {
7371 let _result = self.send_raw();
7372 if _result.is_err() {
7373 self.control_handle.shutdown();
7374 }
7375 self.drop_without_shutdown();
7376 _result
7377 }
7378
7379 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7381 let _result = self.send_raw();
7382 self.drop_without_shutdown();
7383 _result
7384 }
7385
7386 fn send_raw(&self) -> Result<(), fidl::Error> {
7387 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7388 (),
7389 self.tx_id,
7390 0x4f3d53885503a1d8,
7391 fidl::encoding::DynamicFlags::empty(),
7392 )
7393 }
7394}
7395
7396#[must_use = "FIDL methods require a response to be sent"]
7397#[derive(Debug)]
7398pub struct WlanFullmacImplIfcSaeFrameRxResponder {
7399 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7400 tx_id: u32,
7401}
7402
7403impl std::ops::Drop for WlanFullmacImplIfcSaeFrameRxResponder {
7407 fn drop(&mut self) {
7408 self.control_handle.shutdown();
7409 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7411 }
7412}
7413
7414impl fidl::endpoints::Responder for WlanFullmacImplIfcSaeFrameRxResponder {
7415 type ControlHandle = WlanFullmacImplIfcControlHandle;
7416
7417 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7418 &self.control_handle
7419 }
7420
7421 fn drop_without_shutdown(mut self) {
7422 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7424 std::mem::forget(self);
7426 }
7427}
7428
7429impl WlanFullmacImplIfcSaeFrameRxResponder {
7430 pub fn send(self) -> Result<(), fidl::Error> {
7434 let _result = self.send_raw();
7435 if _result.is_err() {
7436 self.control_handle.shutdown();
7437 }
7438 self.drop_without_shutdown();
7439 _result
7440 }
7441
7442 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7444 let _result = self.send_raw();
7445 self.drop_without_shutdown();
7446 _result
7447 }
7448
7449 fn send_raw(&self) -> Result<(), fidl::Error> {
7450 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7451 (),
7452 self.tx_id,
7453 0x51650906857ed4d4,
7454 fidl::encoding::DynamicFlags::empty(),
7455 )
7456 }
7457}
7458
7459#[must_use = "FIDL methods require a response to be sent"]
7460#[derive(Debug)]
7461pub struct WlanFullmacImplIfcOnWmmStatusRespResponder {
7462 control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7463 tx_id: u32,
7464}
7465
7466impl std::ops::Drop for WlanFullmacImplIfcOnWmmStatusRespResponder {
7470 fn drop(&mut self) {
7471 self.control_handle.shutdown();
7472 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7474 }
7475}
7476
7477impl fidl::endpoints::Responder for WlanFullmacImplIfcOnWmmStatusRespResponder {
7478 type ControlHandle = WlanFullmacImplIfcControlHandle;
7479
7480 fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7481 &self.control_handle
7482 }
7483
7484 fn drop_without_shutdown(mut self) {
7485 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7487 std::mem::forget(self);
7489 }
7490}
7491
7492impl WlanFullmacImplIfcOnWmmStatusRespResponder {
7493 pub fn send(self) -> Result<(), fidl::Error> {
7497 let _result = self.send_raw();
7498 if _result.is_err() {
7499 self.control_handle.shutdown();
7500 }
7501 self.drop_without_shutdown();
7502 _result
7503 }
7504
7505 pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7507 let _result = self.send_raw();
7508 self.drop_without_shutdown();
7509 _result
7510 }
7511
7512 fn send_raw(&self) -> Result<(), fidl::Error> {
7513 self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7514 (),
7515 self.tx_id,
7516 0x6823a88bf3ba8b2a,
7517 fidl::encoding::DynamicFlags::empty(),
7518 )
7519 }
7520}
7521
7522#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
7523pub struct ServiceMarker;
7524
7525#[cfg(target_os = "fuchsia")]
7526impl fidl::endpoints::ServiceMarker for ServiceMarker {
7527 type Proxy = ServiceProxy;
7528 type Request = ServiceRequest;
7529 const SERVICE_NAME: &'static str = "fuchsia.wlan.fullmac.Service";
7530}
7531
7532#[cfg(target_os = "fuchsia")]
7535pub enum ServiceRequest {
7536 WlanFullmacImpl(WlanFullmacImpl_RequestStream),
7537}
7538
7539#[cfg(target_os = "fuchsia")]
7540impl fidl::endpoints::ServiceRequest for ServiceRequest {
7541 type Service = ServiceMarker;
7542
7543 fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
7544 match name {
7545 "wlan_fullmac_impl" => Self::WlanFullmacImpl(
7546 <WlanFullmacImpl_RequestStream as fidl::endpoints::RequestStream>::from_channel(
7547 _channel,
7548 ),
7549 ),
7550 _ => panic!("no such member protocol name for service Service"),
7551 }
7552 }
7553
7554 fn member_names() -> &'static [&'static str] {
7555 &["wlan_fullmac_impl"]
7556 }
7557}
7558#[cfg(target_os = "fuchsia")]
7559pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
7560
7561#[cfg(target_os = "fuchsia")]
7562impl fidl::endpoints::ServiceProxy for ServiceProxy {
7563 type Service = ServiceMarker;
7564
7565 fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
7566 Self(opener)
7567 }
7568}
7569
7570#[cfg(target_os = "fuchsia")]
7571impl ServiceProxy {
7572 pub fn connect_to_wlan_fullmac_impl(&self) -> Result<WlanFullmacImpl_Proxy, fidl::Error> {
7573 let (proxy, server_end) = fidl::endpoints::create_proxy::<WlanFullmacImpl_Marker>();
7574 self.connect_channel_to_wlan_fullmac_impl(server_end)?;
7575 Ok(proxy)
7576 }
7577
7578 pub fn connect_to_wlan_fullmac_impl_sync(
7581 &self,
7582 ) -> Result<WlanFullmacImpl_SynchronousProxy, fidl::Error> {
7583 let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<WlanFullmacImpl_Marker>();
7584 self.connect_channel_to_wlan_fullmac_impl(server_end)?;
7585 Ok(proxy)
7586 }
7587
7588 pub fn connect_channel_to_wlan_fullmac_impl(
7591 &self,
7592 server_end: fidl::endpoints::ServerEnd<WlanFullmacImpl_Marker>,
7593 ) -> Result<(), fidl::Error> {
7594 self.0.open_member("wlan_fullmac_impl", server_end.into_channel())
7595 }
7596
7597 pub fn instance_name(&self) -> &str {
7598 self.0.instance_name()
7599 }
7600}
7601
7602mod internal {
7603 use super::*;
7604
7605 impl WlanFullmacImplInitRequest {
7606 #[inline(always)]
7607 fn max_ordinal_present(&self) -> u64 {
7608 if let Some(_) = self.ifc {
7609 return 1;
7610 }
7611 0
7612 }
7613 }
7614
7615 impl fidl::encoding::ResourceTypeMarker for WlanFullmacImplInitRequest {
7616 type Borrowed<'a> = &'a mut Self;
7617 fn take_or_borrow<'a>(
7618 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7619 ) -> Self::Borrowed<'a> {
7620 value
7621 }
7622 }
7623
7624 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplInitRequest {
7625 type Owned = Self;
7626
7627 #[inline(always)]
7628 fn inline_align(_context: fidl::encoding::Context) -> usize {
7629 8
7630 }
7631
7632 #[inline(always)]
7633 fn inline_size(_context: fidl::encoding::Context) -> usize {
7634 16
7635 }
7636 }
7637
7638 unsafe impl
7639 fidl::encoding::Encode<
7640 WlanFullmacImplInitRequest,
7641 fidl::encoding::DefaultFuchsiaResourceDialect,
7642 > for &mut WlanFullmacImplInitRequest
7643 {
7644 unsafe fn encode(
7645 self,
7646 encoder: &mut fidl::encoding::Encoder<
7647 '_,
7648 fidl::encoding::DefaultFuchsiaResourceDialect,
7649 >,
7650 offset: usize,
7651 mut depth: fidl::encoding::Depth,
7652 ) -> fidl::Result<()> {
7653 encoder.debug_check_bounds::<WlanFullmacImplInitRequest>(offset);
7654 let max_ordinal: u64 = self.max_ordinal_present();
7656 encoder.write_num(max_ordinal, offset);
7657 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7658 if max_ordinal == 0 {
7660 return Ok(());
7661 }
7662 depth.increment()?;
7663 let envelope_size = 8;
7664 let bytes_len = max_ordinal as usize * envelope_size;
7665 #[allow(unused_variables)]
7666 let offset = encoder.out_of_line_offset(bytes_len);
7667 let mut _prev_end_offset: usize = 0;
7668 if 1 > max_ordinal {
7669 return Ok(());
7670 }
7671
7672 let cur_offset: usize = (1 - 1) * envelope_size;
7675
7676 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7678
7679 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
7684 self.ifc.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
7685 encoder, offset + cur_offset, depth
7686 )?;
7687
7688 _prev_end_offset = cur_offset + envelope_size;
7689
7690 Ok(())
7691 }
7692 }
7693
7694 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7695 for WlanFullmacImplInitRequest
7696 {
7697 #[inline(always)]
7698 fn new_empty() -> Self {
7699 Self::default()
7700 }
7701
7702 unsafe fn decode(
7703 &mut self,
7704 decoder: &mut fidl::encoding::Decoder<
7705 '_,
7706 fidl::encoding::DefaultFuchsiaResourceDialect,
7707 >,
7708 offset: usize,
7709 mut depth: fidl::encoding::Depth,
7710 ) -> fidl::Result<()> {
7711 decoder.debug_check_bounds::<Self>(offset);
7712 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7713 None => return Err(fidl::Error::NotNullable),
7714 Some(len) => len,
7715 };
7716 if len == 0 {
7718 return Ok(());
7719 };
7720 depth.increment()?;
7721 let envelope_size = 8;
7722 let bytes_len = len * envelope_size;
7723 let offset = decoder.out_of_line_offset(bytes_len)?;
7724 let mut _next_ordinal_to_read = 0;
7726 let mut next_offset = offset;
7727 let end_offset = offset + bytes_len;
7728 _next_ordinal_to_read += 1;
7729 if next_offset >= end_offset {
7730 return Ok(());
7731 }
7732
7733 while _next_ordinal_to_read < 1 {
7735 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7736 _next_ordinal_to_read += 1;
7737 next_offset += envelope_size;
7738 }
7739
7740 let next_out_of_line = decoder.next_out_of_line();
7741 let handles_before = decoder.remaining_handles();
7742 if let Some((inlined, num_bytes, num_handles)) =
7743 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7744 {
7745 let member_inline_size = <fidl::encoding::Endpoint<
7746 fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>,
7747 > as fidl::encoding::TypeMarker>::inline_size(
7748 decoder.context
7749 );
7750 if inlined != (member_inline_size <= 4) {
7751 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7752 }
7753 let inner_offset;
7754 let mut inner_depth = depth.clone();
7755 if inlined {
7756 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7757 inner_offset = next_offset;
7758 } else {
7759 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7760 inner_depth.increment()?;
7761 }
7762 let val_ref = self.ifc.get_or_insert_with(|| {
7763 fidl::new_empty!(
7764 fidl::encoding::Endpoint<
7765 fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>,
7766 >,
7767 fidl::encoding::DefaultFuchsiaResourceDialect
7768 )
7769 });
7770 fidl::decode!(
7771 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>>,
7772 fidl::encoding::DefaultFuchsiaResourceDialect,
7773 val_ref,
7774 decoder,
7775 inner_offset,
7776 inner_depth
7777 )?;
7778 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7779 {
7780 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7781 }
7782 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7783 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7784 }
7785 }
7786
7787 next_offset += envelope_size;
7788
7789 while next_offset < end_offset {
7791 _next_ordinal_to_read += 1;
7792 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7793 next_offset += envelope_size;
7794 }
7795
7796 Ok(())
7797 }
7798 }
7799
7800 impl WlanFullmacImplInitResponse {
7801 #[inline(always)]
7802 fn max_ordinal_present(&self) -> u64 {
7803 if let Some(_) = self.sme_channel {
7804 return 1;
7805 }
7806 0
7807 }
7808 }
7809
7810 impl fidl::encoding::ResourceTypeMarker for WlanFullmacImplInitResponse {
7811 type Borrowed<'a> = &'a mut Self;
7812 fn take_or_borrow<'a>(
7813 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7814 ) -> Self::Borrowed<'a> {
7815 value
7816 }
7817 }
7818
7819 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplInitResponse {
7820 type Owned = Self;
7821
7822 #[inline(always)]
7823 fn inline_align(_context: fidl::encoding::Context) -> usize {
7824 8
7825 }
7826
7827 #[inline(always)]
7828 fn inline_size(_context: fidl::encoding::Context) -> usize {
7829 16
7830 }
7831 }
7832
7833 unsafe impl
7834 fidl::encoding::Encode<
7835 WlanFullmacImplInitResponse,
7836 fidl::encoding::DefaultFuchsiaResourceDialect,
7837 > for &mut WlanFullmacImplInitResponse
7838 {
7839 unsafe fn encode(
7840 self,
7841 encoder: &mut fidl::encoding::Encoder<
7842 '_,
7843 fidl::encoding::DefaultFuchsiaResourceDialect,
7844 >,
7845 offset: usize,
7846 mut depth: fidl::encoding::Depth,
7847 ) -> fidl::Result<()> {
7848 encoder.debug_check_bounds::<WlanFullmacImplInitResponse>(offset);
7849 let max_ordinal: u64 = self.max_ordinal_present();
7851 encoder.write_num(max_ordinal, offset);
7852 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7853 if max_ordinal == 0 {
7855 return Ok(());
7856 }
7857 depth.increment()?;
7858 let envelope_size = 8;
7859 let bytes_len = max_ordinal as usize * envelope_size;
7860 #[allow(unused_variables)]
7861 let offset = encoder.out_of_line_offset(bytes_len);
7862 let mut _prev_end_offset: usize = 0;
7863 if 1 > max_ordinal {
7864 return Ok(());
7865 }
7866
7867 let cur_offset: usize = (1 - 1) * envelope_size;
7870
7871 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7873
7874 fidl::encoding::encode_in_envelope_optional::<
7879 fidl::encoding::HandleType<
7880 fidl::Channel,
7881 { fidl::ObjectType::CHANNEL.into_raw() },
7882 2147483648,
7883 >,
7884 fidl::encoding::DefaultFuchsiaResourceDialect,
7885 >(
7886 self.sme_channel.as_mut().map(
7887 <fidl::encoding::HandleType<
7888 fidl::Channel,
7889 { fidl::ObjectType::CHANNEL.into_raw() },
7890 2147483648,
7891 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
7892 ),
7893 encoder,
7894 offset + cur_offset,
7895 depth,
7896 )?;
7897
7898 _prev_end_offset = cur_offset + envelope_size;
7899
7900 Ok(())
7901 }
7902 }
7903
7904 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7905 for WlanFullmacImplInitResponse
7906 {
7907 #[inline(always)]
7908 fn new_empty() -> Self {
7909 Self::default()
7910 }
7911
7912 unsafe fn decode(
7913 &mut self,
7914 decoder: &mut fidl::encoding::Decoder<
7915 '_,
7916 fidl::encoding::DefaultFuchsiaResourceDialect,
7917 >,
7918 offset: usize,
7919 mut depth: fidl::encoding::Depth,
7920 ) -> fidl::Result<()> {
7921 decoder.debug_check_bounds::<Self>(offset);
7922 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7923 None => return Err(fidl::Error::NotNullable),
7924 Some(len) => len,
7925 };
7926 if len == 0 {
7928 return Ok(());
7929 };
7930 depth.increment()?;
7931 let envelope_size = 8;
7932 let bytes_len = len * envelope_size;
7933 let offset = decoder.out_of_line_offset(bytes_len)?;
7934 let mut _next_ordinal_to_read = 0;
7936 let mut next_offset = offset;
7937 let end_offset = offset + bytes_len;
7938 _next_ordinal_to_read += 1;
7939 if next_offset >= end_offset {
7940 return Ok(());
7941 }
7942
7943 while _next_ordinal_to_read < 1 {
7945 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7946 _next_ordinal_to_read += 1;
7947 next_offset += envelope_size;
7948 }
7949
7950 let next_out_of_line = decoder.next_out_of_line();
7951 let handles_before = decoder.remaining_handles();
7952 if let Some((inlined, num_bytes, num_handles)) =
7953 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7954 {
7955 let member_inline_size = <fidl::encoding::HandleType<
7956 fidl::Channel,
7957 { fidl::ObjectType::CHANNEL.into_raw() },
7958 2147483648,
7959 > as fidl::encoding::TypeMarker>::inline_size(
7960 decoder.context
7961 );
7962 if inlined != (member_inline_size <= 4) {
7963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7964 }
7965 let inner_offset;
7966 let mut inner_depth = depth.clone();
7967 if inlined {
7968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7969 inner_offset = next_offset;
7970 } else {
7971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7972 inner_depth.increment()?;
7973 }
7974 let val_ref =
7975 self.sme_channel.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
7976 fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
7977 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7978 {
7979 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7980 }
7981 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7982 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7983 }
7984 }
7985
7986 next_offset += envelope_size;
7987
7988 while next_offset < end_offset {
7990 _next_ordinal_to_read += 1;
7991 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7992 next_offset += envelope_size;
7993 }
7994
7995 Ok(())
7996 }
7997 }
7998}