1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12pub enum DeviceMonitorError {
13 #[doc(hidden)]
14 __SourceBreaking { unknown_ordinal: u32 },
15}
16
17#[macro_export]
19macro_rules! DeviceMonitorErrorUnknown {
20 () => {
21 _
22 };
23}
24
25impl DeviceMonitorError {
26 #[inline]
27 pub fn from_primitive(prim: u32) -> Option<Self> {
28 match prim {
29 _ => None,
30 }
31 }
32
33 #[inline]
34 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
35 match prim {
36 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
37 }
38 }
39
40 #[inline]
41 pub fn unknown() -> Self {
42 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
43 }
44
45 #[inline]
46 pub const fn into_primitive(self) -> u32 {
47 match self {
48 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
49 }
50 }
51
52 #[inline]
53 pub fn is_unknown(&self) -> bool {
54 match self {
55 Self::__SourceBreaking { unknown_ordinal: _ } => true,
56 }
57 }
58}
59
60#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
61#[repr(C)]
62pub struct ClearCountryRequest {
63 pub phy_id: u16,
64}
65
66impl fidl::Persistable for ClearCountryRequest {}
67
68#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
69#[repr(C)]
70pub struct DestroyIfaceRequest {
71 pub iface_id: u16,
72}
73
74impl fidl::Persistable for DestroyIfaceRequest {}
75
76#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
77#[repr(C)]
78pub struct DeviceMonitorClearCountryRequest {
79 pub req: ClearCountryRequest,
80}
81
82impl fidl::Persistable for DeviceMonitorClearCountryRequest {}
83
84#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
85#[repr(C)]
86pub struct DeviceMonitorClearCountryResponse {
87 pub status: i32,
88}
89
90impl fidl::Persistable for DeviceMonitorClearCountryResponse {}
91
92#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
93#[repr(C)]
94pub struct DeviceMonitorDestroyIfaceRequest {
95 pub req: DestroyIfaceRequest,
96}
97
98impl fidl::Persistable for DeviceMonitorDestroyIfaceRequest {}
99
100#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
101#[repr(C)]
102pub struct DeviceMonitorDestroyIfaceResponse {
103 pub status: i32,
104}
105
106impl fidl::Persistable for DeviceMonitorDestroyIfaceResponse {}
107
108#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
109#[repr(C)]
110pub struct DeviceMonitorGetCountryRequest {
111 pub phy_id: u16,
112}
113
114impl fidl::Persistable for DeviceMonitorGetCountryRequest {}
115
116#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
117#[repr(C)]
118pub struct DeviceMonitorGetDevPathRequest {
119 pub phy_id: u16,
120}
121
122impl fidl::Persistable for DeviceMonitorGetDevPathRequest {}
123
124#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
125pub struct DeviceMonitorGetDevPathResponse {
126 pub dev_path: Option<String>,
127}
128
129impl fidl::Persistable for DeviceMonitorGetDevPathResponse {}
130
131#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
132#[repr(C)]
133pub struct DeviceMonitorGetPowerSaveModeRequest {
134 pub phy_id: u16,
135}
136
137impl fidl::Persistable for DeviceMonitorGetPowerSaveModeRequest {}
138
139#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
140#[repr(C)]
141pub struct DeviceMonitorGetSupportedMacRolesRequest {
142 pub phy_id: u16,
143}
144
145impl fidl::Persistable for DeviceMonitorGetSupportedMacRolesRequest {}
146
147#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
148pub struct DeviceMonitorListIfacesResponse {
149 pub iface_list: Vec<u16>,
150}
151
152impl fidl::Persistable for DeviceMonitorListIfacesResponse {}
153
154#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155pub struct DeviceMonitorListPhysResponse {
156 pub phy_list: Vec<u16>,
157}
158
159impl fidl::Persistable for DeviceMonitorListPhysResponse {}
160
161#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
162#[repr(C)]
163pub struct DeviceMonitorQueryIfaceRequest {
164 pub iface_id: u16,
165}
166
167impl fidl::Persistable for DeviceMonitorQueryIfaceRequest {}
168
169#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
170#[repr(C)]
171pub struct DeviceMonitorSetCountryRequest {
172 pub req: SetCountryRequest,
173}
174
175impl fidl::Persistable for DeviceMonitorSetCountryRequest {}
176
177#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
178#[repr(C)]
179pub struct DeviceMonitorSetCountryResponse {
180 pub status: i32,
181}
182
183impl fidl::Persistable for DeviceMonitorSetCountryResponse {}
184
185#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
186pub struct DeviceMonitorSetPowerSaveModeRequest {
187 pub req: SetPowerSaveModeRequest,
188}
189
190impl fidl::Persistable for DeviceMonitorSetPowerSaveModeRequest {}
191
192#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
193#[repr(C)]
194pub struct DeviceMonitorSetPowerSaveModeResponse {
195 pub status: i32,
196}
197
198impl fidl::Persistable for DeviceMonitorSetPowerSaveModeResponse {}
199
200#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
201#[repr(C)]
202pub struct DeviceMonitorGetCountryResponse {
203 pub resp: GetCountryResponse,
204}
205
206impl fidl::Persistable for DeviceMonitorGetCountryResponse {}
207
208#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
209pub struct DeviceMonitorGetPowerSaveModeResponse {
210 pub resp: GetPowerSaveModeResponse,
211}
212
213impl fidl::Persistable for DeviceMonitorGetPowerSaveModeResponse {}
214
215#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
216pub struct DeviceMonitorGetSupportedMacRolesResponse {
217 pub supported_mac_roles: Vec<fidl_fuchsia_wlan_common__common::WlanMacRole>,
218}
219
220impl fidl::Persistable for DeviceMonitorGetSupportedMacRolesResponse {}
221
222#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
223pub struct DeviceMonitorQueryIfaceResponse {
224 pub resp: QueryIfaceResponse,
225}
226
227impl fidl::Persistable for DeviceMonitorQueryIfaceResponse {}
228
229#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
230#[repr(C)]
231pub struct DeviceWatcherOnIfaceAddedRequest {
232 pub iface_id: u16,
233}
234
235impl fidl::Persistable for DeviceWatcherOnIfaceAddedRequest {}
236
237#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
238#[repr(C)]
239pub struct DeviceWatcherOnIfaceRemovedRequest {
240 pub iface_id: u16,
241}
242
243impl fidl::Persistable for DeviceWatcherOnIfaceRemovedRequest {}
244
245#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
246#[repr(C)]
247pub struct DeviceWatcherOnPhyAddedRequest {
248 pub phy_id: u16,
249}
250
251impl fidl::Persistable for DeviceWatcherOnPhyAddedRequest {}
252
253#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
254#[repr(C)]
255pub struct DeviceWatcherOnPhyRemovedRequest {
256 pub phy_id: u16,
257}
258
259impl fidl::Persistable for DeviceWatcherOnPhyRemovedRequest {}
260
261#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
262#[repr(C)]
263pub struct GetCountryResponse {
264 pub alpha2: [u8; 2],
265}
266
267impl fidl::Persistable for GetCountryResponse {}
268
269#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
270pub struct GetPowerSaveModeResponse {
271 pub ps_mode: fidl_fuchsia_wlan_common__common::PowerSaveType,
273}
274
275impl fidl::Persistable for GetPowerSaveModeResponse {}
276
277#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
278pub struct QueryIfaceResponse {
279 pub role: fidl_fuchsia_wlan_common__common::WlanMacRole,
281 pub id: u16,
283 pub phy_id: u16,
285 pub phy_assigned_id: u16,
287 pub sta_addr: [u8; 6],
289}
290
291impl fidl::Persistable for QueryIfaceResponse {}
292
293#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
294#[repr(C)]
295pub struct SetCountryRequest {
296 pub phy_id: u16,
297 pub alpha2: [u8; 2],
298}
299
300impl fidl::Persistable for SetCountryRequest {}
301
302#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
303pub struct SetPowerSaveModeRequest {
304 pub phy_id: u16,
306 pub ps_mode: fidl_fuchsia_wlan_common__common::PowerSaveType,
308}
309
310impl fidl::Persistable for SetPowerSaveModeRequest {}
311
312#[derive(Clone, Debug, Default, PartialEq)]
313pub struct DeviceMonitorCreateIfaceRequest {
314 pub phy_id: Option<u16>,
315 pub role: Option<fidl_fuchsia_wlan_common__common::WlanMacRole>,
316 pub sta_address: Option<[u8; 6]>,
317 #[doc(hidden)]
318 pub __source_breaking: fidl::marker::SourceBreaking,
319}
320
321impl fidl::Persistable for DeviceMonitorCreateIfaceRequest {}
322
323#[derive(Clone, Debug, Default, PartialEq)]
324pub struct DeviceMonitorCreateIfaceResponse {
325 pub iface_id: Option<u16>,
326 #[doc(hidden)]
327 pub __source_breaking: fidl::marker::SourceBreaking,
328}
329
330impl fidl::Persistable for DeviceMonitorCreateIfaceResponse {}
331
332#[derive(Clone, Debug, PartialEq)]
333pub enum GetIfaceHistogramStatsResponse {
334 Stats(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats),
335 ErrorStatus(i32),
336}
337
338impl GetIfaceHistogramStatsResponse {
339 #[inline]
340 pub fn ordinal(&self) -> u64 {
341 match *self {
342 Self::Stats(_) => 1,
343 Self::ErrorStatus(_) => 2,
344 }
345 }
346}
347
348impl fidl::Persistable for GetIfaceHistogramStatsResponse {}
349
350mod internal {
351 use super::*;
352 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorError {
353 type Owned = Self;
354
355 #[inline(always)]
356 fn inline_align(_context: fidl::encoding::Context) -> usize {
357 std::mem::align_of::<u32>()
358 }
359
360 #[inline(always)]
361 fn inline_size(_context: fidl::encoding::Context) -> usize {
362 std::mem::size_of::<u32>()
363 }
364
365 #[inline(always)]
366 fn encode_is_copy() -> bool {
367 false
368 }
369
370 #[inline(always)]
371 fn decode_is_copy() -> bool {
372 false
373 }
374 }
375
376 impl fidl::encoding::ValueTypeMarker for DeviceMonitorError {
377 type Borrowed<'a> = Self;
378 #[inline(always)]
379 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
380 *value
381 }
382 }
383
384 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
385 for DeviceMonitorError
386 {
387 #[inline]
388 unsafe fn encode(
389 self,
390 encoder: &mut fidl::encoding::Encoder<'_, D>,
391 offset: usize,
392 _depth: fidl::encoding::Depth,
393 ) -> fidl::Result<()> {
394 encoder.debug_check_bounds::<Self>(offset);
395 encoder.write_num(self.into_primitive(), offset);
396 Ok(())
397 }
398 }
399
400 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceMonitorError {
401 #[inline(always)]
402 fn new_empty() -> Self {
403 Self::unknown()
404 }
405
406 #[inline]
407 unsafe fn decode(
408 &mut self,
409 decoder: &mut fidl::encoding::Decoder<'_, D>,
410 offset: usize,
411 _depth: fidl::encoding::Depth,
412 ) -> fidl::Result<()> {
413 decoder.debug_check_bounds::<Self>(offset);
414 let prim = decoder.read_num::<u32>(offset);
415
416 *self = Self::from_primitive_allow_unknown(prim);
417 Ok(())
418 }
419 }
420
421 impl fidl::encoding::ValueTypeMarker for ClearCountryRequest {
422 type Borrowed<'a> = &'a Self;
423 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
424 value
425 }
426 }
427
428 unsafe impl fidl::encoding::TypeMarker for ClearCountryRequest {
429 type Owned = Self;
430
431 #[inline(always)]
432 fn inline_align(_context: fidl::encoding::Context) -> usize {
433 2
434 }
435
436 #[inline(always)]
437 fn inline_size(_context: fidl::encoding::Context) -> usize {
438 2
439 }
440 #[inline(always)]
441 fn encode_is_copy() -> bool {
442 true
443 }
444
445 #[inline(always)]
446 fn decode_is_copy() -> bool {
447 true
448 }
449 }
450
451 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClearCountryRequest, D>
452 for &ClearCountryRequest
453 {
454 #[inline]
455 unsafe fn encode(
456 self,
457 encoder: &mut fidl::encoding::Encoder<'_, D>,
458 offset: usize,
459 _depth: fidl::encoding::Depth,
460 ) -> fidl::Result<()> {
461 encoder.debug_check_bounds::<ClearCountryRequest>(offset);
462 unsafe {
463 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
465 (buf_ptr as *mut ClearCountryRequest)
466 .write_unaligned((self as *const ClearCountryRequest).read());
467 }
470 Ok(())
471 }
472 }
473 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
474 fidl::encoding::Encode<ClearCountryRequest, D> for (T0,)
475 {
476 #[inline]
477 unsafe fn encode(
478 self,
479 encoder: &mut fidl::encoding::Encoder<'_, D>,
480 offset: usize,
481 depth: fidl::encoding::Depth,
482 ) -> fidl::Result<()> {
483 encoder.debug_check_bounds::<ClearCountryRequest>(offset);
484 self.0.encode(encoder, offset + 0, depth)?;
488 Ok(())
489 }
490 }
491
492 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClearCountryRequest {
493 #[inline(always)]
494 fn new_empty() -> Self {
495 Self { phy_id: fidl::new_empty!(u16, D) }
496 }
497
498 #[inline]
499 unsafe fn decode(
500 &mut self,
501 decoder: &mut fidl::encoding::Decoder<'_, D>,
502 offset: usize,
503 _depth: fidl::encoding::Depth,
504 ) -> fidl::Result<()> {
505 decoder.debug_check_bounds::<Self>(offset);
506 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
507 unsafe {
510 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
511 }
512 Ok(())
513 }
514 }
515
516 impl fidl::encoding::ValueTypeMarker for DestroyIfaceRequest {
517 type Borrowed<'a> = &'a Self;
518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
519 value
520 }
521 }
522
523 unsafe impl fidl::encoding::TypeMarker for DestroyIfaceRequest {
524 type Owned = Self;
525
526 #[inline(always)]
527 fn inline_align(_context: fidl::encoding::Context) -> usize {
528 2
529 }
530
531 #[inline(always)]
532 fn inline_size(_context: fidl::encoding::Context) -> usize {
533 2
534 }
535 #[inline(always)]
536 fn encode_is_copy() -> bool {
537 true
538 }
539
540 #[inline(always)]
541 fn decode_is_copy() -> bool {
542 true
543 }
544 }
545
546 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DestroyIfaceRequest, D>
547 for &DestroyIfaceRequest
548 {
549 #[inline]
550 unsafe fn encode(
551 self,
552 encoder: &mut fidl::encoding::Encoder<'_, D>,
553 offset: usize,
554 _depth: fidl::encoding::Depth,
555 ) -> fidl::Result<()> {
556 encoder.debug_check_bounds::<DestroyIfaceRequest>(offset);
557 unsafe {
558 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
560 (buf_ptr as *mut DestroyIfaceRequest)
561 .write_unaligned((self as *const DestroyIfaceRequest).read());
562 }
565 Ok(())
566 }
567 }
568 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
569 fidl::encoding::Encode<DestroyIfaceRequest, D> for (T0,)
570 {
571 #[inline]
572 unsafe fn encode(
573 self,
574 encoder: &mut fidl::encoding::Encoder<'_, D>,
575 offset: usize,
576 depth: fidl::encoding::Depth,
577 ) -> fidl::Result<()> {
578 encoder.debug_check_bounds::<DestroyIfaceRequest>(offset);
579 self.0.encode(encoder, offset + 0, depth)?;
583 Ok(())
584 }
585 }
586
587 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DestroyIfaceRequest {
588 #[inline(always)]
589 fn new_empty() -> Self {
590 Self { iface_id: fidl::new_empty!(u16, D) }
591 }
592
593 #[inline]
594 unsafe fn decode(
595 &mut self,
596 decoder: &mut fidl::encoding::Decoder<'_, D>,
597 offset: usize,
598 _depth: fidl::encoding::Depth,
599 ) -> fidl::Result<()> {
600 decoder.debug_check_bounds::<Self>(offset);
601 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
602 unsafe {
605 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
606 }
607 Ok(())
608 }
609 }
610
611 impl fidl::encoding::ValueTypeMarker for DeviceMonitorClearCountryRequest {
612 type Borrowed<'a> = &'a Self;
613 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
614 value
615 }
616 }
617
618 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorClearCountryRequest {
619 type Owned = Self;
620
621 #[inline(always)]
622 fn inline_align(_context: fidl::encoding::Context) -> usize {
623 2
624 }
625
626 #[inline(always)]
627 fn inline_size(_context: fidl::encoding::Context) -> usize {
628 2
629 }
630 #[inline(always)]
631 fn encode_is_copy() -> bool {
632 true
633 }
634
635 #[inline(always)]
636 fn decode_is_copy() -> bool {
637 true
638 }
639 }
640
641 unsafe impl<D: fidl::encoding::ResourceDialect>
642 fidl::encoding::Encode<DeviceMonitorClearCountryRequest, D>
643 for &DeviceMonitorClearCountryRequest
644 {
645 #[inline]
646 unsafe fn encode(
647 self,
648 encoder: &mut fidl::encoding::Encoder<'_, D>,
649 offset: usize,
650 _depth: fidl::encoding::Depth,
651 ) -> fidl::Result<()> {
652 encoder.debug_check_bounds::<DeviceMonitorClearCountryRequest>(offset);
653 unsafe {
654 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
656 (buf_ptr as *mut DeviceMonitorClearCountryRequest)
657 .write_unaligned((self as *const DeviceMonitorClearCountryRequest).read());
658 }
661 Ok(())
662 }
663 }
664 unsafe impl<
665 D: fidl::encoding::ResourceDialect,
666 T0: fidl::encoding::Encode<ClearCountryRequest, D>,
667 > fidl::encoding::Encode<DeviceMonitorClearCountryRequest, D> for (T0,)
668 {
669 #[inline]
670 unsafe fn encode(
671 self,
672 encoder: &mut fidl::encoding::Encoder<'_, D>,
673 offset: usize,
674 depth: fidl::encoding::Depth,
675 ) -> fidl::Result<()> {
676 encoder.debug_check_bounds::<DeviceMonitorClearCountryRequest>(offset);
677 self.0.encode(encoder, offset + 0, depth)?;
681 Ok(())
682 }
683 }
684
685 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
686 for DeviceMonitorClearCountryRequest
687 {
688 #[inline(always)]
689 fn new_empty() -> Self {
690 Self { req: fidl::new_empty!(ClearCountryRequest, D) }
691 }
692
693 #[inline]
694 unsafe fn decode(
695 &mut self,
696 decoder: &mut fidl::encoding::Decoder<'_, D>,
697 offset: usize,
698 _depth: fidl::encoding::Depth,
699 ) -> fidl::Result<()> {
700 decoder.debug_check_bounds::<Self>(offset);
701 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
702 unsafe {
705 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
706 }
707 Ok(())
708 }
709 }
710
711 impl fidl::encoding::ValueTypeMarker for DeviceMonitorClearCountryResponse {
712 type Borrowed<'a> = &'a Self;
713 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
714 value
715 }
716 }
717
718 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorClearCountryResponse {
719 type Owned = Self;
720
721 #[inline(always)]
722 fn inline_align(_context: fidl::encoding::Context) -> usize {
723 4
724 }
725
726 #[inline(always)]
727 fn inline_size(_context: fidl::encoding::Context) -> usize {
728 4
729 }
730 #[inline(always)]
731 fn encode_is_copy() -> bool {
732 true
733 }
734
735 #[inline(always)]
736 fn decode_is_copy() -> bool {
737 true
738 }
739 }
740
741 unsafe impl<D: fidl::encoding::ResourceDialect>
742 fidl::encoding::Encode<DeviceMonitorClearCountryResponse, D>
743 for &DeviceMonitorClearCountryResponse
744 {
745 #[inline]
746 unsafe fn encode(
747 self,
748 encoder: &mut fidl::encoding::Encoder<'_, D>,
749 offset: usize,
750 _depth: fidl::encoding::Depth,
751 ) -> fidl::Result<()> {
752 encoder.debug_check_bounds::<DeviceMonitorClearCountryResponse>(offset);
753 unsafe {
754 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
756 (buf_ptr as *mut DeviceMonitorClearCountryResponse)
757 .write_unaligned((self as *const DeviceMonitorClearCountryResponse).read());
758 }
761 Ok(())
762 }
763 }
764 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
765 fidl::encoding::Encode<DeviceMonitorClearCountryResponse, D> for (T0,)
766 {
767 #[inline]
768 unsafe fn encode(
769 self,
770 encoder: &mut fidl::encoding::Encoder<'_, D>,
771 offset: usize,
772 depth: fidl::encoding::Depth,
773 ) -> fidl::Result<()> {
774 encoder.debug_check_bounds::<DeviceMonitorClearCountryResponse>(offset);
775 self.0.encode(encoder, offset + 0, depth)?;
779 Ok(())
780 }
781 }
782
783 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
784 for DeviceMonitorClearCountryResponse
785 {
786 #[inline(always)]
787 fn new_empty() -> Self {
788 Self { status: fidl::new_empty!(i32, D) }
789 }
790
791 #[inline]
792 unsafe fn decode(
793 &mut self,
794 decoder: &mut fidl::encoding::Decoder<'_, D>,
795 offset: usize,
796 _depth: fidl::encoding::Depth,
797 ) -> fidl::Result<()> {
798 decoder.debug_check_bounds::<Self>(offset);
799 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
800 unsafe {
803 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
804 }
805 Ok(())
806 }
807 }
808
809 impl fidl::encoding::ValueTypeMarker for DeviceMonitorDestroyIfaceRequest {
810 type Borrowed<'a> = &'a Self;
811 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
812 value
813 }
814 }
815
816 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorDestroyIfaceRequest {
817 type Owned = Self;
818
819 #[inline(always)]
820 fn inline_align(_context: fidl::encoding::Context) -> usize {
821 2
822 }
823
824 #[inline(always)]
825 fn inline_size(_context: fidl::encoding::Context) -> usize {
826 2
827 }
828 #[inline(always)]
829 fn encode_is_copy() -> bool {
830 true
831 }
832
833 #[inline(always)]
834 fn decode_is_copy() -> bool {
835 true
836 }
837 }
838
839 unsafe impl<D: fidl::encoding::ResourceDialect>
840 fidl::encoding::Encode<DeviceMonitorDestroyIfaceRequest, D>
841 for &DeviceMonitorDestroyIfaceRequest
842 {
843 #[inline]
844 unsafe fn encode(
845 self,
846 encoder: &mut fidl::encoding::Encoder<'_, D>,
847 offset: usize,
848 _depth: fidl::encoding::Depth,
849 ) -> fidl::Result<()> {
850 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceRequest>(offset);
851 unsafe {
852 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
854 (buf_ptr as *mut DeviceMonitorDestroyIfaceRequest)
855 .write_unaligned((self as *const DeviceMonitorDestroyIfaceRequest).read());
856 }
859 Ok(())
860 }
861 }
862 unsafe impl<
863 D: fidl::encoding::ResourceDialect,
864 T0: fidl::encoding::Encode<DestroyIfaceRequest, D>,
865 > fidl::encoding::Encode<DeviceMonitorDestroyIfaceRequest, D> for (T0,)
866 {
867 #[inline]
868 unsafe fn encode(
869 self,
870 encoder: &mut fidl::encoding::Encoder<'_, D>,
871 offset: usize,
872 depth: fidl::encoding::Depth,
873 ) -> fidl::Result<()> {
874 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceRequest>(offset);
875 self.0.encode(encoder, offset + 0, depth)?;
879 Ok(())
880 }
881 }
882
883 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
884 for DeviceMonitorDestroyIfaceRequest
885 {
886 #[inline(always)]
887 fn new_empty() -> Self {
888 Self { req: fidl::new_empty!(DestroyIfaceRequest, D) }
889 }
890
891 #[inline]
892 unsafe fn decode(
893 &mut self,
894 decoder: &mut fidl::encoding::Decoder<'_, D>,
895 offset: usize,
896 _depth: fidl::encoding::Depth,
897 ) -> fidl::Result<()> {
898 decoder.debug_check_bounds::<Self>(offset);
899 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
900 unsafe {
903 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
904 }
905 Ok(())
906 }
907 }
908
909 impl fidl::encoding::ValueTypeMarker for DeviceMonitorDestroyIfaceResponse {
910 type Borrowed<'a> = &'a Self;
911 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
912 value
913 }
914 }
915
916 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorDestroyIfaceResponse {
917 type Owned = Self;
918
919 #[inline(always)]
920 fn inline_align(_context: fidl::encoding::Context) -> usize {
921 4
922 }
923
924 #[inline(always)]
925 fn inline_size(_context: fidl::encoding::Context) -> usize {
926 4
927 }
928 #[inline(always)]
929 fn encode_is_copy() -> bool {
930 true
931 }
932
933 #[inline(always)]
934 fn decode_is_copy() -> bool {
935 true
936 }
937 }
938
939 unsafe impl<D: fidl::encoding::ResourceDialect>
940 fidl::encoding::Encode<DeviceMonitorDestroyIfaceResponse, D>
941 for &DeviceMonitorDestroyIfaceResponse
942 {
943 #[inline]
944 unsafe fn encode(
945 self,
946 encoder: &mut fidl::encoding::Encoder<'_, D>,
947 offset: usize,
948 _depth: fidl::encoding::Depth,
949 ) -> fidl::Result<()> {
950 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceResponse>(offset);
951 unsafe {
952 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
954 (buf_ptr as *mut DeviceMonitorDestroyIfaceResponse)
955 .write_unaligned((self as *const DeviceMonitorDestroyIfaceResponse).read());
956 }
959 Ok(())
960 }
961 }
962 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
963 fidl::encoding::Encode<DeviceMonitorDestroyIfaceResponse, D> for (T0,)
964 {
965 #[inline]
966 unsafe fn encode(
967 self,
968 encoder: &mut fidl::encoding::Encoder<'_, D>,
969 offset: usize,
970 depth: fidl::encoding::Depth,
971 ) -> fidl::Result<()> {
972 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceResponse>(offset);
973 self.0.encode(encoder, offset + 0, depth)?;
977 Ok(())
978 }
979 }
980
981 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
982 for DeviceMonitorDestroyIfaceResponse
983 {
984 #[inline(always)]
985 fn new_empty() -> Self {
986 Self { status: fidl::new_empty!(i32, D) }
987 }
988
989 #[inline]
990 unsafe fn decode(
991 &mut self,
992 decoder: &mut fidl::encoding::Decoder<'_, D>,
993 offset: usize,
994 _depth: fidl::encoding::Depth,
995 ) -> fidl::Result<()> {
996 decoder.debug_check_bounds::<Self>(offset);
997 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
998 unsafe {
1001 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1002 }
1003 Ok(())
1004 }
1005 }
1006
1007 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetCountryRequest {
1008 type Borrowed<'a> = &'a Self;
1009 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1010 value
1011 }
1012 }
1013
1014 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetCountryRequest {
1015 type Owned = Self;
1016
1017 #[inline(always)]
1018 fn inline_align(_context: fidl::encoding::Context) -> usize {
1019 2
1020 }
1021
1022 #[inline(always)]
1023 fn inline_size(_context: fidl::encoding::Context) -> usize {
1024 2
1025 }
1026 #[inline(always)]
1027 fn encode_is_copy() -> bool {
1028 true
1029 }
1030
1031 #[inline(always)]
1032 fn decode_is_copy() -> bool {
1033 true
1034 }
1035 }
1036
1037 unsafe impl<D: fidl::encoding::ResourceDialect>
1038 fidl::encoding::Encode<DeviceMonitorGetCountryRequest, D>
1039 for &DeviceMonitorGetCountryRequest
1040 {
1041 #[inline]
1042 unsafe fn encode(
1043 self,
1044 encoder: &mut fidl::encoding::Encoder<'_, D>,
1045 offset: usize,
1046 _depth: fidl::encoding::Depth,
1047 ) -> fidl::Result<()> {
1048 encoder.debug_check_bounds::<DeviceMonitorGetCountryRequest>(offset);
1049 unsafe {
1050 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1052 (buf_ptr as *mut DeviceMonitorGetCountryRequest)
1053 .write_unaligned((self as *const DeviceMonitorGetCountryRequest).read());
1054 }
1057 Ok(())
1058 }
1059 }
1060 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1061 fidl::encoding::Encode<DeviceMonitorGetCountryRequest, D> for (T0,)
1062 {
1063 #[inline]
1064 unsafe fn encode(
1065 self,
1066 encoder: &mut fidl::encoding::Encoder<'_, D>,
1067 offset: usize,
1068 depth: fidl::encoding::Depth,
1069 ) -> fidl::Result<()> {
1070 encoder.debug_check_bounds::<DeviceMonitorGetCountryRequest>(offset);
1071 self.0.encode(encoder, offset + 0, depth)?;
1075 Ok(())
1076 }
1077 }
1078
1079 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1080 for DeviceMonitorGetCountryRequest
1081 {
1082 #[inline(always)]
1083 fn new_empty() -> Self {
1084 Self { phy_id: fidl::new_empty!(u16, D) }
1085 }
1086
1087 #[inline]
1088 unsafe fn decode(
1089 &mut self,
1090 decoder: &mut fidl::encoding::Decoder<'_, D>,
1091 offset: usize,
1092 _depth: fidl::encoding::Depth,
1093 ) -> fidl::Result<()> {
1094 decoder.debug_check_bounds::<Self>(offset);
1095 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1096 unsafe {
1099 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1100 }
1101 Ok(())
1102 }
1103 }
1104
1105 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetDevPathRequest {
1106 type Borrowed<'a> = &'a Self;
1107 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1108 value
1109 }
1110 }
1111
1112 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetDevPathRequest {
1113 type Owned = Self;
1114
1115 #[inline(always)]
1116 fn inline_align(_context: fidl::encoding::Context) -> usize {
1117 2
1118 }
1119
1120 #[inline(always)]
1121 fn inline_size(_context: fidl::encoding::Context) -> usize {
1122 2
1123 }
1124 #[inline(always)]
1125 fn encode_is_copy() -> bool {
1126 true
1127 }
1128
1129 #[inline(always)]
1130 fn decode_is_copy() -> bool {
1131 true
1132 }
1133 }
1134
1135 unsafe impl<D: fidl::encoding::ResourceDialect>
1136 fidl::encoding::Encode<DeviceMonitorGetDevPathRequest, D>
1137 for &DeviceMonitorGetDevPathRequest
1138 {
1139 #[inline]
1140 unsafe fn encode(
1141 self,
1142 encoder: &mut fidl::encoding::Encoder<'_, D>,
1143 offset: usize,
1144 _depth: fidl::encoding::Depth,
1145 ) -> fidl::Result<()> {
1146 encoder.debug_check_bounds::<DeviceMonitorGetDevPathRequest>(offset);
1147 unsafe {
1148 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1150 (buf_ptr as *mut DeviceMonitorGetDevPathRequest)
1151 .write_unaligned((self as *const DeviceMonitorGetDevPathRequest).read());
1152 }
1155 Ok(())
1156 }
1157 }
1158 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1159 fidl::encoding::Encode<DeviceMonitorGetDevPathRequest, D> for (T0,)
1160 {
1161 #[inline]
1162 unsafe fn encode(
1163 self,
1164 encoder: &mut fidl::encoding::Encoder<'_, D>,
1165 offset: usize,
1166 depth: fidl::encoding::Depth,
1167 ) -> fidl::Result<()> {
1168 encoder.debug_check_bounds::<DeviceMonitorGetDevPathRequest>(offset);
1169 self.0.encode(encoder, offset + 0, depth)?;
1173 Ok(())
1174 }
1175 }
1176
1177 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1178 for DeviceMonitorGetDevPathRequest
1179 {
1180 #[inline(always)]
1181 fn new_empty() -> Self {
1182 Self { phy_id: fidl::new_empty!(u16, D) }
1183 }
1184
1185 #[inline]
1186 unsafe fn decode(
1187 &mut self,
1188 decoder: &mut fidl::encoding::Decoder<'_, D>,
1189 offset: usize,
1190 _depth: fidl::encoding::Depth,
1191 ) -> fidl::Result<()> {
1192 decoder.debug_check_bounds::<Self>(offset);
1193 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1194 unsafe {
1197 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1198 }
1199 Ok(())
1200 }
1201 }
1202
1203 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetDevPathResponse {
1204 type Borrowed<'a> = &'a Self;
1205 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1206 value
1207 }
1208 }
1209
1210 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetDevPathResponse {
1211 type Owned = Self;
1212
1213 #[inline(always)]
1214 fn inline_align(_context: fidl::encoding::Context) -> usize {
1215 8
1216 }
1217
1218 #[inline(always)]
1219 fn inline_size(_context: fidl::encoding::Context) -> usize {
1220 16
1221 }
1222 }
1223
1224 unsafe impl<D: fidl::encoding::ResourceDialect>
1225 fidl::encoding::Encode<DeviceMonitorGetDevPathResponse, D>
1226 for &DeviceMonitorGetDevPathResponse
1227 {
1228 #[inline]
1229 unsafe fn encode(
1230 self,
1231 encoder: &mut fidl::encoding::Encoder<'_, D>,
1232 offset: usize,
1233 _depth: fidl::encoding::Depth,
1234 ) -> fidl::Result<()> {
1235 encoder.debug_check_bounds::<DeviceMonitorGetDevPathResponse>(offset);
1236 fidl::encoding::Encode::<DeviceMonitorGetDevPathResponse, D>::encode(
1238 (
1239 <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.dev_path),
1240 ),
1241 encoder, offset, _depth
1242 )
1243 }
1244 }
1245 unsafe impl<
1246 D: fidl::encoding::ResourceDialect,
1247 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::UnboundedString>, D>,
1248 > fidl::encoding::Encode<DeviceMonitorGetDevPathResponse, D> for (T0,)
1249 {
1250 #[inline]
1251 unsafe fn encode(
1252 self,
1253 encoder: &mut fidl::encoding::Encoder<'_, D>,
1254 offset: usize,
1255 depth: fidl::encoding::Depth,
1256 ) -> fidl::Result<()> {
1257 encoder.debug_check_bounds::<DeviceMonitorGetDevPathResponse>(offset);
1258 self.0.encode(encoder, offset + 0, depth)?;
1262 Ok(())
1263 }
1264 }
1265
1266 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1267 for DeviceMonitorGetDevPathResponse
1268 {
1269 #[inline(always)]
1270 fn new_empty() -> Self {
1271 Self {
1272 dev_path: fidl::new_empty!(
1273 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1274 D
1275 ),
1276 }
1277 }
1278
1279 #[inline]
1280 unsafe fn decode(
1281 &mut self,
1282 decoder: &mut fidl::encoding::Decoder<'_, D>,
1283 offset: usize,
1284 _depth: fidl::encoding::Depth,
1285 ) -> fidl::Result<()> {
1286 decoder.debug_check_bounds::<Self>(offset);
1287 fidl::decode!(
1289 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1290 D,
1291 &mut self.dev_path,
1292 decoder,
1293 offset + 0,
1294 _depth
1295 )?;
1296 Ok(())
1297 }
1298 }
1299
1300 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerSaveModeRequest {
1301 type Borrowed<'a> = &'a Self;
1302 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1303 value
1304 }
1305 }
1306
1307 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerSaveModeRequest {
1308 type Owned = Self;
1309
1310 #[inline(always)]
1311 fn inline_align(_context: fidl::encoding::Context) -> usize {
1312 2
1313 }
1314
1315 #[inline(always)]
1316 fn inline_size(_context: fidl::encoding::Context) -> usize {
1317 2
1318 }
1319 #[inline(always)]
1320 fn encode_is_copy() -> bool {
1321 true
1322 }
1323
1324 #[inline(always)]
1325 fn decode_is_copy() -> bool {
1326 true
1327 }
1328 }
1329
1330 unsafe impl<D: fidl::encoding::ResourceDialect>
1331 fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeRequest, D>
1332 for &DeviceMonitorGetPowerSaveModeRequest
1333 {
1334 #[inline]
1335 unsafe fn encode(
1336 self,
1337 encoder: &mut fidl::encoding::Encoder<'_, D>,
1338 offset: usize,
1339 _depth: fidl::encoding::Depth,
1340 ) -> fidl::Result<()> {
1341 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeRequest>(offset);
1342 unsafe {
1343 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1345 (buf_ptr as *mut DeviceMonitorGetPowerSaveModeRequest)
1346 .write_unaligned((self as *const DeviceMonitorGetPowerSaveModeRequest).read());
1347 }
1350 Ok(())
1351 }
1352 }
1353 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1354 fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeRequest, D> for (T0,)
1355 {
1356 #[inline]
1357 unsafe fn encode(
1358 self,
1359 encoder: &mut fidl::encoding::Encoder<'_, D>,
1360 offset: usize,
1361 depth: fidl::encoding::Depth,
1362 ) -> fidl::Result<()> {
1363 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeRequest>(offset);
1364 self.0.encode(encoder, offset + 0, depth)?;
1368 Ok(())
1369 }
1370 }
1371
1372 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1373 for DeviceMonitorGetPowerSaveModeRequest
1374 {
1375 #[inline(always)]
1376 fn new_empty() -> Self {
1377 Self { phy_id: fidl::new_empty!(u16, D) }
1378 }
1379
1380 #[inline]
1381 unsafe fn decode(
1382 &mut self,
1383 decoder: &mut fidl::encoding::Decoder<'_, D>,
1384 offset: usize,
1385 _depth: fidl::encoding::Depth,
1386 ) -> fidl::Result<()> {
1387 decoder.debug_check_bounds::<Self>(offset);
1388 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1389 unsafe {
1392 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1393 }
1394 Ok(())
1395 }
1396 }
1397
1398 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetSupportedMacRolesRequest {
1399 type Borrowed<'a> = &'a Self;
1400 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1401 value
1402 }
1403 }
1404
1405 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetSupportedMacRolesRequest {
1406 type Owned = Self;
1407
1408 #[inline(always)]
1409 fn inline_align(_context: fidl::encoding::Context) -> usize {
1410 2
1411 }
1412
1413 #[inline(always)]
1414 fn inline_size(_context: fidl::encoding::Context) -> usize {
1415 2
1416 }
1417 #[inline(always)]
1418 fn encode_is_copy() -> bool {
1419 true
1420 }
1421
1422 #[inline(always)]
1423 fn decode_is_copy() -> bool {
1424 true
1425 }
1426 }
1427
1428 unsafe impl<D: fidl::encoding::ResourceDialect>
1429 fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesRequest, D>
1430 for &DeviceMonitorGetSupportedMacRolesRequest
1431 {
1432 #[inline]
1433 unsafe fn encode(
1434 self,
1435 encoder: &mut fidl::encoding::Encoder<'_, D>,
1436 offset: usize,
1437 _depth: fidl::encoding::Depth,
1438 ) -> fidl::Result<()> {
1439 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesRequest>(offset);
1440 unsafe {
1441 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1443 (buf_ptr as *mut DeviceMonitorGetSupportedMacRolesRequest).write_unaligned(
1444 (self as *const DeviceMonitorGetSupportedMacRolesRequest).read(),
1445 );
1446 }
1449 Ok(())
1450 }
1451 }
1452 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1453 fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesRequest, D> for (T0,)
1454 {
1455 #[inline]
1456 unsafe fn encode(
1457 self,
1458 encoder: &mut fidl::encoding::Encoder<'_, D>,
1459 offset: usize,
1460 depth: fidl::encoding::Depth,
1461 ) -> fidl::Result<()> {
1462 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesRequest>(offset);
1463 self.0.encode(encoder, offset + 0, depth)?;
1467 Ok(())
1468 }
1469 }
1470
1471 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1472 for DeviceMonitorGetSupportedMacRolesRequest
1473 {
1474 #[inline(always)]
1475 fn new_empty() -> Self {
1476 Self { phy_id: fidl::new_empty!(u16, D) }
1477 }
1478
1479 #[inline]
1480 unsafe fn decode(
1481 &mut self,
1482 decoder: &mut fidl::encoding::Decoder<'_, D>,
1483 offset: usize,
1484 _depth: fidl::encoding::Depth,
1485 ) -> fidl::Result<()> {
1486 decoder.debug_check_bounds::<Self>(offset);
1487 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1488 unsafe {
1491 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1492 }
1493 Ok(())
1494 }
1495 }
1496
1497 impl fidl::encoding::ValueTypeMarker for DeviceMonitorListIfacesResponse {
1498 type Borrowed<'a> = &'a Self;
1499 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1500 value
1501 }
1502 }
1503
1504 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorListIfacesResponse {
1505 type Owned = Self;
1506
1507 #[inline(always)]
1508 fn inline_align(_context: fidl::encoding::Context) -> usize {
1509 8
1510 }
1511
1512 #[inline(always)]
1513 fn inline_size(_context: fidl::encoding::Context) -> usize {
1514 16
1515 }
1516 }
1517
1518 unsafe impl<D: fidl::encoding::ResourceDialect>
1519 fidl::encoding::Encode<DeviceMonitorListIfacesResponse, D>
1520 for &DeviceMonitorListIfacesResponse
1521 {
1522 #[inline]
1523 unsafe fn encode(
1524 self,
1525 encoder: &mut fidl::encoding::Encoder<'_, D>,
1526 offset: usize,
1527 _depth: fidl::encoding::Depth,
1528 ) -> fidl::Result<()> {
1529 encoder.debug_check_bounds::<DeviceMonitorListIfacesResponse>(offset);
1530 fidl::encoding::Encode::<DeviceMonitorListIfacesResponse, D>::encode(
1532 (
1533 <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.iface_list),
1534 ),
1535 encoder, offset, _depth
1536 )
1537 }
1538 }
1539 unsafe impl<
1540 D: fidl::encoding::ResourceDialect,
1541 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u16>, D>,
1542 > fidl::encoding::Encode<DeviceMonitorListIfacesResponse, D> for (T0,)
1543 {
1544 #[inline]
1545 unsafe fn encode(
1546 self,
1547 encoder: &mut fidl::encoding::Encoder<'_, D>,
1548 offset: usize,
1549 depth: fidl::encoding::Depth,
1550 ) -> fidl::Result<()> {
1551 encoder.debug_check_bounds::<DeviceMonitorListIfacesResponse>(offset);
1552 self.0.encode(encoder, offset + 0, depth)?;
1556 Ok(())
1557 }
1558 }
1559
1560 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1561 for DeviceMonitorListIfacesResponse
1562 {
1563 #[inline(always)]
1564 fn new_empty() -> Self {
1565 Self { iface_list: fidl::new_empty!(fidl::encoding::UnboundedVector<u16>, D) }
1566 }
1567
1568 #[inline]
1569 unsafe fn decode(
1570 &mut self,
1571 decoder: &mut fidl::encoding::Decoder<'_, D>,
1572 offset: usize,
1573 _depth: fidl::encoding::Depth,
1574 ) -> fidl::Result<()> {
1575 decoder.debug_check_bounds::<Self>(offset);
1576 fidl::decode!(
1578 fidl::encoding::UnboundedVector<u16>,
1579 D,
1580 &mut self.iface_list,
1581 decoder,
1582 offset + 0,
1583 _depth
1584 )?;
1585 Ok(())
1586 }
1587 }
1588
1589 impl fidl::encoding::ValueTypeMarker for DeviceMonitorListPhysResponse {
1590 type Borrowed<'a> = &'a Self;
1591 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1592 value
1593 }
1594 }
1595
1596 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorListPhysResponse {
1597 type Owned = Self;
1598
1599 #[inline(always)]
1600 fn inline_align(_context: fidl::encoding::Context) -> usize {
1601 8
1602 }
1603
1604 #[inline(always)]
1605 fn inline_size(_context: fidl::encoding::Context) -> usize {
1606 16
1607 }
1608 }
1609
1610 unsafe impl<D: fidl::encoding::ResourceDialect>
1611 fidl::encoding::Encode<DeviceMonitorListPhysResponse, D>
1612 for &DeviceMonitorListPhysResponse
1613 {
1614 #[inline]
1615 unsafe fn encode(
1616 self,
1617 encoder: &mut fidl::encoding::Encoder<'_, D>,
1618 offset: usize,
1619 _depth: fidl::encoding::Depth,
1620 ) -> fidl::Result<()> {
1621 encoder.debug_check_bounds::<DeviceMonitorListPhysResponse>(offset);
1622 fidl::encoding::Encode::<DeviceMonitorListPhysResponse, D>::encode(
1624 (
1625 <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_list),
1626 ),
1627 encoder, offset, _depth
1628 )
1629 }
1630 }
1631 unsafe impl<
1632 D: fidl::encoding::ResourceDialect,
1633 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u16>, D>,
1634 > fidl::encoding::Encode<DeviceMonitorListPhysResponse, D> for (T0,)
1635 {
1636 #[inline]
1637 unsafe fn encode(
1638 self,
1639 encoder: &mut fidl::encoding::Encoder<'_, D>,
1640 offset: usize,
1641 depth: fidl::encoding::Depth,
1642 ) -> fidl::Result<()> {
1643 encoder.debug_check_bounds::<DeviceMonitorListPhysResponse>(offset);
1644 self.0.encode(encoder, offset + 0, depth)?;
1648 Ok(())
1649 }
1650 }
1651
1652 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1653 for DeviceMonitorListPhysResponse
1654 {
1655 #[inline(always)]
1656 fn new_empty() -> Self {
1657 Self { phy_list: fidl::new_empty!(fidl::encoding::UnboundedVector<u16>, D) }
1658 }
1659
1660 #[inline]
1661 unsafe fn decode(
1662 &mut self,
1663 decoder: &mut fidl::encoding::Decoder<'_, D>,
1664 offset: usize,
1665 _depth: fidl::encoding::Depth,
1666 ) -> fidl::Result<()> {
1667 decoder.debug_check_bounds::<Self>(offset);
1668 fidl::decode!(
1670 fidl::encoding::UnboundedVector<u16>,
1671 D,
1672 &mut self.phy_list,
1673 decoder,
1674 offset + 0,
1675 _depth
1676 )?;
1677 Ok(())
1678 }
1679 }
1680
1681 impl fidl::encoding::ValueTypeMarker for DeviceMonitorQueryIfaceRequest {
1682 type Borrowed<'a> = &'a Self;
1683 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1684 value
1685 }
1686 }
1687
1688 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorQueryIfaceRequest {
1689 type Owned = Self;
1690
1691 #[inline(always)]
1692 fn inline_align(_context: fidl::encoding::Context) -> usize {
1693 2
1694 }
1695
1696 #[inline(always)]
1697 fn inline_size(_context: fidl::encoding::Context) -> usize {
1698 2
1699 }
1700 #[inline(always)]
1701 fn encode_is_copy() -> bool {
1702 true
1703 }
1704
1705 #[inline(always)]
1706 fn decode_is_copy() -> bool {
1707 true
1708 }
1709 }
1710
1711 unsafe impl<D: fidl::encoding::ResourceDialect>
1712 fidl::encoding::Encode<DeviceMonitorQueryIfaceRequest, D>
1713 for &DeviceMonitorQueryIfaceRequest
1714 {
1715 #[inline]
1716 unsafe fn encode(
1717 self,
1718 encoder: &mut fidl::encoding::Encoder<'_, D>,
1719 offset: usize,
1720 _depth: fidl::encoding::Depth,
1721 ) -> fidl::Result<()> {
1722 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceRequest>(offset);
1723 unsafe {
1724 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1726 (buf_ptr as *mut DeviceMonitorQueryIfaceRequest)
1727 .write_unaligned((self as *const DeviceMonitorQueryIfaceRequest).read());
1728 }
1731 Ok(())
1732 }
1733 }
1734 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1735 fidl::encoding::Encode<DeviceMonitorQueryIfaceRequest, D> for (T0,)
1736 {
1737 #[inline]
1738 unsafe fn encode(
1739 self,
1740 encoder: &mut fidl::encoding::Encoder<'_, D>,
1741 offset: usize,
1742 depth: fidl::encoding::Depth,
1743 ) -> fidl::Result<()> {
1744 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceRequest>(offset);
1745 self.0.encode(encoder, offset + 0, depth)?;
1749 Ok(())
1750 }
1751 }
1752
1753 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1754 for DeviceMonitorQueryIfaceRequest
1755 {
1756 #[inline(always)]
1757 fn new_empty() -> Self {
1758 Self { iface_id: fidl::new_empty!(u16, D) }
1759 }
1760
1761 #[inline]
1762 unsafe fn decode(
1763 &mut self,
1764 decoder: &mut fidl::encoding::Decoder<'_, D>,
1765 offset: usize,
1766 _depth: fidl::encoding::Depth,
1767 ) -> fidl::Result<()> {
1768 decoder.debug_check_bounds::<Self>(offset);
1769 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1770 unsafe {
1773 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1774 }
1775 Ok(())
1776 }
1777 }
1778
1779 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetCountryRequest {
1780 type Borrowed<'a> = &'a Self;
1781 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1782 value
1783 }
1784 }
1785
1786 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetCountryRequest {
1787 type Owned = Self;
1788
1789 #[inline(always)]
1790 fn inline_align(_context: fidl::encoding::Context) -> usize {
1791 2
1792 }
1793
1794 #[inline(always)]
1795 fn inline_size(_context: fidl::encoding::Context) -> usize {
1796 4
1797 }
1798 #[inline(always)]
1799 fn encode_is_copy() -> bool {
1800 true
1801 }
1802
1803 #[inline(always)]
1804 fn decode_is_copy() -> bool {
1805 true
1806 }
1807 }
1808
1809 unsafe impl<D: fidl::encoding::ResourceDialect>
1810 fidl::encoding::Encode<DeviceMonitorSetCountryRequest, D>
1811 for &DeviceMonitorSetCountryRequest
1812 {
1813 #[inline]
1814 unsafe fn encode(
1815 self,
1816 encoder: &mut fidl::encoding::Encoder<'_, D>,
1817 offset: usize,
1818 _depth: fidl::encoding::Depth,
1819 ) -> fidl::Result<()> {
1820 encoder.debug_check_bounds::<DeviceMonitorSetCountryRequest>(offset);
1821 unsafe {
1822 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1824 (buf_ptr as *mut DeviceMonitorSetCountryRequest)
1825 .write_unaligned((self as *const DeviceMonitorSetCountryRequest).read());
1826 }
1829 Ok(())
1830 }
1831 }
1832 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetCountryRequest, D>>
1833 fidl::encoding::Encode<DeviceMonitorSetCountryRequest, D> for (T0,)
1834 {
1835 #[inline]
1836 unsafe fn encode(
1837 self,
1838 encoder: &mut fidl::encoding::Encoder<'_, D>,
1839 offset: usize,
1840 depth: fidl::encoding::Depth,
1841 ) -> fidl::Result<()> {
1842 encoder.debug_check_bounds::<DeviceMonitorSetCountryRequest>(offset);
1843 self.0.encode(encoder, offset + 0, depth)?;
1847 Ok(())
1848 }
1849 }
1850
1851 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1852 for DeviceMonitorSetCountryRequest
1853 {
1854 #[inline(always)]
1855 fn new_empty() -> Self {
1856 Self { req: fidl::new_empty!(SetCountryRequest, D) }
1857 }
1858
1859 #[inline]
1860 unsafe fn decode(
1861 &mut self,
1862 decoder: &mut fidl::encoding::Decoder<'_, D>,
1863 offset: usize,
1864 _depth: fidl::encoding::Depth,
1865 ) -> fidl::Result<()> {
1866 decoder.debug_check_bounds::<Self>(offset);
1867 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1868 unsafe {
1871 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1872 }
1873 Ok(())
1874 }
1875 }
1876
1877 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetCountryResponse {
1878 type Borrowed<'a> = &'a Self;
1879 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1880 value
1881 }
1882 }
1883
1884 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetCountryResponse {
1885 type Owned = Self;
1886
1887 #[inline(always)]
1888 fn inline_align(_context: fidl::encoding::Context) -> usize {
1889 4
1890 }
1891
1892 #[inline(always)]
1893 fn inline_size(_context: fidl::encoding::Context) -> usize {
1894 4
1895 }
1896 #[inline(always)]
1897 fn encode_is_copy() -> bool {
1898 true
1899 }
1900
1901 #[inline(always)]
1902 fn decode_is_copy() -> bool {
1903 true
1904 }
1905 }
1906
1907 unsafe impl<D: fidl::encoding::ResourceDialect>
1908 fidl::encoding::Encode<DeviceMonitorSetCountryResponse, D>
1909 for &DeviceMonitorSetCountryResponse
1910 {
1911 #[inline]
1912 unsafe fn encode(
1913 self,
1914 encoder: &mut fidl::encoding::Encoder<'_, D>,
1915 offset: usize,
1916 _depth: fidl::encoding::Depth,
1917 ) -> fidl::Result<()> {
1918 encoder.debug_check_bounds::<DeviceMonitorSetCountryResponse>(offset);
1919 unsafe {
1920 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1922 (buf_ptr as *mut DeviceMonitorSetCountryResponse)
1923 .write_unaligned((self as *const DeviceMonitorSetCountryResponse).read());
1924 }
1927 Ok(())
1928 }
1929 }
1930 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
1931 fidl::encoding::Encode<DeviceMonitorSetCountryResponse, D> for (T0,)
1932 {
1933 #[inline]
1934 unsafe fn encode(
1935 self,
1936 encoder: &mut fidl::encoding::Encoder<'_, D>,
1937 offset: usize,
1938 depth: fidl::encoding::Depth,
1939 ) -> fidl::Result<()> {
1940 encoder.debug_check_bounds::<DeviceMonitorSetCountryResponse>(offset);
1941 self.0.encode(encoder, offset + 0, depth)?;
1945 Ok(())
1946 }
1947 }
1948
1949 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1950 for DeviceMonitorSetCountryResponse
1951 {
1952 #[inline(always)]
1953 fn new_empty() -> Self {
1954 Self { status: fidl::new_empty!(i32, D) }
1955 }
1956
1957 #[inline]
1958 unsafe fn decode(
1959 &mut self,
1960 decoder: &mut fidl::encoding::Decoder<'_, D>,
1961 offset: usize,
1962 _depth: fidl::encoding::Depth,
1963 ) -> fidl::Result<()> {
1964 decoder.debug_check_bounds::<Self>(offset);
1965 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1966 unsafe {
1969 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1970 }
1971 Ok(())
1972 }
1973 }
1974
1975 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetPowerSaveModeRequest {
1976 type Borrowed<'a> = &'a Self;
1977 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1978 value
1979 }
1980 }
1981
1982 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetPowerSaveModeRequest {
1983 type Owned = Self;
1984
1985 #[inline(always)]
1986 fn inline_align(_context: fidl::encoding::Context) -> usize {
1987 4
1988 }
1989
1990 #[inline(always)]
1991 fn inline_size(_context: fidl::encoding::Context) -> usize {
1992 8
1993 }
1994 }
1995
1996 unsafe impl<D: fidl::encoding::ResourceDialect>
1997 fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeRequest, D>
1998 for &DeviceMonitorSetPowerSaveModeRequest
1999 {
2000 #[inline]
2001 unsafe fn encode(
2002 self,
2003 encoder: &mut fidl::encoding::Encoder<'_, D>,
2004 offset: usize,
2005 _depth: fidl::encoding::Depth,
2006 ) -> fidl::Result<()> {
2007 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeRequest>(offset);
2008 fidl::encoding::Encode::<DeviceMonitorSetPowerSaveModeRequest, D>::encode(
2010 (<SetPowerSaveModeRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
2011 encoder,
2012 offset,
2013 _depth,
2014 )
2015 }
2016 }
2017 unsafe impl<
2018 D: fidl::encoding::ResourceDialect,
2019 T0: fidl::encoding::Encode<SetPowerSaveModeRequest, D>,
2020 > fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeRequest, D> for (T0,)
2021 {
2022 #[inline]
2023 unsafe fn encode(
2024 self,
2025 encoder: &mut fidl::encoding::Encoder<'_, D>,
2026 offset: usize,
2027 depth: fidl::encoding::Depth,
2028 ) -> fidl::Result<()> {
2029 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeRequest>(offset);
2030 self.0.encode(encoder, offset + 0, depth)?;
2034 Ok(())
2035 }
2036 }
2037
2038 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2039 for DeviceMonitorSetPowerSaveModeRequest
2040 {
2041 #[inline(always)]
2042 fn new_empty() -> Self {
2043 Self { req: fidl::new_empty!(SetPowerSaveModeRequest, D) }
2044 }
2045
2046 #[inline]
2047 unsafe fn decode(
2048 &mut self,
2049 decoder: &mut fidl::encoding::Decoder<'_, D>,
2050 offset: usize,
2051 _depth: fidl::encoding::Depth,
2052 ) -> fidl::Result<()> {
2053 decoder.debug_check_bounds::<Self>(offset);
2054 fidl::decode!(SetPowerSaveModeRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
2056 Ok(())
2057 }
2058 }
2059
2060 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetPowerSaveModeResponse {
2061 type Borrowed<'a> = &'a Self;
2062 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2063 value
2064 }
2065 }
2066
2067 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetPowerSaveModeResponse {
2068 type Owned = Self;
2069
2070 #[inline(always)]
2071 fn inline_align(_context: fidl::encoding::Context) -> usize {
2072 4
2073 }
2074
2075 #[inline(always)]
2076 fn inline_size(_context: fidl::encoding::Context) -> usize {
2077 4
2078 }
2079 #[inline(always)]
2080 fn encode_is_copy() -> bool {
2081 true
2082 }
2083
2084 #[inline(always)]
2085 fn decode_is_copy() -> bool {
2086 true
2087 }
2088 }
2089
2090 unsafe impl<D: fidl::encoding::ResourceDialect>
2091 fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeResponse, D>
2092 for &DeviceMonitorSetPowerSaveModeResponse
2093 {
2094 #[inline]
2095 unsafe fn encode(
2096 self,
2097 encoder: &mut fidl::encoding::Encoder<'_, D>,
2098 offset: usize,
2099 _depth: fidl::encoding::Depth,
2100 ) -> fidl::Result<()> {
2101 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeResponse>(offset);
2102 unsafe {
2103 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2105 (buf_ptr as *mut DeviceMonitorSetPowerSaveModeResponse)
2106 .write_unaligned((self as *const DeviceMonitorSetPowerSaveModeResponse).read());
2107 }
2110 Ok(())
2111 }
2112 }
2113 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
2114 fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeResponse, D> for (T0,)
2115 {
2116 #[inline]
2117 unsafe fn encode(
2118 self,
2119 encoder: &mut fidl::encoding::Encoder<'_, D>,
2120 offset: usize,
2121 depth: fidl::encoding::Depth,
2122 ) -> fidl::Result<()> {
2123 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeResponse>(offset);
2124 self.0.encode(encoder, offset + 0, depth)?;
2128 Ok(())
2129 }
2130 }
2131
2132 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2133 for DeviceMonitorSetPowerSaveModeResponse
2134 {
2135 #[inline(always)]
2136 fn new_empty() -> Self {
2137 Self { status: fidl::new_empty!(i32, D) }
2138 }
2139
2140 #[inline]
2141 unsafe fn decode(
2142 &mut self,
2143 decoder: &mut fidl::encoding::Decoder<'_, D>,
2144 offset: usize,
2145 _depth: fidl::encoding::Depth,
2146 ) -> fidl::Result<()> {
2147 decoder.debug_check_bounds::<Self>(offset);
2148 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2149 unsafe {
2152 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
2153 }
2154 Ok(())
2155 }
2156 }
2157
2158 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetCountryResponse {
2159 type Borrowed<'a> = &'a Self;
2160 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2161 value
2162 }
2163 }
2164
2165 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetCountryResponse {
2166 type Owned = Self;
2167
2168 #[inline(always)]
2169 fn inline_align(_context: fidl::encoding::Context) -> usize {
2170 1
2171 }
2172
2173 #[inline(always)]
2174 fn inline_size(_context: fidl::encoding::Context) -> usize {
2175 2
2176 }
2177 #[inline(always)]
2178 fn encode_is_copy() -> bool {
2179 true
2180 }
2181
2182 #[inline(always)]
2183 fn decode_is_copy() -> bool {
2184 true
2185 }
2186 }
2187
2188 unsafe impl<D: fidl::encoding::ResourceDialect>
2189 fidl::encoding::Encode<DeviceMonitorGetCountryResponse, D>
2190 for &DeviceMonitorGetCountryResponse
2191 {
2192 #[inline]
2193 unsafe fn encode(
2194 self,
2195 encoder: &mut fidl::encoding::Encoder<'_, D>,
2196 offset: usize,
2197 _depth: fidl::encoding::Depth,
2198 ) -> fidl::Result<()> {
2199 encoder.debug_check_bounds::<DeviceMonitorGetCountryResponse>(offset);
2200 unsafe {
2201 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2203 (buf_ptr as *mut DeviceMonitorGetCountryResponse)
2204 .write_unaligned((self as *const DeviceMonitorGetCountryResponse).read());
2205 }
2208 Ok(())
2209 }
2210 }
2211 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<GetCountryResponse, D>>
2212 fidl::encoding::Encode<DeviceMonitorGetCountryResponse, D> for (T0,)
2213 {
2214 #[inline]
2215 unsafe fn encode(
2216 self,
2217 encoder: &mut fidl::encoding::Encoder<'_, D>,
2218 offset: usize,
2219 depth: fidl::encoding::Depth,
2220 ) -> fidl::Result<()> {
2221 encoder.debug_check_bounds::<DeviceMonitorGetCountryResponse>(offset);
2222 self.0.encode(encoder, offset + 0, depth)?;
2226 Ok(())
2227 }
2228 }
2229
2230 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2231 for DeviceMonitorGetCountryResponse
2232 {
2233 #[inline(always)]
2234 fn new_empty() -> Self {
2235 Self { resp: fidl::new_empty!(GetCountryResponse, D) }
2236 }
2237
2238 #[inline]
2239 unsafe fn decode(
2240 &mut self,
2241 decoder: &mut fidl::encoding::Decoder<'_, D>,
2242 offset: usize,
2243 _depth: fidl::encoding::Depth,
2244 ) -> fidl::Result<()> {
2245 decoder.debug_check_bounds::<Self>(offset);
2246 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2247 unsafe {
2250 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2251 }
2252 Ok(())
2253 }
2254 }
2255
2256 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerSaveModeResponse {
2257 type Borrowed<'a> = &'a Self;
2258 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2259 value
2260 }
2261 }
2262
2263 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerSaveModeResponse {
2264 type Owned = Self;
2265
2266 #[inline(always)]
2267 fn inline_align(_context: fidl::encoding::Context) -> usize {
2268 4
2269 }
2270
2271 #[inline(always)]
2272 fn inline_size(_context: fidl::encoding::Context) -> usize {
2273 4
2274 }
2275 }
2276
2277 unsafe impl<D: fidl::encoding::ResourceDialect>
2278 fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeResponse, D>
2279 for &DeviceMonitorGetPowerSaveModeResponse
2280 {
2281 #[inline]
2282 unsafe fn encode(
2283 self,
2284 encoder: &mut fidl::encoding::Encoder<'_, D>,
2285 offset: usize,
2286 _depth: fidl::encoding::Depth,
2287 ) -> fidl::Result<()> {
2288 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeResponse>(offset);
2289 fidl::encoding::Encode::<DeviceMonitorGetPowerSaveModeResponse, D>::encode(
2291 (<GetPowerSaveModeResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2292 encoder,
2293 offset,
2294 _depth,
2295 )
2296 }
2297 }
2298 unsafe impl<
2299 D: fidl::encoding::ResourceDialect,
2300 T0: fidl::encoding::Encode<GetPowerSaveModeResponse, D>,
2301 > fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeResponse, D> for (T0,)
2302 {
2303 #[inline]
2304 unsafe fn encode(
2305 self,
2306 encoder: &mut fidl::encoding::Encoder<'_, D>,
2307 offset: usize,
2308 depth: fidl::encoding::Depth,
2309 ) -> fidl::Result<()> {
2310 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeResponse>(offset);
2311 self.0.encode(encoder, offset + 0, depth)?;
2315 Ok(())
2316 }
2317 }
2318
2319 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2320 for DeviceMonitorGetPowerSaveModeResponse
2321 {
2322 #[inline(always)]
2323 fn new_empty() -> Self {
2324 Self { resp: fidl::new_empty!(GetPowerSaveModeResponse, D) }
2325 }
2326
2327 #[inline]
2328 unsafe fn decode(
2329 &mut self,
2330 decoder: &mut fidl::encoding::Decoder<'_, D>,
2331 offset: usize,
2332 _depth: fidl::encoding::Depth,
2333 ) -> fidl::Result<()> {
2334 decoder.debug_check_bounds::<Self>(offset);
2335 fidl::decode!(
2337 GetPowerSaveModeResponse,
2338 D,
2339 &mut self.resp,
2340 decoder,
2341 offset + 0,
2342 _depth
2343 )?;
2344 Ok(())
2345 }
2346 }
2347
2348 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetSupportedMacRolesResponse {
2349 type Borrowed<'a> = &'a Self;
2350 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2351 value
2352 }
2353 }
2354
2355 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetSupportedMacRolesResponse {
2356 type Owned = Self;
2357
2358 #[inline(always)]
2359 fn inline_align(_context: fidl::encoding::Context) -> usize {
2360 8
2361 }
2362
2363 #[inline(always)]
2364 fn inline_size(_context: fidl::encoding::Context) -> usize {
2365 16
2366 }
2367 }
2368
2369 unsafe impl<D: fidl::encoding::ResourceDialect>
2370 fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesResponse, D>
2371 for &DeviceMonitorGetSupportedMacRolesResponse
2372 {
2373 #[inline]
2374 unsafe fn encode(
2375 self,
2376 encoder: &mut fidl::encoding::Encoder<'_, D>,
2377 offset: usize,
2378 _depth: fidl::encoding::Depth,
2379 ) -> fidl::Result<()> {
2380 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesResponse>(offset);
2381 fidl::encoding::Encode::<DeviceMonitorGetSupportedMacRolesResponse, D>::encode(
2383 (
2384 <fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.supported_mac_roles),
2385 ),
2386 encoder, offset, _depth
2387 )
2388 }
2389 }
2390 unsafe impl<
2391 D: fidl::encoding::ResourceDialect,
2392 T0: fidl::encoding::Encode<
2393 fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>,
2394 D,
2395 >,
2396 > fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesResponse, D> for (T0,)
2397 {
2398 #[inline]
2399 unsafe fn encode(
2400 self,
2401 encoder: &mut fidl::encoding::Encoder<'_, D>,
2402 offset: usize,
2403 depth: fidl::encoding::Depth,
2404 ) -> fidl::Result<()> {
2405 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesResponse>(offset);
2406 self.0.encode(encoder, offset + 0, depth)?;
2410 Ok(())
2411 }
2412 }
2413
2414 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2415 for DeviceMonitorGetSupportedMacRolesResponse
2416 {
2417 #[inline(always)]
2418 fn new_empty() -> Self {
2419 Self {
2420 supported_mac_roles: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>, D),
2421 }
2422 }
2423
2424 #[inline]
2425 unsafe fn decode(
2426 &mut self,
2427 decoder: &mut fidl::encoding::Decoder<'_, D>,
2428 offset: usize,
2429 _depth: fidl::encoding::Depth,
2430 ) -> fidl::Result<()> {
2431 decoder.debug_check_bounds::<Self>(offset);
2432 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>, D, &mut self.supported_mac_roles, decoder, offset + 0, _depth)?;
2434 Ok(())
2435 }
2436 }
2437
2438 impl fidl::encoding::ValueTypeMarker for DeviceMonitorQueryIfaceResponse {
2439 type Borrowed<'a> = &'a Self;
2440 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2441 value
2442 }
2443 }
2444
2445 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorQueryIfaceResponse {
2446 type Owned = Self;
2447
2448 #[inline(always)]
2449 fn inline_align(_context: fidl::encoding::Context) -> usize {
2450 4
2451 }
2452
2453 #[inline(always)]
2454 fn inline_size(_context: fidl::encoding::Context) -> usize {
2455 16
2456 }
2457 }
2458
2459 unsafe impl<D: fidl::encoding::ResourceDialect>
2460 fidl::encoding::Encode<DeviceMonitorQueryIfaceResponse, D>
2461 for &DeviceMonitorQueryIfaceResponse
2462 {
2463 #[inline]
2464 unsafe fn encode(
2465 self,
2466 encoder: &mut fidl::encoding::Encoder<'_, D>,
2467 offset: usize,
2468 _depth: fidl::encoding::Depth,
2469 ) -> fidl::Result<()> {
2470 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceResponse>(offset);
2471 fidl::encoding::Encode::<DeviceMonitorQueryIfaceResponse, D>::encode(
2473 (<QueryIfaceResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2474 encoder,
2475 offset,
2476 _depth,
2477 )
2478 }
2479 }
2480 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<QueryIfaceResponse, D>>
2481 fidl::encoding::Encode<DeviceMonitorQueryIfaceResponse, D> for (T0,)
2482 {
2483 #[inline]
2484 unsafe fn encode(
2485 self,
2486 encoder: &mut fidl::encoding::Encoder<'_, D>,
2487 offset: usize,
2488 depth: fidl::encoding::Depth,
2489 ) -> fidl::Result<()> {
2490 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceResponse>(offset);
2491 self.0.encode(encoder, offset + 0, depth)?;
2495 Ok(())
2496 }
2497 }
2498
2499 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2500 for DeviceMonitorQueryIfaceResponse
2501 {
2502 #[inline(always)]
2503 fn new_empty() -> Self {
2504 Self { resp: fidl::new_empty!(QueryIfaceResponse, D) }
2505 }
2506
2507 #[inline]
2508 unsafe fn decode(
2509 &mut self,
2510 decoder: &mut fidl::encoding::Decoder<'_, D>,
2511 offset: usize,
2512 _depth: fidl::encoding::Depth,
2513 ) -> fidl::Result<()> {
2514 decoder.debug_check_bounds::<Self>(offset);
2515 fidl::decode!(QueryIfaceResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
2517 Ok(())
2518 }
2519 }
2520
2521 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnIfaceAddedRequest {
2522 type Borrowed<'a> = &'a Self;
2523 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2524 value
2525 }
2526 }
2527
2528 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnIfaceAddedRequest {
2529 type Owned = Self;
2530
2531 #[inline(always)]
2532 fn inline_align(_context: fidl::encoding::Context) -> usize {
2533 2
2534 }
2535
2536 #[inline(always)]
2537 fn inline_size(_context: fidl::encoding::Context) -> usize {
2538 2
2539 }
2540 #[inline(always)]
2541 fn encode_is_copy() -> bool {
2542 true
2543 }
2544
2545 #[inline(always)]
2546 fn decode_is_copy() -> bool {
2547 true
2548 }
2549 }
2550
2551 unsafe impl<D: fidl::encoding::ResourceDialect>
2552 fidl::encoding::Encode<DeviceWatcherOnIfaceAddedRequest, D>
2553 for &DeviceWatcherOnIfaceAddedRequest
2554 {
2555 #[inline]
2556 unsafe fn encode(
2557 self,
2558 encoder: &mut fidl::encoding::Encoder<'_, D>,
2559 offset: usize,
2560 _depth: fidl::encoding::Depth,
2561 ) -> fidl::Result<()> {
2562 encoder.debug_check_bounds::<DeviceWatcherOnIfaceAddedRequest>(offset);
2563 unsafe {
2564 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2566 (buf_ptr as *mut DeviceWatcherOnIfaceAddedRequest)
2567 .write_unaligned((self as *const DeviceWatcherOnIfaceAddedRequest).read());
2568 }
2571 Ok(())
2572 }
2573 }
2574 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2575 fidl::encoding::Encode<DeviceWatcherOnIfaceAddedRequest, D> for (T0,)
2576 {
2577 #[inline]
2578 unsafe fn encode(
2579 self,
2580 encoder: &mut fidl::encoding::Encoder<'_, D>,
2581 offset: usize,
2582 depth: fidl::encoding::Depth,
2583 ) -> fidl::Result<()> {
2584 encoder.debug_check_bounds::<DeviceWatcherOnIfaceAddedRequest>(offset);
2585 self.0.encode(encoder, offset + 0, depth)?;
2589 Ok(())
2590 }
2591 }
2592
2593 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2594 for DeviceWatcherOnIfaceAddedRequest
2595 {
2596 #[inline(always)]
2597 fn new_empty() -> Self {
2598 Self { iface_id: fidl::new_empty!(u16, D) }
2599 }
2600
2601 #[inline]
2602 unsafe fn decode(
2603 &mut self,
2604 decoder: &mut fidl::encoding::Decoder<'_, D>,
2605 offset: usize,
2606 _depth: fidl::encoding::Depth,
2607 ) -> fidl::Result<()> {
2608 decoder.debug_check_bounds::<Self>(offset);
2609 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2610 unsafe {
2613 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2614 }
2615 Ok(())
2616 }
2617 }
2618
2619 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnIfaceRemovedRequest {
2620 type Borrowed<'a> = &'a Self;
2621 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2622 value
2623 }
2624 }
2625
2626 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnIfaceRemovedRequest {
2627 type Owned = Self;
2628
2629 #[inline(always)]
2630 fn inline_align(_context: fidl::encoding::Context) -> usize {
2631 2
2632 }
2633
2634 #[inline(always)]
2635 fn inline_size(_context: fidl::encoding::Context) -> usize {
2636 2
2637 }
2638 #[inline(always)]
2639 fn encode_is_copy() -> bool {
2640 true
2641 }
2642
2643 #[inline(always)]
2644 fn decode_is_copy() -> bool {
2645 true
2646 }
2647 }
2648
2649 unsafe impl<D: fidl::encoding::ResourceDialect>
2650 fidl::encoding::Encode<DeviceWatcherOnIfaceRemovedRequest, D>
2651 for &DeviceWatcherOnIfaceRemovedRequest
2652 {
2653 #[inline]
2654 unsafe fn encode(
2655 self,
2656 encoder: &mut fidl::encoding::Encoder<'_, D>,
2657 offset: usize,
2658 _depth: fidl::encoding::Depth,
2659 ) -> fidl::Result<()> {
2660 encoder.debug_check_bounds::<DeviceWatcherOnIfaceRemovedRequest>(offset);
2661 unsafe {
2662 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2664 (buf_ptr as *mut DeviceWatcherOnIfaceRemovedRequest)
2665 .write_unaligned((self as *const DeviceWatcherOnIfaceRemovedRequest).read());
2666 }
2669 Ok(())
2670 }
2671 }
2672 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2673 fidl::encoding::Encode<DeviceWatcherOnIfaceRemovedRequest, D> for (T0,)
2674 {
2675 #[inline]
2676 unsafe fn encode(
2677 self,
2678 encoder: &mut fidl::encoding::Encoder<'_, D>,
2679 offset: usize,
2680 depth: fidl::encoding::Depth,
2681 ) -> fidl::Result<()> {
2682 encoder.debug_check_bounds::<DeviceWatcherOnIfaceRemovedRequest>(offset);
2683 self.0.encode(encoder, offset + 0, depth)?;
2687 Ok(())
2688 }
2689 }
2690
2691 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2692 for DeviceWatcherOnIfaceRemovedRequest
2693 {
2694 #[inline(always)]
2695 fn new_empty() -> Self {
2696 Self { iface_id: fidl::new_empty!(u16, D) }
2697 }
2698
2699 #[inline]
2700 unsafe fn decode(
2701 &mut self,
2702 decoder: &mut fidl::encoding::Decoder<'_, D>,
2703 offset: usize,
2704 _depth: fidl::encoding::Depth,
2705 ) -> fidl::Result<()> {
2706 decoder.debug_check_bounds::<Self>(offset);
2707 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2708 unsafe {
2711 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2712 }
2713 Ok(())
2714 }
2715 }
2716
2717 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnPhyAddedRequest {
2718 type Borrowed<'a> = &'a Self;
2719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2720 value
2721 }
2722 }
2723
2724 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnPhyAddedRequest {
2725 type Owned = Self;
2726
2727 #[inline(always)]
2728 fn inline_align(_context: fidl::encoding::Context) -> usize {
2729 2
2730 }
2731
2732 #[inline(always)]
2733 fn inline_size(_context: fidl::encoding::Context) -> usize {
2734 2
2735 }
2736 #[inline(always)]
2737 fn encode_is_copy() -> bool {
2738 true
2739 }
2740
2741 #[inline(always)]
2742 fn decode_is_copy() -> bool {
2743 true
2744 }
2745 }
2746
2747 unsafe impl<D: fidl::encoding::ResourceDialect>
2748 fidl::encoding::Encode<DeviceWatcherOnPhyAddedRequest, D>
2749 for &DeviceWatcherOnPhyAddedRequest
2750 {
2751 #[inline]
2752 unsafe fn encode(
2753 self,
2754 encoder: &mut fidl::encoding::Encoder<'_, D>,
2755 offset: usize,
2756 _depth: fidl::encoding::Depth,
2757 ) -> fidl::Result<()> {
2758 encoder.debug_check_bounds::<DeviceWatcherOnPhyAddedRequest>(offset);
2759 unsafe {
2760 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2762 (buf_ptr as *mut DeviceWatcherOnPhyAddedRequest)
2763 .write_unaligned((self as *const DeviceWatcherOnPhyAddedRequest).read());
2764 }
2767 Ok(())
2768 }
2769 }
2770 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2771 fidl::encoding::Encode<DeviceWatcherOnPhyAddedRequest, D> for (T0,)
2772 {
2773 #[inline]
2774 unsafe fn encode(
2775 self,
2776 encoder: &mut fidl::encoding::Encoder<'_, D>,
2777 offset: usize,
2778 depth: fidl::encoding::Depth,
2779 ) -> fidl::Result<()> {
2780 encoder.debug_check_bounds::<DeviceWatcherOnPhyAddedRequest>(offset);
2781 self.0.encode(encoder, offset + 0, depth)?;
2785 Ok(())
2786 }
2787 }
2788
2789 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2790 for DeviceWatcherOnPhyAddedRequest
2791 {
2792 #[inline(always)]
2793 fn new_empty() -> Self {
2794 Self { phy_id: fidl::new_empty!(u16, D) }
2795 }
2796
2797 #[inline]
2798 unsafe fn decode(
2799 &mut self,
2800 decoder: &mut fidl::encoding::Decoder<'_, D>,
2801 offset: usize,
2802 _depth: fidl::encoding::Depth,
2803 ) -> fidl::Result<()> {
2804 decoder.debug_check_bounds::<Self>(offset);
2805 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2806 unsafe {
2809 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2810 }
2811 Ok(())
2812 }
2813 }
2814
2815 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnPhyRemovedRequest {
2816 type Borrowed<'a> = &'a Self;
2817 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2818 value
2819 }
2820 }
2821
2822 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnPhyRemovedRequest {
2823 type Owned = Self;
2824
2825 #[inline(always)]
2826 fn inline_align(_context: fidl::encoding::Context) -> usize {
2827 2
2828 }
2829
2830 #[inline(always)]
2831 fn inline_size(_context: fidl::encoding::Context) -> usize {
2832 2
2833 }
2834 #[inline(always)]
2835 fn encode_is_copy() -> bool {
2836 true
2837 }
2838
2839 #[inline(always)]
2840 fn decode_is_copy() -> bool {
2841 true
2842 }
2843 }
2844
2845 unsafe impl<D: fidl::encoding::ResourceDialect>
2846 fidl::encoding::Encode<DeviceWatcherOnPhyRemovedRequest, D>
2847 for &DeviceWatcherOnPhyRemovedRequest
2848 {
2849 #[inline]
2850 unsafe fn encode(
2851 self,
2852 encoder: &mut fidl::encoding::Encoder<'_, D>,
2853 offset: usize,
2854 _depth: fidl::encoding::Depth,
2855 ) -> fidl::Result<()> {
2856 encoder.debug_check_bounds::<DeviceWatcherOnPhyRemovedRequest>(offset);
2857 unsafe {
2858 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2860 (buf_ptr as *mut DeviceWatcherOnPhyRemovedRequest)
2861 .write_unaligned((self as *const DeviceWatcherOnPhyRemovedRequest).read());
2862 }
2865 Ok(())
2866 }
2867 }
2868 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2869 fidl::encoding::Encode<DeviceWatcherOnPhyRemovedRequest, D> for (T0,)
2870 {
2871 #[inline]
2872 unsafe fn encode(
2873 self,
2874 encoder: &mut fidl::encoding::Encoder<'_, D>,
2875 offset: usize,
2876 depth: fidl::encoding::Depth,
2877 ) -> fidl::Result<()> {
2878 encoder.debug_check_bounds::<DeviceWatcherOnPhyRemovedRequest>(offset);
2879 self.0.encode(encoder, offset + 0, depth)?;
2883 Ok(())
2884 }
2885 }
2886
2887 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2888 for DeviceWatcherOnPhyRemovedRequest
2889 {
2890 #[inline(always)]
2891 fn new_empty() -> Self {
2892 Self { phy_id: fidl::new_empty!(u16, D) }
2893 }
2894
2895 #[inline]
2896 unsafe fn decode(
2897 &mut self,
2898 decoder: &mut fidl::encoding::Decoder<'_, D>,
2899 offset: usize,
2900 _depth: fidl::encoding::Depth,
2901 ) -> fidl::Result<()> {
2902 decoder.debug_check_bounds::<Self>(offset);
2903 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2904 unsafe {
2907 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2908 }
2909 Ok(())
2910 }
2911 }
2912
2913 impl fidl::encoding::ValueTypeMarker for GetCountryResponse {
2914 type Borrowed<'a> = &'a Self;
2915 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2916 value
2917 }
2918 }
2919
2920 unsafe impl fidl::encoding::TypeMarker for GetCountryResponse {
2921 type Owned = Self;
2922
2923 #[inline(always)]
2924 fn inline_align(_context: fidl::encoding::Context) -> usize {
2925 1
2926 }
2927
2928 #[inline(always)]
2929 fn inline_size(_context: fidl::encoding::Context) -> usize {
2930 2
2931 }
2932 #[inline(always)]
2933 fn encode_is_copy() -> bool {
2934 true
2935 }
2936
2937 #[inline(always)]
2938 fn decode_is_copy() -> bool {
2939 true
2940 }
2941 }
2942
2943 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GetCountryResponse, D>
2944 for &GetCountryResponse
2945 {
2946 #[inline]
2947 unsafe fn encode(
2948 self,
2949 encoder: &mut fidl::encoding::Encoder<'_, D>,
2950 offset: usize,
2951 _depth: fidl::encoding::Depth,
2952 ) -> fidl::Result<()> {
2953 encoder.debug_check_bounds::<GetCountryResponse>(offset);
2954 unsafe {
2955 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2957 (buf_ptr as *mut GetCountryResponse)
2958 .write_unaligned((self as *const GetCountryResponse).read());
2959 }
2962 Ok(())
2963 }
2964 }
2965 unsafe impl<
2966 D: fidl::encoding::ResourceDialect,
2967 T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
2968 > fidl::encoding::Encode<GetCountryResponse, D> for (T0,)
2969 {
2970 #[inline]
2971 unsafe fn encode(
2972 self,
2973 encoder: &mut fidl::encoding::Encoder<'_, D>,
2974 offset: usize,
2975 depth: fidl::encoding::Depth,
2976 ) -> fidl::Result<()> {
2977 encoder.debug_check_bounds::<GetCountryResponse>(offset);
2978 self.0.encode(encoder, offset + 0, depth)?;
2982 Ok(())
2983 }
2984 }
2985
2986 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetCountryResponse {
2987 #[inline(always)]
2988 fn new_empty() -> Self {
2989 Self { alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D) }
2990 }
2991
2992 #[inline]
2993 unsafe fn decode(
2994 &mut self,
2995 decoder: &mut fidl::encoding::Decoder<'_, D>,
2996 offset: usize,
2997 _depth: fidl::encoding::Depth,
2998 ) -> fidl::Result<()> {
2999 decoder.debug_check_bounds::<Self>(offset);
3000 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3001 unsafe {
3004 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3005 }
3006 Ok(())
3007 }
3008 }
3009
3010 impl fidl::encoding::ValueTypeMarker for GetPowerSaveModeResponse {
3011 type Borrowed<'a> = &'a Self;
3012 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3013 value
3014 }
3015 }
3016
3017 unsafe impl fidl::encoding::TypeMarker for GetPowerSaveModeResponse {
3018 type Owned = Self;
3019
3020 #[inline(always)]
3021 fn inline_align(_context: fidl::encoding::Context) -> usize {
3022 4
3023 }
3024
3025 #[inline(always)]
3026 fn inline_size(_context: fidl::encoding::Context) -> usize {
3027 4
3028 }
3029 }
3030
3031 unsafe impl<D: fidl::encoding::ResourceDialect>
3032 fidl::encoding::Encode<GetPowerSaveModeResponse, D> for &GetPowerSaveModeResponse
3033 {
3034 #[inline]
3035 unsafe fn encode(
3036 self,
3037 encoder: &mut fidl::encoding::Encoder<'_, D>,
3038 offset: usize,
3039 _depth: fidl::encoding::Depth,
3040 ) -> fidl::Result<()> {
3041 encoder.debug_check_bounds::<GetPowerSaveModeResponse>(offset);
3042 fidl::encoding::Encode::<GetPowerSaveModeResponse, D>::encode(
3044 (
3045 <fidl_fuchsia_wlan_common__common::PowerSaveType as fidl::encoding::ValueTypeMarker>::borrow(&self.ps_mode),
3046 ),
3047 encoder, offset, _depth
3048 )
3049 }
3050 }
3051 unsafe impl<
3052 D: fidl::encoding::ResourceDialect,
3053 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::PowerSaveType, D>,
3054 > fidl::encoding::Encode<GetPowerSaveModeResponse, D> for (T0,)
3055 {
3056 #[inline]
3057 unsafe fn encode(
3058 self,
3059 encoder: &mut fidl::encoding::Encoder<'_, D>,
3060 offset: usize,
3061 depth: fidl::encoding::Depth,
3062 ) -> fidl::Result<()> {
3063 encoder.debug_check_bounds::<GetPowerSaveModeResponse>(offset);
3064 self.0.encode(encoder, offset + 0, depth)?;
3068 Ok(())
3069 }
3070 }
3071
3072 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3073 for GetPowerSaveModeResponse
3074 {
3075 #[inline(always)]
3076 fn new_empty() -> Self {
3077 Self { ps_mode: fidl::new_empty!(fidl_fuchsia_wlan_common__common::PowerSaveType, D) }
3078 }
3079
3080 #[inline]
3081 unsafe fn decode(
3082 &mut self,
3083 decoder: &mut fidl::encoding::Decoder<'_, D>,
3084 offset: usize,
3085 _depth: fidl::encoding::Depth,
3086 ) -> fidl::Result<()> {
3087 decoder.debug_check_bounds::<Self>(offset);
3088 fidl::decode!(
3090 fidl_fuchsia_wlan_common__common::PowerSaveType,
3091 D,
3092 &mut self.ps_mode,
3093 decoder,
3094 offset + 0,
3095 _depth
3096 )?;
3097 Ok(())
3098 }
3099 }
3100
3101 impl fidl::encoding::ValueTypeMarker for QueryIfaceResponse {
3102 type Borrowed<'a> = &'a Self;
3103 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3104 value
3105 }
3106 }
3107
3108 unsafe impl fidl::encoding::TypeMarker for QueryIfaceResponse {
3109 type Owned = Self;
3110
3111 #[inline(always)]
3112 fn inline_align(_context: fidl::encoding::Context) -> usize {
3113 4
3114 }
3115
3116 #[inline(always)]
3117 fn inline_size(_context: fidl::encoding::Context) -> usize {
3118 16
3119 }
3120 }
3121
3122 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<QueryIfaceResponse, D>
3123 for &QueryIfaceResponse
3124 {
3125 #[inline]
3126 unsafe fn encode(
3127 self,
3128 encoder: &mut fidl::encoding::Encoder<'_, D>,
3129 offset: usize,
3130 _depth: fidl::encoding::Depth,
3131 ) -> fidl::Result<()> {
3132 encoder.debug_check_bounds::<QueryIfaceResponse>(offset);
3133 fidl::encoding::Encode::<QueryIfaceResponse, D>::encode(
3135 (
3136 <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow(&self.role),
3137 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3138 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_id),
3139 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_assigned_id),
3140 <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.sta_addr),
3141 ),
3142 encoder, offset, _depth
3143 )
3144 }
3145 }
3146 unsafe impl<
3147 D: fidl::encoding::ResourceDialect,
3148 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanMacRole, D>,
3149 T1: fidl::encoding::Encode<u16, D>,
3150 T2: fidl::encoding::Encode<u16, D>,
3151 T3: fidl::encoding::Encode<u16, D>,
3152 T4: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3153 > fidl::encoding::Encode<QueryIfaceResponse, D> for (T0, T1, T2, T3, T4)
3154 {
3155 #[inline]
3156 unsafe fn encode(
3157 self,
3158 encoder: &mut fidl::encoding::Encoder<'_, D>,
3159 offset: usize,
3160 depth: fidl::encoding::Depth,
3161 ) -> fidl::Result<()> {
3162 encoder.debug_check_bounds::<QueryIfaceResponse>(offset);
3163 self.0.encode(encoder, offset + 0, depth)?;
3167 self.1.encode(encoder, offset + 4, depth)?;
3168 self.2.encode(encoder, offset + 6, depth)?;
3169 self.3.encode(encoder, offset + 8, depth)?;
3170 self.4.encode(encoder, offset + 10, depth)?;
3171 Ok(())
3172 }
3173 }
3174
3175 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for QueryIfaceResponse {
3176 #[inline(always)]
3177 fn new_empty() -> Self {
3178 Self {
3179 role: fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D),
3180 id: fidl::new_empty!(u16, D),
3181 phy_id: fidl::new_empty!(u16, D),
3182 phy_assigned_id: fidl::new_empty!(u16, D),
3183 sta_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3184 }
3185 }
3186
3187 #[inline]
3188 unsafe fn decode(
3189 &mut self,
3190 decoder: &mut fidl::encoding::Decoder<'_, D>,
3191 offset: usize,
3192 _depth: fidl::encoding::Depth,
3193 ) -> fidl::Result<()> {
3194 decoder.debug_check_bounds::<Self>(offset);
3195 fidl::decode!(
3197 fidl_fuchsia_wlan_common__common::WlanMacRole,
3198 D,
3199 &mut self.role,
3200 decoder,
3201 offset + 0,
3202 _depth
3203 )?;
3204 fidl::decode!(u16, D, &mut self.id, decoder, offset + 4, _depth)?;
3205 fidl::decode!(u16, D, &mut self.phy_id, decoder, offset + 6, _depth)?;
3206 fidl::decode!(u16, D, &mut self.phy_assigned_id, decoder, offset + 8, _depth)?;
3207 fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_addr, decoder, offset + 10, _depth)?;
3208 Ok(())
3209 }
3210 }
3211
3212 impl fidl::encoding::ValueTypeMarker for SetCountryRequest {
3213 type Borrowed<'a> = &'a Self;
3214 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3215 value
3216 }
3217 }
3218
3219 unsafe impl fidl::encoding::TypeMarker for SetCountryRequest {
3220 type Owned = Self;
3221
3222 #[inline(always)]
3223 fn inline_align(_context: fidl::encoding::Context) -> usize {
3224 2
3225 }
3226
3227 #[inline(always)]
3228 fn inline_size(_context: fidl::encoding::Context) -> usize {
3229 4
3230 }
3231 #[inline(always)]
3232 fn encode_is_copy() -> bool {
3233 true
3234 }
3235
3236 #[inline(always)]
3237 fn decode_is_copy() -> bool {
3238 true
3239 }
3240 }
3241
3242 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetCountryRequest, D>
3243 for &SetCountryRequest
3244 {
3245 #[inline]
3246 unsafe fn encode(
3247 self,
3248 encoder: &mut fidl::encoding::Encoder<'_, D>,
3249 offset: usize,
3250 _depth: fidl::encoding::Depth,
3251 ) -> fidl::Result<()> {
3252 encoder.debug_check_bounds::<SetCountryRequest>(offset);
3253 unsafe {
3254 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3256 (buf_ptr as *mut SetCountryRequest)
3257 .write_unaligned((self as *const SetCountryRequest).read());
3258 }
3261 Ok(())
3262 }
3263 }
3264 unsafe impl<
3265 D: fidl::encoding::ResourceDialect,
3266 T0: fidl::encoding::Encode<u16, D>,
3267 T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
3268 > fidl::encoding::Encode<SetCountryRequest, D> for (T0, T1)
3269 {
3270 #[inline]
3271 unsafe fn encode(
3272 self,
3273 encoder: &mut fidl::encoding::Encoder<'_, D>,
3274 offset: usize,
3275 depth: fidl::encoding::Depth,
3276 ) -> fidl::Result<()> {
3277 encoder.debug_check_bounds::<SetCountryRequest>(offset);
3278 self.0.encode(encoder, offset + 0, depth)?;
3282 self.1.encode(encoder, offset + 2, depth)?;
3283 Ok(())
3284 }
3285 }
3286
3287 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetCountryRequest {
3288 #[inline(always)]
3289 fn new_empty() -> Self {
3290 Self {
3291 phy_id: fidl::new_empty!(u16, D),
3292 alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D),
3293 }
3294 }
3295
3296 #[inline]
3297 unsafe fn decode(
3298 &mut self,
3299 decoder: &mut fidl::encoding::Decoder<'_, D>,
3300 offset: usize,
3301 _depth: fidl::encoding::Depth,
3302 ) -> fidl::Result<()> {
3303 decoder.debug_check_bounds::<Self>(offset);
3304 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3305 unsafe {
3308 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
3309 }
3310 Ok(())
3311 }
3312 }
3313
3314 impl fidl::encoding::ValueTypeMarker for SetPowerSaveModeRequest {
3315 type Borrowed<'a> = &'a Self;
3316 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3317 value
3318 }
3319 }
3320
3321 unsafe impl fidl::encoding::TypeMarker for SetPowerSaveModeRequest {
3322 type Owned = Self;
3323
3324 #[inline(always)]
3325 fn inline_align(_context: fidl::encoding::Context) -> usize {
3326 4
3327 }
3328
3329 #[inline(always)]
3330 fn inline_size(_context: fidl::encoding::Context) -> usize {
3331 8
3332 }
3333 }
3334
3335 unsafe impl<D: fidl::encoding::ResourceDialect>
3336 fidl::encoding::Encode<SetPowerSaveModeRequest, D> for &SetPowerSaveModeRequest
3337 {
3338 #[inline]
3339 unsafe fn encode(
3340 self,
3341 encoder: &mut fidl::encoding::Encoder<'_, D>,
3342 offset: usize,
3343 _depth: fidl::encoding::Depth,
3344 ) -> fidl::Result<()> {
3345 encoder.debug_check_bounds::<SetPowerSaveModeRequest>(offset);
3346 fidl::encoding::Encode::<SetPowerSaveModeRequest, D>::encode(
3348 (
3349 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_id),
3350 <fidl_fuchsia_wlan_common__common::PowerSaveType as fidl::encoding::ValueTypeMarker>::borrow(&self.ps_mode),
3351 ),
3352 encoder, offset, _depth
3353 )
3354 }
3355 }
3356 unsafe impl<
3357 D: fidl::encoding::ResourceDialect,
3358 T0: fidl::encoding::Encode<u16, D>,
3359 T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::PowerSaveType, D>,
3360 > fidl::encoding::Encode<SetPowerSaveModeRequest, D> for (T0, T1)
3361 {
3362 #[inline]
3363 unsafe fn encode(
3364 self,
3365 encoder: &mut fidl::encoding::Encoder<'_, D>,
3366 offset: usize,
3367 depth: fidl::encoding::Depth,
3368 ) -> fidl::Result<()> {
3369 encoder.debug_check_bounds::<SetPowerSaveModeRequest>(offset);
3370 unsafe {
3373 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3374 (ptr as *mut u32).write_unaligned(0);
3375 }
3376 self.0.encode(encoder, offset + 0, depth)?;
3378 self.1.encode(encoder, offset + 4, depth)?;
3379 Ok(())
3380 }
3381 }
3382
3383 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3384 for SetPowerSaveModeRequest
3385 {
3386 #[inline(always)]
3387 fn new_empty() -> Self {
3388 Self {
3389 phy_id: fidl::new_empty!(u16, D),
3390 ps_mode: fidl::new_empty!(fidl_fuchsia_wlan_common__common::PowerSaveType, D),
3391 }
3392 }
3393
3394 #[inline]
3395 unsafe fn decode(
3396 &mut self,
3397 decoder: &mut fidl::encoding::Decoder<'_, D>,
3398 offset: usize,
3399 _depth: fidl::encoding::Depth,
3400 ) -> fidl::Result<()> {
3401 decoder.debug_check_bounds::<Self>(offset);
3402 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3404 let padval = unsafe { (ptr as *const u32).read_unaligned() };
3405 let mask = 0xffff0000u32;
3406 let maskedval = padval & mask;
3407 if maskedval != 0 {
3408 return Err(fidl::Error::NonZeroPadding {
3409 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3410 });
3411 }
3412 fidl::decode!(u16, D, &mut self.phy_id, decoder, offset + 0, _depth)?;
3413 fidl::decode!(
3414 fidl_fuchsia_wlan_common__common::PowerSaveType,
3415 D,
3416 &mut self.ps_mode,
3417 decoder,
3418 offset + 4,
3419 _depth
3420 )?;
3421 Ok(())
3422 }
3423 }
3424
3425 impl DeviceMonitorCreateIfaceRequest {
3426 #[inline(always)]
3427 fn max_ordinal_present(&self) -> u64 {
3428 if let Some(_) = self.sta_address {
3429 return 3;
3430 }
3431 if let Some(_) = self.role {
3432 return 2;
3433 }
3434 if let Some(_) = self.phy_id {
3435 return 1;
3436 }
3437 0
3438 }
3439 }
3440
3441 impl fidl::encoding::ValueTypeMarker for DeviceMonitorCreateIfaceRequest {
3442 type Borrowed<'a> = &'a Self;
3443 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3444 value
3445 }
3446 }
3447
3448 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorCreateIfaceRequest {
3449 type Owned = Self;
3450
3451 #[inline(always)]
3452 fn inline_align(_context: fidl::encoding::Context) -> usize {
3453 8
3454 }
3455
3456 #[inline(always)]
3457 fn inline_size(_context: fidl::encoding::Context) -> usize {
3458 16
3459 }
3460 }
3461
3462 unsafe impl<D: fidl::encoding::ResourceDialect>
3463 fidl::encoding::Encode<DeviceMonitorCreateIfaceRequest, D>
3464 for &DeviceMonitorCreateIfaceRequest
3465 {
3466 unsafe fn encode(
3467 self,
3468 encoder: &mut fidl::encoding::Encoder<'_, D>,
3469 offset: usize,
3470 mut depth: fidl::encoding::Depth,
3471 ) -> fidl::Result<()> {
3472 encoder.debug_check_bounds::<DeviceMonitorCreateIfaceRequest>(offset);
3473 let max_ordinal: u64 = self.max_ordinal_present();
3475 encoder.write_num(max_ordinal, offset);
3476 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3477 if max_ordinal == 0 {
3479 return Ok(());
3480 }
3481 depth.increment()?;
3482 let envelope_size = 8;
3483 let bytes_len = max_ordinal as usize * envelope_size;
3484 #[allow(unused_variables)]
3485 let offset = encoder.out_of_line_offset(bytes_len);
3486 let mut _prev_end_offset: usize = 0;
3487 if 1 > max_ordinal {
3488 return Ok(());
3489 }
3490
3491 let cur_offset: usize = (1 - 1) * envelope_size;
3494
3495 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3497
3498 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3503 self.phy_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3504 encoder,
3505 offset + cur_offset,
3506 depth,
3507 )?;
3508
3509 _prev_end_offset = cur_offset + envelope_size;
3510 if 2 > max_ordinal {
3511 return Ok(());
3512 }
3513
3514 let cur_offset: usize = (2 - 1) * envelope_size;
3517
3518 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3520
3521 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
3526 self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
3527 encoder, offset + cur_offset, depth
3528 )?;
3529
3530 _prev_end_offset = cur_offset + envelope_size;
3531 if 3 > max_ordinal {
3532 return Ok(());
3533 }
3534
3535 let cur_offset: usize = (3 - 1) * envelope_size;
3538
3539 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3541
3542 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3547 self.sta_address
3548 .as_ref()
3549 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3550 encoder,
3551 offset + cur_offset,
3552 depth,
3553 )?;
3554
3555 _prev_end_offset = cur_offset + envelope_size;
3556
3557 Ok(())
3558 }
3559 }
3560
3561 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3562 for DeviceMonitorCreateIfaceRequest
3563 {
3564 #[inline(always)]
3565 fn new_empty() -> Self {
3566 Self::default()
3567 }
3568
3569 unsafe fn decode(
3570 &mut self,
3571 decoder: &mut fidl::encoding::Decoder<'_, D>,
3572 offset: usize,
3573 mut depth: fidl::encoding::Depth,
3574 ) -> fidl::Result<()> {
3575 decoder.debug_check_bounds::<Self>(offset);
3576 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3577 None => return Err(fidl::Error::NotNullable),
3578 Some(len) => len,
3579 };
3580 if len == 0 {
3582 return Ok(());
3583 };
3584 depth.increment()?;
3585 let envelope_size = 8;
3586 let bytes_len = len * envelope_size;
3587 let offset = decoder.out_of_line_offset(bytes_len)?;
3588 let mut _next_ordinal_to_read = 0;
3590 let mut next_offset = offset;
3591 let end_offset = offset + bytes_len;
3592 _next_ordinal_to_read += 1;
3593 if next_offset >= end_offset {
3594 return Ok(());
3595 }
3596
3597 while _next_ordinal_to_read < 1 {
3599 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3600 _next_ordinal_to_read += 1;
3601 next_offset += envelope_size;
3602 }
3603
3604 let next_out_of_line = decoder.next_out_of_line();
3605 let handles_before = decoder.remaining_handles();
3606 if let Some((inlined, num_bytes, num_handles)) =
3607 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3608 {
3609 let member_inline_size =
3610 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3611 if inlined != (member_inline_size <= 4) {
3612 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3613 }
3614 let inner_offset;
3615 let mut inner_depth = depth.clone();
3616 if inlined {
3617 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3618 inner_offset = next_offset;
3619 } else {
3620 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3621 inner_depth.increment()?;
3622 }
3623 let val_ref = self.phy_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
3624 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3625 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3626 {
3627 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3628 }
3629 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3630 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3631 }
3632 }
3633
3634 next_offset += envelope_size;
3635 _next_ordinal_to_read += 1;
3636 if next_offset >= end_offset {
3637 return Ok(());
3638 }
3639
3640 while _next_ordinal_to_read < 2 {
3642 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3643 _next_ordinal_to_read += 1;
3644 next_offset += envelope_size;
3645 }
3646
3647 let next_out_of_line = decoder.next_out_of_line();
3648 let handles_before = decoder.remaining_handles();
3649 if let Some((inlined, num_bytes, num_handles)) =
3650 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3651 {
3652 let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3653 if inlined != (member_inline_size <= 4) {
3654 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3655 }
3656 let inner_offset;
3657 let mut inner_depth = depth.clone();
3658 if inlined {
3659 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3660 inner_offset = next_offset;
3661 } else {
3662 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3663 inner_depth.increment()?;
3664 }
3665 let val_ref = self.role.get_or_insert_with(|| {
3666 fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
3667 });
3668 fidl::decode!(
3669 fidl_fuchsia_wlan_common__common::WlanMacRole,
3670 D,
3671 val_ref,
3672 decoder,
3673 inner_offset,
3674 inner_depth
3675 )?;
3676 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3677 {
3678 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3679 }
3680 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3681 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3682 }
3683 }
3684
3685 next_offset += envelope_size;
3686 _next_ordinal_to_read += 1;
3687 if next_offset >= end_offset {
3688 return Ok(());
3689 }
3690
3691 while _next_ordinal_to_read < 3 {
3693 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3694 _next_ordinal_to_read += 1;
3695 next_offset += envelope_size;
3696 }
3697
3698 let next_out_of_line = decoder.next_out_of_line();
3699 let handles_before = decoder.remaining_handles();
3700 if let Some((inlined, num_bytes, num_handles)) =
3701 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3702 {
3703 let member_inline_size =
3704 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3705 decoder.context,
3706 );
3707 if inlined != (member_inline_size <= 4) {
3708 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3709 }
3710 let inner_offset;
3711 let mut inner_depth = depth.clone();
3712 if inlined {
3713 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3714 inner_offset = next_offset;
3715 } else {
3716 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3717 inner_depth.increment()?;
3718 }
3719 let val_ref = self
3720 .sta_address
3721 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3722 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3723 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3724 {
3725 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3726 }
3727 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3728 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3729 }
3730 }
3731
3732 next_offset += envelope_size;
3733
3734 while next_offset < end_offset {
3736 _next_ordinal_to_read += 1;
3737 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3738 next_offset += envelope_size;
3739 }
3740
3741 Ok(())
3742 }
3743 }
3744
3745 impl DeviceMonitorCreateIfaceResponse {
3746 #[inline(always)]
3747 fn max_ordinal_present(&self) -> u64 {
3748 if let Some(_) = self.iface_id {
3749 return 1;
3750 }
3751 0
3752 }
3753 }
3754
3755 impl fidl::encoding::ValueTypeMarker for DeviceMonitorCreateIfaceResponse {
3756 type Borrowed<'a> = &'a Self;
3757 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3758 value
3759 }
3760 }
3761
3762 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorCreateIfaceResponse {
3763 type Owned = Self;
3764
3765 #[inline(always)]
3766 fn inline_align(_context: fidl::encoding::Context) -> usize {
3767 8
3768 }
3769
3770 #[inline(always)]
3771 fn inline_size(_context: fidl::encoding::Context) -> usize {
3772 16
3773 }
3774 }
3775
3776 unsafe impl<D: fidl::encoding::ResourceDialect>
3777 fidl::encoding::Encode<DeviceMonitorCreateIfaceResponse, D>
3778 for &DeviceMonitorCreateIfaceResponse
3779 {
3780 unsafe fn encode(
3781 self,
3782 encoder: &mut fidl::encoding::Encoder<'_, D>,
3783 offset: usize,
3784 mut depth: fidl::encoding::Depth,
3785 ) -> fidl::Result<()> {
3786 encoder.debug_check_bounds::<DeviceMonitorCreateIfaceResponse>(offset);
3787 let max_ordinal: u64 = self.max_ordinal_present();
3789 encoder.write_num(max_ordinal, offset);
3790 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3791 if max_ordinal == 0 {
3793 return Ok(());
3794 }
3795 depth.increment()?;
3796 let envelope_size = 8;
3797 let bytes_len = max_ordinal as usize * envelope_size;
3798 #[allow(unused_variables)]
3799 let offset = encoder.out_of_line_offset(bytes_len);
3800 let mut _prev_end_offset: usize = 0;
3801 if 1 > max_ordinal {
3802 return Ok(());
3803 }
3804
3805 let cur_offset: usize = (1 - 1) * envelope_size;
3808
3809 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3811
3812 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3817 self.iface_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3818 encoder,
3819 offset + cur_offset,
3820 depth,
3821 )?;
3822
3823 _prev_end_offset = cur_offset + envelope_size;
3824
3825 Ok(())
3826 }
3827 }
3828
3829 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3830 for DeviceMonitorCreateIfaceResponse
3831 {
3832 #[inline(always)]
3833 fn new_empty() -> Self {
3834 Self::default()
3835 }
3836
3837 unsafe fn decode(
3838 &mut self,
3839 decoder: &mut fidl::encoding::Decoder<'_, D>,
3840 offset: usize,
3841 mut depth: fidl::encoding::Depth,
3842 ) -> fidl::Result<()> {
3843 decoder.debug_check_bounds::<Self>(offset);
3844 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3845 None => return Err(fidl::Error::NotNullable),
3846 Some(len) => len,
3847 };
3848 if len == 0 {
3850 return Ok(());
3851 };
3852 depth.increment()?;
3853 let envelope_size = 8;
3854 let bytes_len = len * envelope_size;
3855 let offset = decoder.out_of_line_offset(bytes_len)?;
3856 let mut _next_ordinal_to_read = 0;
3858 let mut next_offset = offset;
3859 let end_offset = offset + bytes_len;
3860 _next_ordinal_to_read += 1;
3861 if next_offset >= end_offset {
3862 return Ok(());
3863 }
3864
3865 while _next_ordinal_to_read < 1 {
3867 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3868 _next_ordinal_to_read += 1;
3869 next_offset += envelope_size;
3870 }
3871
3872 let next_out_of_line = decoder.next_out_of_line();
3873 let handles_before = decoder.remaining_handles();
3874 if let Some((inlined, num_bytes, num_handles)) =
3875 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3876 {
3877 let member_inline_size =
3878 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3879 if inlined != (member_inline_size <= 4) {
3880 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3881 }
3882 let inner_offset;
3883 let mut inner_depth = depth.clone();
3884 if inlined {
3885 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3886 inner_offset = next_offset;
3887 } else {
3888 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3889 inner_depth.increment()?;
3890 }
3891 let val_ref = self.iface_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
3892 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3893 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3894 {
3895 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3896 }
3897 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3898 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3899 }
3900 }
3901
3902 next_offset += envelope_size;
3903
3904 while next_offset < end_offset {
3906 _next_ordinal_to_read += 1;
3907 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3908 next_offset += envelope_size;
3909 }
3910
3911 Ok(())
3912 }
3913 }
3914
3915 impl fidl::encoding::ValueTypeMarker for GetIfaceHistogramStatsResponse {
3916 type Borrowed<'a> = &'a Self;
3917 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3918 value
3919 }
3920 }
3921
3922 unsafe impl fidl::encoding::TypeMarker for GetIfaceHistogramStatsResponse {
3923 type Owned = Self;
3924
3925 #[inline(always)]
3926 fn inline_align(_context: fidl::encoding::Context) -> usize {
3927 8
3928 }
3929
3930 #[inline(always)]
3931 fn inline_size(_context: fidl::encoding::Context) -> usize {
3932 16
3933 }
3934 }
3935
3936 unsafe impl<D: fidl::encoding::ResourceDialect>
3937 fidl::encoding::Encode<GetIfaceHistogramStatsResponse, D>
3938 for &GetIfaceHistogramStatsResponse
3939 {
3940 #[inline]
3941 unsafe fn encode(
3942 self,
3943 encoder: &mut fidl::encoding::Encoder<'_, D>,
3944 offset: usize,
3945 _depth: fidl::encoding::Depth,
3946 ) -> fidl::Result<()> {
3947 encoder.debug_check_bounds::<GetIfaceHistogramStatsResponse>(offset);
3948 encoder.write_num::<u64>(self.ordinal(), offset);
3949 match self {
3950 GetIfaceHistogramStatsResponse::Stats(ref val) => {
3951 fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>(
3952 <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(val),
3953 encoder, offset + 8, _depth
3954 )
3955 }
3956 GetIfaceHistogramStatsResponse::ErrorStatus(ref val) => {
3957 fidl::encoding::encode_in_envelope::<i32, D>(
3958 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3959 encoder, offset + 8, _depth
3960 )
3961 }
3962 }
3963 }
3964 }
3965
3966 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3967 for GetIfaceHistogramStatsResponse
3968 {
3969 #[inline(always)]
3970 fn new_empty() -> Self {
3971 Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D))
3972 }
3973
3974 #[inline]
3975 unsafe fn decode(
3976 &mut self,
3977 decoder: &mut fidl::encoding::Decoder<'_, D>,
3978 offset: usize,
3979 mut depth: fidl::encoding::Depth,
3980 ) -> fidl::Result<()> {
3981 decoder.debug_check_bounds::<Self>(offset);
3982 #[allow(unused_variables)]
3983 let next_out_of_line = decoder.next_out_of_line();
3984 let handles_before = decoder.remaining_handles();
3985 let (ordinal, inlined, num_bytes, num_handles) =
3986 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
3987
3988 let member_inline_size = match ordinal {
3989 1 => <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3990 2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3991 _ => return Err(fidl::Error::UnknownUnionTag),
3992 };
3993
3994 if inlined != (member_inline_size <= 4) {
3995 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3996 }
3997 let _inner_offset;
3998 if inlined {
3999 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4000 _inner_offset = offset + 8;
4001 } else {
4002 depth.increment()?;
4003 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4004 }
4005 match ordinal {
4006 1 => {
4007 #[allow(irrefutable_let_patterns)]
4008 if let GetIfaceHistogramStatsResponse::Stats(_) = self {
4009 } else {
4011 *self = GetIfaceHistogramStatsResponse::Stats(fidl::new_empty!(
4013 fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
4014 D
4015 ));
4016 }
4017 #[allow(irrefutable_let_patterns)]
4018 if let GetIfaceHistogramStatsResponse::Stats(ref mut val) = self {
4019 fidl::decode!(
4020 fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
4021 D,
4022 val,
4023 decoder,
4024 _inner_offset,
4025 depth
4026 )?;
4027 } else {
4028 unreachable!()
4029 }
4030 }
4031 2 => {
4032 #[allow(irrefutable_let_patterns)]
4033 if let GetIfaceHistogramStatsResponse::ErrorStatus(_) = self {
4034 } else {
4036 *self =
4038 GetIfaceHistogramStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
4039 }
4040 #[allow(irrefutable_let_patterns)]
4041 if let GetIfaceHistogramStatsResponse::ErrorStatus(ref mut val) = self {
4042 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
4043 } else {
4044 unreachable!()
4045 }
4046 }
4047 ordinal => panic!("unexpected ordinal {:?}", ordinal),
4048 }
4049 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4050 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4051 }
4052 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4053 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4054 }
4055 Ok(())
4056 }
4057 }
4058}