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 DeviceMonitorGetPowerStateRequest {
142 pub phy_id: u16,
143}
144
145impl fidl::Persistable for DeviceMonitorGetPowerStateRequest {}
146
147#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
148#[repr(C)]
149pub struct DeviceMonitorGetSupportedMacRolesRequest {
150 pub phy_id: u16,
151}
152
153impl fidl::Persistable for DeviceMonitorGetSupportedMacRolesRequest {}
154
155#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
156pub struct DeviceMonitorListIfacesResponse {
157 pub iface_list: Vec<u16>,
158}
159
160impl fidl::Persistable for DeviceMonitorListIfacesResponse {}
161
162#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
163pub struct DeviceMonitorListPhysResponse {
164 pub phy_list: Vec<u16>,
165}
166
167impl fidl::Persistable for DeviceMonitorListPhysResponse {}
168
169#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
170#[repr(C)]
171pub struct DeviceMonitorPowerDownRequest {
172 pub phy_id: u16,
173}
174
175impl fidl::Persistable for DeviceMonitorPowerDownRequest {}
176
177#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
178#[repr(C)]
179pub struct DeviceMonitorPowerUpRequest {
180 pub phy_id: u16,
181}
182
183impl fidl::Persistable for DeviceMonitorPowerUpRequest {}
184
185#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
186#[repr(C)]
187pub struct DeviceMonitorQueryIfaceRequest {
188 pub iface_id: u16,
189}
190
191impl fidl::Persistable for DeviceMonitorQueryIfaceRequest {}
192
193#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
194#[repr(C)]
195pub struct DeviceMonitorResetRequest {
196 pub phy_id: u16,
197}
198
199impl fidl::Persistable for DeviceMonitorResetRequest {}
200
201#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
202#[repr(C)]
203pub struct DeviceMonitorSetCountryRequest {
204 pub req: SetCountryRequest,
205}
206
207impl fidl::Persistable for DeviceMonitorSetCountryRequest {}
208
209#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
210#[repr(C)]
211pub struct DeviceMonitorSetCountryResponse {
212 pub status: i32,
213}
214
215impl fidl::Persistable for DeviceMonitorSetCountryResponse {}
216
217#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
218pub struct DeviceMonitorSetPowerSaveModeRequest {
219 pub req: SetPowerSaveModeRequest,
220}
221
222impl fidl::Persistable for DeviceMonitorSetPowerSaveModeRequest {}
223
224#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
225#[repr(C)]
226pub struct DeviceMonitorSetPowerSaveModeResponse {
227 pub status: i32,
228}
229
230impl fidl::Persistable for DeviceMonitorSetPowerSaveModeResponse {}
231
232#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
233#[repr(C)]
234pub struct DeviceMonitorGetCountryResponse {
235 pub resp: GetCountryResponse,
236}
237
238impl fidl::Persistable for DeviceMonitorGetCountryResponse {}
239
240#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
241pub struct DeviceMonitorGetPowerSaveModeResponse {
242 pub resp: GetPowerSaveModeResponse,
243}
244
245impl fidl::Persistable for DeviceMonitorGetPowerSaveModeResponse {}
246
247#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
248pub struct DeviceMonitorGetPowerStateResponse {
249 pub power_on: bool,
250}
251
252impl fidl::Persistable for DeviceMonitorGetPowerStateResponse {}
253
254#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
255pub struct DeviceMonitorGetSupportedMacRolesResponse {
256 pub supported_mac_roles: Vec<fidl_fuchsia_wlan_common__common::WlanMacRole>,
257}
258
259impl fidl::Persistable for DeviceMonitorGetSupportedMacRolesResponse {}
260
261#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
262pub struct DeviceMonitorQueryIfaceResponse {
263 pub resp: QueryIfaceResponse,
264}
265
266impl fidl::Persistable for DeviceMonitorQueryIfaceResponse {}
267
268#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
269#[repr(C)]
270pub struct DeviceWatcherOnIfaceAddedRequest {
271 pub iface_id: u16,
272}
273
274impl fidl::Persistable for DeviceWatcherOnIfaceAddedRequest {}
275
276#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
277#[repr(C)]
278pub struct DeviceWatcherOnIfaceRemovedRequest {
279 pub iface_id: u16,
280}
281
282impl fidl::Persistable for DeviceWatcherOnIfaceRemovedRequest {}
283
284#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
285#[repr(C)]
286pub struct DeviceWatcherOnPhyAddedRequest {
287 pub phy_id: u16,
288}
289
290impl fidl::Persistable for DeviceWatcherOnPhyAddedRequest {}
291
292#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
293#[repr(C)]
294pub struct DeviceWatcherOnPhyRemovedRequest {
295 pub phy_id: u16,
296}
297
298impl fidl::Persistable for DeviceWatcherOnPhyRemovedRequest {}
299
300#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
301#[repr(C)]
302pub struct GetCountryResponse {
303 pub alpha2: [u8; 2],
304}
305
306impl fidl::Persistable for GetCountryResponse {}
307
308#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
309pub struct GetPowerSaveModeResponse {
310 pub ps_mode: fidl_fuchsia_wlan_common__common::PowerSaveType,
312}
313
314impl fidl::Persistable for GetPowerSaveModeResponse {}
315
316#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
317pub struct QueryIfaceResponse {
318 pub role: fidl_fuchsia_wlan_common__common::WlanMacRole,
320 pub id: u16,
322 pub phy_id: u16,
324 pub phy_assigned_id: u16,
326 pub sta_addr: [u8; 6],
328}
329
330impl fidl::Persistable for QueryIfaceResponse {}
331
332#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
333#[repr(C)]
334pub struct SetCountryRequest {
335 pub phy_id: u16,
336 pub alpha2: [u8; 2],
337}
338
339impl fidl::Persistable for SetCountryRequest {}
340
341#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
342pub struct SetPowerSaveModeRequest {
343 pub phy_id: u16,
345 pub ps_mode: fidl_fuchsia_wlan_common__common::PowerSaveType,
347}
348
349impl fidl::Persistable for SetPowerSaveModeRequest {}
350
351#[derive(Clone, Debug, Default, PartialEq)]
352pub struct DeviceMonitorCreateIfaceRequest {
353 pub phy_id: Option<u16>,
354 pub role: Option<fidl_fuchsia_wlan_common__common::WlanMacRole>,
355 pub sta_address: Option<[u8; 6]>,
356 #[doc(hidden)]
357 pub __source_breaking: fidl::marker::SourceBreaking,
358}
359
360impl fidl::Persistable for DeviceMonitorCreateIfaceRequest {}
361
362#[derive(Clone, Debug, Default, PartialEq)]
363pub struct DeviceMonitorCreateIfaceResponse {
364 pub iface_id: Option<u16>,
365 #[doc(hidden)]
366 pub __source_breaking: fidl::marker::SourceBreaking,
367}
368
369impl fidl::Persistable for DeviceMonitorCreateIfaceResponse {}
370
371#[derive(Clone, Debug, PartialEq)]
372pub enum GetIfaceHistogramStatsResponse {
373 Stats(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats),
374 ErrorStatus(i32),
375}
376
377impl GetIfaceHistogramStatsResponse {
378 #[inline]
379 pub fn ordinal(&self) -> u64 {
380 match *self {
381 Self::Stats(_) => 1,
382 Self::ErrorStatus(_) => 2,
383 }
384 }
385}
386
387impl fidl::Persistable for GetIfaceHistogramStatsResponse {}
388
389pub mod device_monitor_ordinals {
390 pub const LIST_PHYS: u64 = 0x3a08518874196aab;
391 pub const LIST_IFACES: u64 = 0x129e758fb8e0b113;
392 pub const GET_DEV_PATH: u64 = 0x4aa489b57113bccf;
393 pub const GET_SUPPORTED_MAC_ROLES: u64 = 0x172b3d2eabd5a14e;
394 pub const WATCH_DEVICES: u64 = 0x4615941e67e31b8e;
395 pub const GET_COUNTRY: u64 = 0x6f1040bd81bde90e;
396 pub const SET_COUNTRY: u64 = 0xdaa7b77a5a6e71b;
397 pub const CLEAR_COUNTRY: u64 = 0x66714d61103120e9;
398 pub const SET_POWER_SAVE_MODE: u64 = 0x62202b4d360533bc;
399 pub const GET_POWER_SAVE_MODE: u64 = 0x14304d406ada8693;
400 pub const POWER_DOWN: u64 = 0x374ad717fe8902e0;
401 pub const POWER_UP: u64 = 0xa2379b639869c17;
402 pub const RESET: u64 = 0x6def240c9f8c6867;
403 pub const GET_POWER_STATE: u64 = 0x58cf95c5bbbe3f;
404 pub const CREATE_IFACE: u64 = 0x1e1d30c24c0ec144;
405 pub const QUERY_IFACE: u64 = 0x1a48c4a2b86259ef;
406 pub const DESTROY_IFACE: u64 = 0x4c77982c1616a3b0;
407 pub const GET_CLIENT_SME: u64 = 0x1b056c379ca98273;
408 pub const GET_AP_SME: u64 = 0x754de680c4318c52;
409 pub const GET_SME_TELEMETRY: u64 = 0x1baf42b003f7452a;
410}
411
412pub mod device_watcher_ordinals {
413 pub const ON_PHY_ADDED: u64 = 0x771c58e0bd059f86;
414 pub const ON_PHY_REMOVED: u64 = 0x4ad72b96ccb7cff6;
415 pub const ON_IFACE_ADDED: u64 = 0x6ee685e4aa1f31d8;
416 pub const ON_IFACE_REMOVED: u64 = 0x3b771b1fce38c291;
417}
418
419mod internal {
420 use super::*;
421 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorError {
422 type Owned = Self;
423
424 #[inline(always)]
425 fn inline_align(_context: fidl::encoding::Context) -> usize {
426 std::mem::align_of::<u32>()
427 }
428
429 #[inline(always)]
430 fn inline_size(_context: fidl::encoding::Context) -> usize {
431 std::mem::size_of::<u32>()
432 }
433
434 #[inline(always)]
435 fn encode_is_copy() -> bool {
436 false
437 }
438
439 #[inline(always)]
440 fn decode_is_copy() -> bool {
441 false
442 }
443 }
444
445 impl fidl::encoding::ValueTypeMarker for DeviceMonitorError {
446 type Borrowed<'a> = Self;
447 #[inline(always)]
448 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
449 *value
450 }
451 }
452
453 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
454 for DeviceMonitorError
455 {
456 #[inline]
457 unsafe fn encode(
458 self,
459 encoder: &mut fidl::encoding::Encoder<'_, D>,
460 offset: usize,
461 _depth: fidl::encoding::Depth,
462 ) -> fidl::Result<()> {
463 encoder.debug_check_bounds::<Self>(offset);
464 encoder.write_num(self.into_primitive(), offset);
465 Ok(())
466 }
467 }
468
469 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceMonitorError {
470 #[inline(always)]
471 fn new_empty() -> Self {
472 Self::unknown()
473 }
474
475 #[inline]
476 unsafe fn decode(
477 &mut self,
478 decoder: &mut fidl::encoding::Decoder<'_, D>,
479 offset: usize,
480 _depth: fidl::encoding::Depth,
481 ) -> fidl::Result<()> {
482 decoder.debug_check_bounds::<Self>(offset);
483 let prim = decoder.read_num::<u32>(offset);
484
485 *self = Self::from_primitive_allow_unknown(prim);
486 Ok(())
487 }
488 }
489
490 impl fidl::encoding::ValueTypeMarker for ClearCountryRequest {
491 type Borrowed<'a> = &'a Self;
492 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
493 value
494 }
495 }
496
497 unsafe impl fidl::encoding::TypeMarker for ClearCountryRequest {
498 type Owned = Self;
499
500 #[inline(always)]
501 fn inline_align(_context: fidl::encoding::Context) -> usize {
502 2
503 }
504
505 #[inline(always)]
506 fn inline_size(_context: fidl::encoding::Context) -> usize {
507 2
508 }
509 #[inline(always)]
510 fn encode_is_copy() -> bool {
511 true
512 }
513
514 #[inline(always)]
515 fn decode_is_copy() -> bool {
516 true
517 }
518 }
519
520 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClearCountryRequest, D>
521 for &ClearCountryRequest
522 {
523 #[inline]
524 unsafe fn encode(
525 self,
526 encoder: &mut fidl::encoding::Encoder<'_, D>,
527 offset: usize,
528 _depth: fidl::encoding::Depth,
529 ) -> fidl::Result<()> {
530 encoder.debug_check_bounds::<ClearCountryRequest>(offset);
531 unsafe {
532 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
534 (buf_ptr as *mut ClearCountryRequest)
535 .write_unaligned((self as *const ClearCountryRequest).read());
536 }
539 Ok(())
540 }
541 }
542 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
543 fidl::encoding::Encode<ClearCountryRequest, D> for (T0,)
544 {
545 #[inline]
546 unsafe fn encode(
547 self,
548 encoder: &mut fidl::encoding::Encoder<'_, D>,
549 offset: usize,
550 depth: fidl::encoding::Depth,
551 ) -> fidl::Result<()> {
552 encoder.debug_check_bounds::<ClearCountryRequest>(offset);
553 self.0.encode(encoder, offset + 0, depth)?;
557 Ok(())
558 }
559 }
560
561 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClearCountryRequest {
562 #[inline(always)]
563 fn new_empty() -> Self {
564 Self { phy_id: fidl::new_empty!(u16, D) }
565 }
566
567 #[inline]
568 unsafe fn decode(
569 &mut self,
570 decoder: &mut fidl::encoding::Decoder<'_, D>,
571 offset: usize,
572 _depth: fidl::encoding::Depth,
573 ) -> fidl::Result<()> {
574 decoder.debug_check_bounds::<Self>(offset);
575 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
576 unsafe {
579 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
580 }
581 Ok(())
582 }
583 }
584
585 impl fidl::encoding::ValueTypeMarker for DestroyIfaceRequest {
586 type Borrowed<'a> = &'a Self;
587 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
588 value
589 }
590 }
591
592 unsafe impl fidl::encoding::TypeMarker for DestroyIfaceRequest {
593 type Owned = Self;
594
595 #[inline(always)]
596 fn inline_align(_context: fidl::encoding::Context) -> usize {
597 2
598 }
599
600 #[inline(always)]
601 fn inline_size(_context: fidl::encoding::Context) -> usize {
602 2
603 }
604 #[inline(always)]
605 fn encode_is_copy() -> bool {
606 true
607 }
608
609 #[inline(always)]
610 fn decode_is_copy() -> bool {
611 true
612 }
613 }
614
615 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DestroyIfaceRequest, D>
616 for &DestroyIfaceRequest
617 {
618 #[inline]
619 unsafe fn encode(
620 self,
621 encoder: &mut fidl::encoding::Encoder<'_, D>,
622 offset: usize,
623 _depth: fidl::encoding::Depth,
624 ) -> fidl::Result<()> {
625 encoder.debug_check_bounds::<DestroyIfaceRequest>(offset);
626 unsafe {
627 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
629 (buf_ptr as *mut DestroyIfaceRequest)
630 .write_unaligned((self as *const DestroyIfaceRequest).read());
631 }
634 Ok(())
635 }
636 }
637 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
638 fidl::encoding::Encode<DestroyIfaceRequest, D> for (T0,)
639 {
640 #[inline]
641 unsafe fn encode(
642 self,
643 encoder: &mut fidl::encoding::Encoder<'_, D>,
644 offset: usize,
645 depth: fidl::encoding::Depth,
646 ) -> fidl::Result<()> {
647 encoder.debug_check_bounds::<DestroyIfaceRequest>(offset);
648 self.0.encode(encoder, offset + 0, depth)?;
652 Ok(())
653 }
654 }
655
656 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DestroyIfaceRequest {
657 #[inline(always)]
658 fn new_empty() -> Self {
659 Self { iface_id: fidl::new_empty!(u16, D) }
660 }
661
662 #[inline]
663 unsafe fn decode(
664 &mut self,
665 decoder: &mut fidl::encoding::Decoder<'_, D>,
666 offset: usize,
667 _depth: fidl::encoding::Depth,
668 ) -> fidl::Result<()> {
669 decoder.debug_check_bounds::<Self>(offset);
670 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
671 unsafe {
674 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
675 }
676 Ok(())
677 }
678 }
679
680 impl fidl::encoding::ValueTypeMarker for DeviceMonitorClearCountryRequest {
681 type Borrowed<'a> = &'a Self;
682 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
683 value
684 }
685 }
686
687 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorClearCountryRequest {
688 type Owned = Self;
689
690 #[inline(always)]
691 fn inline_align(_context: fidl::encoding::Context) -> usize {
692 2
693 }
694
695 #[inline(always)]
696 fn inline_size(_context: fidl::encoding::Context) -> usize {
697 2
698 }
699 #[inline(always)]
700 fn encode_is_copy() -> bool {
701 true
702 }
703
704 #[inline(always)]
705 fn decode_is_copy() -> bool {
706 true
707 }
708 }
709
710 unsafe impl<D: fidl::encoding::ResourceDialect>
711 fidl::encoding::Encode<DeviceMonitorClearCountryRequest, D>
712 for &DeviceMonitorClearCountryRequest
713 {
714 #[inline]
715 unsafe fn encode(
716 self,
717 encoder: &mut fidl::encoding::Encoder<'_, D>,
718 offset: usize,
719 _depth: fidl::encoding::Depth,
720 ) -> fidl::Result<()> {
721 encoder.debug_check_bounds::<DeviceMonitorClearCountryRequest>(offset);
722 unsafe {
723 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
725 (buf_ptr as *mut DeviceMonitorClearCountryRequest)
726 .write_unaligned((self as *const DeviceMonitorClearCountryRequest).read());
727 }
730 Ok(())
731 }
732 }
733 unsafe impl<
734 D: fidl::encoding::ResourceDialect,
735 T0: fidl::encoding::Encode<ClearCountryRequest, D>,
736 > fidl::encoding::Encode<DeviceMonitorClearCountryRequest, D> for (T0,)
737 {
738 #[inline]
739 unsafe fn encode(
740 self,
741 encoder: &mut fidl::encoding::Encoder<'_, D>,
742 offset: usize,
743 depth: fidl::encoding::Depth,
744 ) -> fidl::Result<()> {
745 encoder.debug_check_bounds::<DeviceMonitorClearCountryRequest>(offset);
746 self.0.encode(encoder, offset + 0, depth)?;
750 Ok(())
751 }
752 }
753
754 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
755 for DeviceMonitorClearCountryRequest
756 {
757 #[inline(always)]
758 fn new_empty() -> Self {
759 Self { req: fidl::new_empty!(ClearCountryRequest, D) }
760 }
761
762 #[inline]
763 unsafe fn decode(
764 &mut self,
765 decoder: &mut fidl::encoding::Decoder<'_, D>,
766 offset: usize,
767 _depth: fidl::encoding::Depth,
768 ) -> fidl::Result<()> {
769 decoder.debug_check_bounds::<Self>(offset);
770 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
771 unsafe {
774 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
775 }
776 Ok(())
777 }
778 }
779
780 impl fidl::encoding::ValueTypeMarker for DeviceMonitorClearCountryResponse {
781 type Borrowed<'a> = &'a Self;
782 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
783 value
784 }
785 }
786
787 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorClearCountryResponse {
788 type Owned = Self;
789
790 #[inline(always)]
791 fn inline_align(_context: fidl::encoding::Context) -> usize {
792 4
793 }
794
795 #[inline(always)]
796 fn inline_size(_context: fidl::encoding::Context) -> usize {
797 4
798 }
799 #[inline(always)]
800 fn encode_is_copy() -> bool {
801 true
802 }
803
804 #[inline(always)]
805 fn decode_is_copy() -> bool {
806 true
807 }
808 }
809
810 unsafe impl<D: fidl::encoding::ResourceDialect>
811 fidl::encoding::Encode<DeviceMonitorClearCountryResponse, D>
812 for &DeviceMonitorClearCountryResponse
813 {
814 #[inline]
815 unsafe fn encode(
816 self,
817 encoder: &mut fidl::encoding::Encoder<'_, D>,
818 offset: usize,
819 _depth: fidl::encoding::Depth,
820 ) -> fidl::Result<()> {
821 encoder.debug_check_bounds::<DeviceMonitorClearCountryResponse>(offset);
822 unsafe {
823 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
825 (buf_ptr as *mut DeviceMonitorClearCountryResponse)
826 .write_unaligned((self as *const DeviceMonitorClearCountryResponse).read());
827 }
830 Ok(())
831 }
832 }
833 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
834 fidl::encoding::Encode<DeviceMonitorClearCountryResponse, D> for (T0,)
835 {
836 #[inline]
837 unsafe fn encode(
838 self,
839 encoder: &mut fidl::encoding::Encoder<'_, D>,
840 offset: usize,
841 depth: fidl::encoding::Depth,
842 ) -> fidl::Result<()> {
843 encoder.debug_check_bounds::<DeviceMonitorClearCountryResponse>(offset);
844 self.0.encode(encoder, offset + 0, depth)?;
848 Ok(())
849 }
850 }
851
852 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
853 for DeviceMonitorClearCountryResponse
854 {
855 #[inline(always)]
856 fn new_empty() -> Self {
857 Self { status: fidl::new_empty!(i32, D) }
858 }
859
860 #[inline]
861 unsafe fn decode(
862 &mut self,
863 decoder: &mut fidl::encoding::Decoder<'_, D>,
864 offset: usize,
865 _depth: fidl::encoding::Depth,
866 ) -> fidl::Result<()> {
867 decoder.debug_check_bounds::<Self>(offset);
868 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
869 unsafe {
872 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
873 }
874 Ok(())
875 }
876 }
877
878 impl fidl::encoding::ValueTypeMarker for DeviceMonitorDestroyIfaceRequest {
879 type Borrowed<'a> = &'a Self;
880 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
881 value
882 }
883 }
884
885 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorDestroyIfaceRequest {
886 type Owned = Self;
887
888 #[inline(always)]
889 fn inline_align(_context: fidl::encoding::Context) -> usize {
890 2
891 }
892
893 #[inline(always)]
894 fn inline_size(_context: fidl::encoding::Context) -> usize {
895 2
896 }
897 #[inline(always)]
898 fn encode_is_copy() -> bool {
899 true
900 }
901
902 #[inline(always)]
903 fn decode_is_copy() -> bool {
904 true
905 }
906 }
907
908 unsafe impl<D: fidl::encoding::ResourceDialect>
909 fidl::encoding::Encode<DeviceMonitorDestroyIfaceRequest, D>
910 for &DeviceMonitorDestroyIfaceRequest
911 {
912 #[inline]
913 unsafe fn encode(
914 self,
915 encoder: &mut fidl::encoding::Encoder<'_, D>,
916 offset: usize,
917 _depth: fidl::encoding::Depth,
918 ) -> fidl::Result<()> {
919 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceRequest>(offset);
920 unsafe {
921 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
923 (buf_ptr as *mut DeviceMonitorDestroyIfaceRequest)
924 .write_unaligned((self as *const DeviceMonitorDestroyIfaceRequest).read());
925 }
928 Ok(())
929 }
930 }
931 unsafe impl<
932 D: fidl::encoding::ResourceDialect,
933 T0: fidl::encoding::Encode<DestroyIfaceRequest, D>,
934 > fidl::encoding::Encode<DeviceMonitorDestroyIfaceRequest, D> for (T0,)
935 {
936 #[inline]
937 unsafe fn encode(
938 self,
939 encoder: &mut fidl::encoding::Encoder<'_, D>,
940 offset: usize,
941 depth: fidl::encoding::Depth,
942 ) -> fidl::Result<()> {
943 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceRequest>(offset);
944 self.0.encode(encoder, offset + 0, depth)?;
948 Ok(())
949 }
950 }
951
952 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
953 for DeviceMonitorDestroyIfaceRequest
954 {
955 #[inline(always)]
956 fn new_empty() -> Self {
957 Self { req: fidl::new_empty!(DestroyIfaceRequest, D) }
958 }
959
960 #[inline]
961 unsafe fn decode(
962 &mut self,
963 decoder: &mut fidl::encoding::Decoder<'_, D>,
964 offset: usize,
965 _depth: fidl::encoding::Depth,
966 ) -> fidl::Result<()> {
967 decoder.debug_check_bounds::<Self>(offset);
968 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
969 unsafe {
972 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
973 }
974 Ok(())
975 }
976 }
977
978 impl fidl::encoding::ValueTypeMarker for DeviceMonitorDestroyIfaceResponse {
979 type Borrowed<'a> = &'a Self;
980 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
981 value
982 }
983 }
984
985 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorDestroyIfaceResponse {
986 type Owned = Self;
987
988 #[inline(always)]
989 fn inline_align(_context: fidl::encoding::Context) -> usize {
990 4
991 }
992
993 #[inline(always)]
994 fn inline_size(_context: fidl::encoding::Context) -> usize {
995 4
996 }
997 #[inline(always)]
998 fn encode_is_copy() -> bool {
999 true
1000 }
1001
1002 #[inline(always)]
1003 fn decode_is_copy() -> bool {
1004 true
1005 }
1006 }
1007
1008 unsafe impl<D: fidl::encoding::ResourceDialect>
1009 fidl::encoding::Encode<DeviceMonitorDestroyIfaceResponse, D>
1010 for &DeviceMonitorDestroyIfaceResponse
1011 {
1012 #[inline]
1013 unsafe fn encode(
1014 self,
1015 encoder: &mut fidl::encoding::Encoder<'_, D>,
1016 offset: usize,
1017 _depth: fidl::encoding::Depth,
1018 ) -> fidl::Result<()> {
1019 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceResponse>(offset);
1020 unsafe {
1021 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1023 (buf_ptr as *mut DeviceMonitorDestroyIfaceResponse)
1024 .write_unaligned((self as *const DeviceMonitorDestroyIfaceResponse).read());
1025 }
1028 Ok(())
1029 }
1030 }
1031 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
1032 fidl::encoding::Encode<DeviceMonitorDestroyIfaceResponse, D> for (T0,)
1033 {
1034 #[inline]
1035 unsafe fn encode(
1036 self,
1037 encoder: &mut fidl::encoding::Encoder<'_, D>,
1038 offset: usize,
1039 depth: fidl::encoding::Depth,
1040 ) -> fidl::Result<()> {
1041 encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceResponse>(offset);
1042 self.0.encode(encoder, offset + 0, depth)?;
1046 Ok(())
1047 }
1048 }
1049
1050 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1051 for DeviceMonitorDestroyIfaceResponse
1052 {
1053 #[inline(always)]
1054 fn new_empty() -> Self {
1055 Self { status: fidl::new_empty!(i32, D) }
1056 }
1057
1058 #[inline]
1059 unsafe fn decode(
1060 &mut self,
1061 decoder: &mut fidl::encoding::Decoder<'_, D>,
1062 offset: usize,
1063 _depth: fidl::encoding::Depth,
1064 ) -> fidl::Result<()> {
1065 decoder.debug_check_bounds::<Self>(offset);
1066 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1067 unsafe {
1070 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1071 }
1072 Ok(())
1073 }
1074 }
1075
1076 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetCountryRequest {
1077 type Borrowed<'a> = &'a Self;
1078 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1079 value
1080 }
1081 }
1082
1083 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetCountryRequest {
1084 type Owned = Self;
1085
1086 #[inline(always)]
1087 fn inline_align(_context: fidl::encoding::Context) -> usize {
1088 2
1089 }
1090
1091 #[inline(always)]
1092 fn inline_size(_context: fidl::encoding::Context) -> usize {
1093 2
1094 }
1095 #[inline(always)]
1096 fn encode_is_copy() -> bool {
1097 true
1098 }
1099
1100 #[inline(always)]
1101 fn decode_is_copy() -> bool {
1102 true
1103 }
1104 }
1105
1106 unsafe impl<D: fidl::encoding::ResourceDialect>
1107 fidl::encoding::Encode<DeviceMonitorGetCountryRequest, D>
1108 for &DeviceMonitorGetCountryRequest
1109 {
1110 #[inline]
1111 unsafe fn encode(
1112 self,
1113 encoder: &mut fidl::encoding::Encoder<'_, D>,
1114 offset: usize,
1115 _depth: fidl::encoding::Depth,
1116 ) -> fidl::Result<()> {
1117 encoder.debug_check_bounds::<DeviceMonitorGetCountryRequest>(offset);
1118 unsafe {
1119 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1121 (buf_ptr as *mut DeviceMonitorGetCountryRequest)
1122 .write_unaligned((self as *const DeviceMonitorGetCountryRequest).read());
1123 }
1126 Ok(())
1127 }
1128 }
1129 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1130 fidl::encoding::Encode<DeviceMonitorGetCountryRequest, D> for (T0,)
1131 {
1132 #[inline]
1133 unsafe fn encode(
1134 self,
1135 encoder: &mut fidl::encoding::Encoder<'_, D>,
1136 offset: usize,
1137 depth: fidl::encoding::Depth,
1138 ) -> fidl::Result<()> {
1139 encoder.debug_check_bounds::<DeviceMonitorGetCountryRequest>(offset);
1140 self.0.encode(encoder, offset + 0, depth)?;
1144 Ok(())
1145 }
1146 }
1147
1148 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1149 for DeviceMonitorGetCountryRequest
1150 {
1151 #[inline(always)]
1152 fn new_empty() -> Self {
1153 Self { phy_id: fidl::new_empty!(u16, D) }
1154 }
1155
1156 #[inline]
1157 unsafe fn decode(
1158 &mut self,
1159 decoder: &mut fidl::encoding::Decoder<'_, D>,
1160 offset: usize,
1161 _depth: fidl::encoding::Depth,
1162 ) -> fidl::Result<()> {
1163 decoder.debug_check_bounds::<Self>(offset);
1164 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1165 unsafe {
1168 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1169 }
1170 Ok(())
1171 }
1172 }
1173
1174 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetDevPathRequest {
1175 type Borrowed<'a> = &'a Self;
1176 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1177 value
1178 }
1179 }
1180
1181 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetDevPathRequest {
1182 type Owned = Self;
1183
1184 #[inline(always)]
1185 fn inline_align(_context: fidl::encoding::Context) -> usize {
1186 2
1187 }
1188
1189 #[inline(always)]
1190 fn inline_size(_context: fidl::encoding::Context) -> usize {
1191 2
1192 }
1193 #[inline(always)]
1194 fn encode_is_copy() -> bool {
1195 true
1196 }
1197
1198 #[inline(always)]
1199 fn decode_is_copy() -> bool {
1200 true
1201 }
1202 }
1203
1204 unsafe impl<D: fidl::encoding::ResourceDialect>
1205 fidl::encoding::Encode<DeviceMonitorGetDevPathRequest, D>
1206 for &DeviceMonitorGetDevPathRequest
1207 {
1208 #[inline]
1209 unsafe fn encode(
1210 self,
1211 encoder: &mut fidl::encoding::Encoder<'_, D>,
1212 offset: usize,
1213 _depth: fidl::encoding::Depth,
1214 ) -> fidl::Result<()> {
1215 encoder.debug_check_bounds::<DeviceMonitorGetDevPathRequest>(offset);
1216 unsafe {
1217 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1219 (buf_ptr as *mut DeviceMonitorGetDevPathRequest)
1220 .write_unaligned((self as *const DeviceMonitorGetDevPathRequest).read());
1221 }
1224 Ok(())
1225 }
1226 }
1227 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1228 fidl::encoding::Encode<DeviceMonitorGetDevPathRequest, D> for (T0,)
1229 {
1230 #[inline]
1231 unsafe fn encode(
1232 self,
1233 encoder: &mut fidl::encoding::Encoder<'_, D>,
1234 offset: usize,
1235 depth: fidl::encoding::Depth,
1236 ) -> fidl::Result<()> {
1237 encoder.debug_check_bounds::<DeviceMonitorGetDevPathRequest>(offset);
1238 self.0.encode(encoder, offset + 0, depth)?;
1242 Ok(())
1243 }
1244 }
1245
1246 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1247 for DeviceMonitorGetDevPathRequest
1248 {
1249 #[inline(always)]
1250 fn new_empty() -> Self {
1251 Self { phy_id: fidl::new_empty!(u16, D) }
1252 }
1253
1254 #[inline]
1255 unsafe fn decode(
1256 &mut self,
1257 decoder: &mut fidl::encoding::Decoder<'_, D>,
1258 offset: usize,
1259 _depth: fidl::encoding::Depth,
1260 ) -> fidl::Result<()> {
1261 decoder.debug_check_bounds::<Self>(offset);
1262 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1263 unsafe {
1266 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1267 }
1268 Ok(())
1269 }
1270 }
1271
1272 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetDevPathResponse {
1273 type Borrowed<'a> = &'a Self;
1274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1275 value
1276 }
1277 }
1278
1279 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetDevPathResponse {
1280 type Owned = Self;
1281
1282 #[inline(always)]
1283 fn inline_align(_context: fidl::encoding::Context) -> usize {
1284 8
1285 }
1286
1287 #[inline(always)]
1288 fn inline_size(_context: fidl::encoding::Context) -> usize {
1289 16
1290 }
1291 }
1292
1293 unsafe impl<D: fidl::encoding::ResourceDialect>
1294 fidl::encoding::Encode<DeviceMonitorGetDevPathResponse, D>
1295 for &DeviceMonitorGetDevPathResponse
1296 {
1297 #[inline]
1298 unsafe fn encode(
1299 self,
1300 encoder: &mut fidl::encoding::Encoder<'_, D>,
1301 offset: usize,
1302 _depth: fidl::encoding::Depth,
1303 ) -> fidl::Result<()> {
1304 encoder.debug_check_bounds::<DeviceMonitorGetDevPathResponse>(offset);
1305 fidl::encoding::Encode::<DeviceMonitorGetDevPathResponse, D>::encode(
1307 (
1308 <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.dev_path),
1309 ),
1310 encoder, offset, _depth
1311 )
1312 }
1313 }
1314 unsafe impl<
1315 D: fidl::encoding::ResourceDialect,
1316 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::UnboundedString>, D>,
1317 > fidl::encoding::Encode<DeviceMonitorGetDevPathResponse, D> for (T0,)
1318 {
1319 #[inline]
1320 unsafe fn encode(
1321 self,
1322 encoder: &mut fidl::encoding::Encoder<'_, D>,
1323 offset: usize,
1324 depth: fidl::encoding::Depth,
1325 ) -> fidl::Result<()> {
1326 encoder.debug_check_bounds::<DeviceMonitorGetDevPathResponse>(offset);
1327 self.0.encode(encoder, offset + 0, depth)?;
1331 Ok(())
1332 }
1333 }
1334
1335 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1336 for DeviceMonitorGetDevPathResponse
1337 {
1338 #[inline(always)]
1339 fn new_empty() -> Self {
1340 Self {
1341 dev_path: fidl::new_empty!(
1342 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1343 D
1344 ),
1345 }
1346 }
1347
1348 #[inline]
1349 unsafe fn decode(
1350 &mut self,
1351 decoder: &mut fidl::encoding::Decoder<'_, D>,
1352 offset: usize,
1353 _depth: fidl::encoding::Depth,
1354 ) -> fidl::Result<()> {
1355 decoder.debug_check_bounds::<Self>(offset);
1356 fidl::decode!(
1358 fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1359 D,
1360 &mut self.dev_path,
1361 decoder,
1362 offset + 0,
1363 _depth
1364 )?;
1365 Ok(())
1366 }
1367 }
1368
1369 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerSaveModeRequest {
1370 type Borrowed<'a> = &'a Self;
1371 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1372 value
1373 }
1374 }
1375
1376 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerSaveModeRequest {
1377 type Owned = Self;
1378
1379 #[inline(always)]
1380 fn inline_align(_context: fidl::encoding::Context) -> usize {
1381 2
1382 }
1383
1384 #[inline(always)]
1385 fn inline_size(_context: fidl::encoding::Context) -> usize {
1386 2
1387 }
1388 #[inline(always)]
1389 fn encode_is_copy() -> bool {
1390 true
1391 }
1392
1393 #[inline(always)]
1394 fn decode_is_copy() -> bool {
1395 true
1396 }
1397 }
1398
1399 unsafe impl<D: fidl::encoding::ResourceDialect>
1400 fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeRequest, D>
1401 for &DeviceMonitorGetPowerSaveModeRequest
1402 {
1403 #[inline]
1404 unsafe fn encode(
1405 self,
1406 encoder: &mut fidl::encoding::Encoder<'_, D>,
1407 offset: usize,
1408 _depth: fidl::encoding::Depth,
1409 ) -> fidl::Result<()> {
1410 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeRequest>(offset);
1411 unsafe {
1412 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1414 (buf_ptr as *mut DeviceMonitorGetPowerSaveModeRequest)
1415 .write_unaligned((self as *const DeviceMonitorGetPowerSaveModeRequest).read());
1416 }
1419 Ok(())
1420 }
1421 }
1422 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1423 fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeRequest, D> for (T0,)
1424 {
1425 #[inline]
1426 unsafe fn encode(
1427 self,
1428 encoder: &mut fidl::encoding::Encoder<'_, D>,
1429 offset: usize,
1430 depth: fidl::encoding::Depth,
1431 ) -> fidl::Result<()> {
1432 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeRequest>(offset);
1433 self.0.encode(encoder, offset + 0, depth)?;
1437 Ok(())
1438 }
1439 }
1440
1441 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1442 for DeviceMonitorGetPowerSaveModeRequest
1443 {
1444 #[inline(always)]
1445 fn new_empty() -> Self {
1446 Self { phy_id: fidl::new_empty!(u16, D) }
1447 }
1448
1449 #[inline]
1450 unsafe fn decode(
1451 &mut self,
1452 decoder: &mut fidl::encoding::Decoder<'_, D>,
1453 offset: usize,
1454 _depth: fidl::encoding::Depth,
1455 ) -> fidl::Result<()> {
1456 decoder.debug_check_bounds::<Self>(offset);
1457 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1458 unsafe {
1461 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1462 }
1463 Ok(())
1464 }
1465 }
1466
1467 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerStateRequest {
1468 type Borrowed<'a> = &'a Self;
1469 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1470 value
1471 }
1472 }
1473
1474 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerStateRequest {
1475 type Owned = Self;
1476
1477 #[inline(always)]
1478 fn inline_align(_context: fidl::encoding::Context) -> usize {
1479 2
1480 }
1481
1482 #[inline(always)]
1483 fn inline_size(_context: fidl::encoding::Context) -> usize {
1484 2
1485 }
1486 #[inline(always)]
1487 fn encode_is_copy() -> bool {
1488 true
1489 }
1490
1491 #[inline(always)]
1492 fn decode_is_copy() -> bool {
1493 true
1494 }
1495 }
1496
1497 unsafe impl<D: fidl::encoding::ResourceDialect>
1498 fidl::encoding::Encode<DeviceMonitorGetPowerStateRequest, D>
1499 for &DeviceMonitorGetPowerStateRequest
1500 {
1501 #[inline]
1502 unsafe fn encode(
1503 self,
1504 encoder: &mut fidl::encoding::Encoder<'_, D>,
1505 offset: usize,
1506 _depth: fidl::encoding::Depth,
1507 ) -> fidl::Result<()> {
1508 encoder.debug_check_bounds::<DeviceMonitorGetPowerStateRequest>(offset);
1509 unsafe {
1510 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1512 (buf_ptr as *mut DeviceMonitorGetPowerStateRequest)
1513 .write_unaligned((self as *const DeviceMonitorGetPowerStateRequest).read());
1514 }
1517 Ok(())
1518 }
1519 }
1520 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1521 fidl::encoding::Encode<DeviceMonitorGetPowerStateRequest, D> for (T0,)
1522 {
1523 #[inline]
1524 unsafe fn encode(
1525 self,
1526 encoder: &mut fidl::encoding::Encoder<'_, D>,
1527 offset: usize,
1528 depth: fidl::encoding::Depth,
1529 ) -> fidl::Result<()> {
1530 encoder.debug_check_bounds::<DeviceMonitorGetPowerStateRequest>(offset);
1531 self.0.encode(encoder, offset + 0, depth)?;
1535 Ok(())
1536 }
1537 }
1538
1539 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1540 for DeviceMonitorGetPowerStateRequest
1541 {
1542 #[inline(always)]
1543 fn new_empty() -> Self {
1544 Self { phy_id: fidl::new_empty!(u16, D) }
1545 }
1546
1547 #[inline]
1548 unsafe fn decode(
1549 &mut self,
1550 decoder: &mut fidl::encoding::Decoder<'_, D>,
1551 offset: usize,
1552 _depth: fidl::encoding::Depth,
1553 ) -> fidl::Result<()> {
1554 decoder.debug_check_bounds::<Self>(offset);
1555 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1556 unsafe {
1559 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1560 }
1561 Ok(())
1562 }
1563 }
1564
1565 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetSupportedMacRolesRequest {
1566 type Borrowed<'a> = &'a Self;
1567 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1568 value
1569 }
1570 }
1571
1572 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetSupportedMacRolesRequest {
1573 type Owned = Self;
1574
1575 #[inline(always)]
1576 fn inline_align(_context: fidl::encoding::Context) -> usize {
1577 2
1578 }
1579
1580 #[inline(always)]
1581 fn inline_size(_context: fidl::encoding::Context) -> usize {
1582 2
1583 }
1584 #[inline(always)]
1585 fn encode_is_copy() -> bool {
1586 true
1587 }
1588
1589 #[inline(always)]
1590 fn decode_is_copy() -> bool {
1591 true
1592 }
1593 }
1594
1595 unsafe impl<D: fidl::encoding::ResourceDialect>
1596 fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesRequest, D>
1597 for &DeviceMonitorGetSupportedMacRolesRequest
1598 {
1599 #[inline]
1600 unsafe fn encode(
1601 self,
1602 encoder: &mut fidl::encoding::Encoder<'_, D>,
1603 offset: usize,
1604 _depth: fidl::encoding::Depth,
1605 ) -> fidl::Result<()> {
1606 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesRequest>(offset);
1607 unsafe {
1608 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1610 (buf_ptr as *mut DeviceMonitorGetSupportedMacRolesRequest).write_unaligned(
1611 (self as *const DeviceMonitorGetSupportedMacRolesRequest).read(),
1612 );
1613 }
1616 Ok(())
1617 }
1618 }
1619 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1620 fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesRequest, D> for (T0,)
1621 {
1622 #[inline]
1623 unsafe fn encode(
1624 self,
1625 encoder: &mut fidl::encoding::Encoder<'_, D>,
1626 offset: usize,
1627 depth: fidl::encoding::Depth,
1628 ) -> fidl::Result<()> {
1629 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesRequest>(offset);
1630 self.0.encode(encoder, offset + 0, depth)?;
1634 Ok(())
1635 }
1636 }
1637
1638 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1639 for DeviceMonitorGetSupportedMacRolesRequest
1640 {
1641 #[inline(always)]
1642 fn new_empty() -> Self {
1643 Self { phy_id: fidl::new_empty!(u16, D) }
1644 }
1645
1646 #[inline]
1647 unsafe fn decode(
1648 &mut self,
1649 decoder: &mut fidl::encoding::Decoder<'_, D>,
1650 offset: usize,
1651 _depth: fidl::encoding::Depth,
1652 ) -> fidl::Result<()> {
1653 decoder.debug_check_bounds::<Self>(offset);
1654 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1655 unsafe {
1658 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1659 }
1660 Ok(())
1661 }
1662 }
1663
1664 impl fidl::encoding::ValueTypeMarker for DeviceMonitorListIfacesResponse {
1665 type Borrowed<'a> = &'a Self;
1666 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1667 value
1668 }
1669 }
1670
1671 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorListIfacesResponse {
1672 type Owned = Self;
1673
1674 #[inline(always)]
1675 fn inline_align(_context: fidl::encoding::Context) -> usize {
1676 8
1677 }
1678
1679 #[inline(always)]
1680 fn inline_size(_context: fidl::encoding::Context) -> usize {
1681 16
1682 }
1683 }
1684
1685 unsafe impl<D: fidl::encoding::ResourceDialect>
1686 fidl::encoding::Encode<DeviceMonitorListIfacesResponse, D>
1687 for &DeviceMonitorListIfacesResponse
1688 {
1689 #[inline]
1690 unsafe fn encode(
1691 self,
1692 encoder: &mut fidl::encoding::Encoder<'_, D>,
1693 offset: usize,
1694 _depth: fidl::encoding::Depth,
1695 ) -> fidl::Result<()> {
1696 encoder.debug_check_bounds::<DeviceMonitorListIfacesResponse>(offset);
1697 fidl::encoding::Encode::<DeviceMonitorListIfacesResponse, D>::encode(
1699 (
1700 <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.iface_list),
1701 ),
1702 encoder, offset, _depth
1703 )
1704 }
1705 }
1706 unsafe impl<
1707 D: fidl::encoding::ResourceDialect,
1708 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u16>, D>,
1709 > fidl::encoding::Encode<DeviceMonitorListIfacesResponse, D> for (T0,)
1710 {
1711 #[inline]
1712 unsafe fn encode(
1713 self,
1714 encoder: &mut fidl::encoding::Encoder<'_, D>,
1715 offset: usize,
1716 depth: fidl::encoding::Depth,
1717 ) -> fidl::Result<()> {
1718 encoder.debug_check_bounds::<DeviceMonitorListIfacesResponse>(offset);
1719 self.0.encode(encoder, offset + 0, depth)?;
1723 Ok(())
1724 }
1725 }
1726
1727 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1728 for DeviceMonitorListIfacesResponse
1729 {
1730 #[inline(always)]
1731 fn new_empty() -> Self {
1732 Self { iface_list: fidl::new_empty!(fidl::encoding::UnboundedVector<u16>, D) }
1733 }
1734
1735 #[inline]
1736 unsafe fn decode(
1737 &mut self,
1738 decoder: &mut fidl::encoding::Decoder<'_, D>,
1739 offset: usize,
1740 _depth: fidl::encoding::Depth,
1741 ) -> fidl::Result<()> {
1742 decoder.debug_check_bounds::<Self>(offset);
1743 fidl::decode!(
1745 fidl::encoding::UnboundedVector<u16>,
1746 D,
1747 &mut self.iface_list,
1748 decoder,
1749 offset + 0,
1750 _depth
1751 )?;
1752 Ok(())
1753 }
1754 }
1755
1756 impl fidl::encoding::ValueTypeMarker for DeviceMonitorListPhysResponse {
1757 type Borrowed<'a> = &'a Self;
1758 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1759 value
1760 }
1761 }
1762
1763 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorListPhysResponse {
1764 type Owned = Self;
1765
1766 #[inline(always)]
1767 fn inline_align(_context: fidl::encoding::Context) -> usize {
1768 8
1769 }
1770
1771 #[inline(always)]
1772 fn inline_size(_context: fidl::encoding::Context) -> usize {
1773 16
1774 }
1775 }
1776
1777 unsafe impl<D: fidl::encoding::ResourceDialect>
1778 fidl::encoding::Encode<DeviceMonitorListPhysResponse, D>
1779 for &DeviceMonitorListPhysResponse
1780 {
1781 #[inline]
1782 unsafe fn encode(
1783 self,
1784 encoder: &mut fidl::encoding::Encoder<'_, D>,
1785 offset: usize,
1786 _depth: fidl::encoding::Depth,
1787 ) -> fidl::Result<()> {
1788 encoder.debug_check_bounds::<DeviceMonitorListPhysResponse>(offset);
1789 fidl::encoding::Encode::<DeviceMonitorListPhysResponse, D>::encode(
1791 (
1792 <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_list),
1793 ),
1794 encoder, offset, _depth
1795 )
1796 }
1797 }
1798 unsafe impl<
1799 D: fidl::encoding::ResourceDialect,
1800 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u16>, D>,
1801 > fidl::encoding::Encode<DeviceMonitorListPhysResponse, D> for (T0,)
1802 {
1803 #[inline]
1804 unsafe fn encode(
1805 self,
1806 encoder: &mut fidl::encoding::Encoder<'_, D>,
1807 offset: usize,
1808 depth: fidl::encoding::Depth,
1809 ) -> fidl::Result<()> {
1810 encoder.debug_check_bounds::<DeviceMonitorListPhysResponse>(offset);
1811 self.0.encode(encoder, offset + 0, depth)?;
1815 Ok(())
1816 }
1817 }
1818
1819 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1820 for DeviceMonitorListPhysResponse
1821 {
1822 #[inline(always)]
1823 fn new_empty() -> Self {
1824 Self { phy_list: fidl::new_empty!(fidl::encoding::UnboundedVector<u16>, D) }
1825 }
1826
1827 #[inline]
1828 unsafe fn decode(
1829 &mut self,
1830 decoder: &mut fidl::encoding::Decoder<'_, D>,
1831 offset: usize,
1832 _depth: fidl::encoding::Depth,
1833 ) -> fidl::Result<()> {
1834 decoder.debug_check_bounds::<Self>(offset);
1835 fidl::decode!(
1837 fidl::encoding::UnboundedVector<u16>,
1838 D,
1839 &mut self.phy_list,
1840 decoder,
1841 offset + 0,
1842 _depth
1843 )?;
1844 Ok(())
1845 }
1846 }
1847
1848 impl fidl::encoding::ValueTypeMarker for DeviceMonitorPowerDownRequest {
1849 type Borrowed<'a> = &'a Self;
1850 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1851 value
1852 }
1853 }
1854
1855 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorPowerDownRequest {
1856 type Owned = Self;
1857
1858 #[inline(always)]
1859 fn inline_align(_context: fidl::encoding::Context) -> usize {
1860 2
1861 }
1862
1863 #[inline(always)]
1864 fn inline_size(_context: fidl::encoding::Context) -> usize {
1865 2
1866 }
1867 #[inline(always)]
1868 fn encode_is_copy() -> bool {
1869 true
1870 }
1871
1872 #[inline(always)]
1873 fn decode_is_copy() -> bool {
1874 true
1875 }
1876 }
1877
1878 unsafe impl<D: fidl::encoding::ResourceDialect>
1879 fidl::encoding::Encode<DeviceMonitorPowerDownRequest, D>
1880 for &DeviceMonitorPowerDownRequest
1881 {
1882 #[inline]
1883 unsafe fn encode(
1884 self,
1885 encoder: &mut fidl::encoding::Encoder<'_, D>,
1886 offset: usize,
1887 _depth: fidl::encoding::Depth,
1888 ) -> fidl::Result<()> {
1889 encoder.debug_check_bounds::<DeviceMonitorPowerDownRequest>(offset);
1890 unsafe {
1891 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1893 (buf_ptr as *mut DeviceMonitorPowerDownRequest)
1894 .write_unaligned((self as *const DeviceMonitorPowerDownRequest).read());
1895 }
1898 Ok(())
1899 }
1900 }
1901 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1902 fidl::encoding::Encode<DeviceMonitorPowerDownRequest, D> for (T0,)
1903 {
1904 #[inline]
1905 unsafe fn encode(
1906 self,
1907 encoder: &mut fidl::encoding::Encoder<'_, D>,
1908 offset: usize,
1909 depth: fidl::encoding::Depth,
1910 ) -> fidl::Result<()> {
1911 encoder.debug_check_bounds::<DeviceMonitorPowerDownRequest>(offset);
1912 self.0.encode(encoder, offset + 0, depth)?;
1916 Ok(())
1917 }
1918 }
1919
1920 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1921 for DeviceMonitorPowerDownRequest
1922 {
1923 #[inline(always)]
1924 fn new_empty() -> Self {
1925 Self { phy_id: fidl::new_empty!(u16, D) }
1926 }
1927
1928 #[inline]
1929 unsafe fn decode(
1930 &mut self,
1931 decoder: &mut fidl::encoding::Decoder<'_, D>,
1932 offset: usize,
1933 _depth: fidl::encoding::Depth,
1934 ) -> fidl::Result<()> {
1935 decoder.debug_check_bounds::<Self>(offset);
1936 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1937 unsafe {
1940 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1941 }
1942 Ok(())
1943 }
1944 }
1945
1946 impl fidl::encoding::ValueTypeMarker for DeviceMonitorPowerUpRequest {
1947 type Borrowed<'a> = &'a Self;
1948 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1949 value
1950 }
1951 }
1952
1953 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorPowerUpRequest {
1954 type Owned = Self;
1955
1956 #[inline(always)]
1957 fn inline_align(_context: fidl::encoding::Context) -> usize {
1958 2
1959 }
1960
1961 #[inline(always)]
1962 fn inline_size(_context: fidl::encoding::Context) -> usize {
1963 2
1964 }
1965 #[inline(always)]
1966 fn encode_is_copy() -> bool {
1967 true
1968 }
1969
1970 #[inline(always)]
1971 fn decode_is_copy() -> bool {
1972 true
1973 }
1974 }
1975
1976 unsafe impl<D: fidl::encoding::ResourceDialect>
1977 fidl::encoding::Encode<DeviceMonitorPowerUpRequest, D> for &DeviceMonitorPowerUpRequest
1978 {
1979 #[inline]
1980 unsafe fn encode(
1981 self,
1982 encoder: &mut fidl::encoding::Encoder<'_, D>,
1983 offset: usize,
1984 _depth: fidl::encoding::Depth,
1985 ) -> fidl::Result<()> {
1986 encoder.debug_check_bounds::<DeviceMonitorPowerUpRequest>(offset);
1987 unsafe {
1988 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1990 (buf_ptr as *mut DeviceMonitorPowerUpRequest)
1991 .write_unaligned((self as *const DeviceMonitorPowerUpRequest).read());
1992 }
1995 Ok(())
1996 }
1997 }
1998 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1999 fidl::encoding::Encode<DeviceMonitorPowerUpRequest, D> for (T0,)
2000 {
2001 #[inline]
2002 unsafe fn encode(
2003 self,
2004 encoder: &mut fidl::encoding::Encoder<'_, D>,
2005 offset: usize,
2006 depth: fidl::encoding::Depth,
2007 ) -> fidl::Result<()> {
2008 encoder.debug_check_bounds::<DeviceMonitorPowerUpRequest>(offset);
2009 self.0.encode(encoder, offset + 0, depth)?;
2013 Ok(())
2014 }
2015 }
2016
2017 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2018 for DeviceMonitorPowerUpRequest
2019 {
2020 #[inline(always)]
2021 fn new_empty() -> Self {
2022 Self { phy_id: fidl::new_empty!(u16, D) }
2023 }
2024
2025 #[inline]
2026 unsafe fn decode(
2027 &mut self,
2028 decoder: &mut fidl::encoding::Decoder<'_, D>,
2029 offset: usize,
2030 _depth: fidl::encoding::Depth,
2031 ) -> fidl::Result<()> {
2032 decoder.debug_check_bounds::<Self>(offset);
2033 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2034 unsafe {
2037 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2038 }
2039 Ok(())
2040 }
2041 }
2042
2043 impl fidl::encoding::ValueTypeMarker for DeviceMonitorQueryIfaceRequest {
2044 type Borrowed<'a> = &'a Self;
2045 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2046 value
2047 }
2048 }
2049
2050 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorQueryIfaceRequest {
2051 type Owned = Self;
2052
2053 #[inline(always)]
2054 fn inline_align(_context: fidl::encoding::Context) -> usize {
2055 2
2056 }
2057
2058 #[inline(always)]
2059 fn inline_size(_context: fidl::encoding::Context) -> usize {
2060 2
2061 }
2062 #[inline(always)]
2063 fn encode_is_copy() -> bool {
2064 true
2065 }
2066
2067 #[inline(always)]
2068 fn decode_is_copy() -> bool {
2069 true
2070 }
2071 }
2072
2073 unsafe impl<D: fidl::encoding::ResourceDialect>
2074 fidl::encoding::Encode<DeviceMonitorQueryIfaceRequest, D>
2075 for &DeviceMonitorQueryIfaceRequest
2076 {
2077 #[inline]
2078 unsafe fn encode(
2079 self,
2080 encoder: &mut fidl::encoding::Encoder<'_, D>,
2081 offset: usize,
2082 _depth: fidl::encoding::Depth,
2083 ) -> fidl::Result<()> {
2084 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceRequest>(offset);
2085 unsafe {
2086 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2088 (buf_ptr as *mut DeviceMonitorQueryIfaceRequest)
2089 .write_unaligned((self as *const DeviceMonitorQueryIfaceRequest).read());
2090 }
2093 Ok(())
2094 }
2095 }
2096 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2097 fidl::encoding::Encode<DeviceMonitorQueryIfaceRequest, D> for (T0,)
2098 {
2099 #[inline]
2100 unsafe fn encode(
2101 self,
2102 encoder: &mut fidl::encoding::Encoder<'_, D>,
2103 offset: usize,
2104 depth: fidl::encoding::Depth,
2105 ) -> fidl::Result<()> {
2106 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceRequest>(offset);
2107 self.0.encode(encoder, offset + 0, depth)?;
2111 Ok(())
2112 }
2113 }
2114
2115 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2116 for DeviceMonitorQueryIfaceRequest
2117 {
2118 #[inline(always)]
2119 fn new_empty() -> Self {
2120 Self { iface_id: fidl::new_empty!(u16, D) }
2121 }
2122
2123 #[inline]
2124 unsafe fn decode(
2125 &mut self,
2126 decoder: &mut fidl::encoding::Decoder<'_, D>,
2127 offset: usize,
2128 _depth: fidl::encoding::Depth,
2129 ) -> fidl::Result<()> {
2130 decoder.debug_check_bounds::<Self>(offset);
2131 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2132 unsafe {
2135 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2136 }
2137 Ok(())
2138 }
2139 }
2140
2141 impl fidl::encoding::ValueTypeMarker for DeviceMonitorResetRequest {
2142 type Borrowed<'a> = &'a Self;
2143 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2144 value
2145 }
2146 }
2147
2148 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorResetRequest {
2149 type Owned = Self;
2150
2151 #[inline(always)]
2152 fn inline_align(_context: fidl::encoding::Context) -> usize {
2153 2
2154 }
2155
2156 #[inline(always)]
2157 fn inline_size(_context: fidl::encoding::Context) -> usize {
2158 2
2159 }
2160 #[inline(always)]
2161 fn encode_is_copy() -> bool {
2162 true
2163 }
2164
2165 #[inline(always)]
2166 fn decode_is_copy() -> bool {
2167 true
2168 }
2169 }
2170
2171 unsafe impl<D: fidl::encoding::ResourceDialect>
2172 fidl::encoding::Encode<DeviceMonitorResetRequest, D> for &DeviceMonitorResetRequest
2173 {
2174 #[inline]
2175 unsafe fn encode(
2176 self,
2177 encoder: &mut fidl::encoding::Encoder<'_, D>,
2178 offset: usize,
2179 _depth: fidl::encoding::Depth,
2180 ) -> fidl::Result<()> {
2181 encoder.debug_check_bounds::<DeviceMonitorResetRequest>(offset);
2182 unsafe {
2183 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2185 (buf_ptr as *mut DeviceMonitorResetRequest)
2186 .write_unaligned((self as *const DeviceMonitorResetRequest).read());
2187 }
2190 Ok(())
2191 }
2192 }
2193 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2194 fidl::encoding::Encode<DeviceMonitorResetRequest, D> for (T0,)
2195 {
2196 #[inline]
2197 unsafe fn encode(
2198 self,
2199 encoder: &mut fidl::encoding::Encoder<'_, D>,
2200 offset: usize,
2201 depth: fidl::encoding::Depth,
2202 ) -> fidl::Result<()> {
2203 encoder.debug_check_bounds::<DeviceMonitorResetRequest>(offset);
2204 self.0.encode(encoder, offset + 0, depth)?;
2208 Ok(())
2209 }
2210 }
2211
2212 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2213 for DeviceMonitorResetRequest
2214 {
2215 #[inline(always)]
2216 fn new_empty() -> Self {
2217 Self { phy_id: fidl::new_empty!(u16, D) }
2218 }
2219
2220 #[inline]
2221 unsafe fn decode(
2222 &mut self,
2223 decoder: &mut fidl::encoding::Decoder<'_, D>,
2224 offset: usize,
2225 _depth: fidl::encoding::Depth,
2226 ) -> fidl::Result<()> {
2227 decoder.debug_check_bounds::<Self>(offset);
2228 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2229 unsafe {
2232 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2233 }
2234 Ok(())
2235 }
2236 }
2237
2238 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetCountryRequest {
2239 type Borrowed<'a> = &'a Self;
2240 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2241 value
2242 }
2243 }
2244
2245 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetCountryRequest {
2246 type Owned = Self;
2247
2248 #[inline(always)]
2249 fn inline_align(_context: fidl::encoding::Context) -> usize {
2250 2
2251 }
2252
2253 #[inline(always)]
2254 fn inline_size(_context: fidl::encoding::Context) -> usize {
2255 4
2256 }
2257 #[inline(always)]
2258 fn encode_is_copy() -> bool {
2259 true
2260 }
2261
2262 #[inline(always)]
2263 fn decode_is_copy() -> bool {
2264 true
2265 }
2266 }
2267
2268 unsafe impl<D: fidl::encoding::ResourceDialect>
2269 fidl::encoding::Encode<DeviceMonitorSetCountryRequest, D>
2270 for &DeviceMonitorSetCountryRequest
2271 {
2272 #[inline]
2273 unsafe fn encode(
2274 self,
2275 encoder: &mut fidl::encoding::Encoder<'_, D>,
2276 offset: usize,
2277 _depth: fidl::encoding::Depth,
2278 ) -> fidl::Result<()> {
2279 encoder.debug_check_bounds::<DeviceMonitorSetCountryRequest>(offset);
2280 unsafe {
2281 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2283 (buf_ptr as *mut DeviceMonitorSetCountryRequest)
2284 .write_unaligned((self as *const DeviceMonitorSetCountryRequest).read());
2285 }
2288 Ok(())
2289 }
2290 }
2291 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetCountryRequest, D>>
2292 fidl::encoding::Encode<DeviceMonitorSetCountryRequest, D> for (T0,)
2293 {
2294 #[inline]
2295 unsafe fn encode(
2296 self,
2297 encoder: &mut fidl::encoding::Encoder<'_, D>,
2298 offset: usize,
2299 depth: fidl::encoding::Depth,
2300 ) -> fidl::Result<()> {
2301 encoder.debug_check_bounds::<DeviceMonitorSetCountryRequest>(offset);
2302 self.0.encode(encoder, offset + 0, depth)?;
2306 Ok(())
2307 }
2308 }
2309
2310 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2311 for DeviceMonitorSetCountryRequest
2312 {
2313 #[inline(always)]
2314 fn new_empty() -> Self {
2315 Self { req: fidl::new_empty!(SetCountryRequest, D) }
2316 }
2317
2318 #[inline]
2319 unsafe fn decode(
2320 &mut self,
2321 decoder: &mut fidl::encoding::Decoder<'_, D>,
2322 offset: usize,
2323 _depth: fidl::encoding::Depth,
2324 ) -> fidl::Result<()> {
2325 decoder.debug_check_bounds::<Self>(offset);
2326 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2327 unsafe {
2330 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
2331 }
2332 Ok(())
2333 }
2334 }
2335
2336 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetCountryResponse {
2337 type Borrowed<'a> = &'a Self;
2338 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2339 value
2340 }
2341 }
2342
2343 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetCountryResponse {
2344 type Owned = Self;
2345
2346 #[inline(always)]
2347 fn inline_align(_context: fidl::encoding::Context) -> usize {
2348 4
2349 }
2350
2351 #[inline(always)]
2352 fn inline_size(_context: fidl::encoding::Context) -> usize {
2353 4
2354 }
2355 #[inline(always)]
2356 fn encode_is_copy() -> bool {
2357 true
2358 }
2359
2360 #[inline(always)]
2361 fn decode_is_copy() -> bool {
2362 true
2363 }
2364 }
2365
2366 unsafe impl<D: fidl::encoding::ResourceDialect>
2367 fidl::encoding::Encode<DeviceMonitorSetCountryResponse, D>
2368 for &DeviceMonitorSetCountryResponse
2369 {
2370 #[inline]
2371 unsafe fn encode(
2372 self,
2373 encoder: &mut fidl::encoding::Encoder<'_, D>,
2374 offset: usize,
2375 _depth: fidl::encoding::Depth,
2376 ) -> fidl::Result<()> {
2377 encoder.debug_check_bounds::<DeviceMonitorSetCountryResponse>(offset);
2378 unsafe {
2379 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2381 (buf_ptr as *mut DeviceMonitorSetCountryResponse)
2382 .write_unaligned((self as *const DeviceMonitorSetCountryResponse).read());
2383 }
2386 Ok(())
2387 }
2388 }
2389 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
2390 fidl::encoding::Encode<DeviceMonitorSetCountryResponse, D> for (T0,)
2391 {
2392 #[inline]
2393 unsafe fn encode(
2394 self,
2395 encoder: &mut fidl::encoding::Encoder<'_, D>,
2396 offset: usize,
2397 depth: fidl::encoding::Depth,
2398 ) -> fidl::Result<()> {
2399 encoder.debug_check_bounds::<DeviceMonitorSetCountryResponse>(offset);
2400 self.0.encode(encoder, offset + 0, depth)?;
2404 Ok(())
2405 }
2406 }
2407
2408 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2409 for DeviceMonitorSetCountryResponse
2410 {
2411 #[inline(always)]
2412 fn new_empty() -> Self {
2413 Self { status: fidl::new_empty!(i32, D) }
2414 }
2415
2416 #[inline]
2417 unsafe fn decode(
2418 &mut self,
2419 decoder: &mut fidl::encoding::Decoder<'_, D>,
2420 offset: usize,
2421 _depth: fidl::encoding::Depth,
2422 ) -> fidl::Result<()> {
2423 decoder.debug_check_bounds::<Self>(offset);
2424 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2425 unsafe {
2428 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
2429 }
2430 Ok(())
2431 }
2432 }
2433
2434 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetPowerSaveModeRequest {
2435 type Borrowed<'a> = &'a Self;
2436 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2437 value
2438 }
2439 }
2440
2441 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetPowerSaveModeRequest {
2442 type Owned = Self;
2443
2444 #[inline(always)]
2445 fn inline_align(_context: fidl::encoding::Context) -> usize {
2446 4
2447 }
2448
2449 #[inline(always)]
2450 fn inline_size(_context: fidl::encoding::Context) -> usize {
2451 8
2452 }
2453 }
2454
2455 unsafe impl<D: fidl::encoding::ResourceDialect>
2456 fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeRequest, D>
2457 for &DeviceMonitorSetPowerSaveModeRequest
2458 {
2459 #[inline]
2460 unsafe fn encode(
2461 self,
2462 encoder: &mut fidl::encoding::Encoder<'_, D>,
2463 offset: usize,
2464 _depth: fidl::encoding::Depth,
2465 ) -> fidl::Result<()> {
2466 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeRequest>(offset);
2467 fidl::encoding::Encode::<DeviceMonitorSetPowerSaveModeRequest, D>::encode(
2469 (<SetPowerSaveModeRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
2470 encoder,
2471 offset,
2472 _depth,
2473 )
2474 }
2475 }
2476 unsafe impl<
2477 D: fidl::encoding::ResourceDialect,
2478 T0: fidl::encoding::Encode<SetPowerSaveModeRequest, D>,
2479 > fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeRequest, D> for (T0,)
2480 {
2481 #[inline]
2482 unsafe fn encode(
2483 self,
2484 encoder: &mut fidl::encoding::Encoder<'_, D>,
2485 offset: usize,
2486 depth: fidl::encoding::Depth,
2487 ) -> fidl::Result<()> {
2488 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeRequest>(offset);
2489 self.0.encode(encoder, offset + 0, depth)?;
2493 Ok(())
2494 }
2495 }
2496
2497 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2498 for DeviceMonitorSetPowerSaveModeRequest
2499 {
2500 #[inline(always)]
2501 fn new_empty() -> Self {
2502 Self { req: fidl::new_empty!(SetPowerSaveModeRequest, D) }
2503 }
2504
2505 #[inline]
2506 unsafe fn decode(
2507 &mut self,
2508 decoder: &mut fidl::encoding::Decoder<'_, D>,
2509 offset: usize,
2510 _depth: fidl::encoding::Depth,
2511 ) -> fidl::Result<()> {
2512 decoder.debug_check_bounds::<Self>(offset);
2513 fidl::decode!(SetPowerSaveModeRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
2515 Ok(())
2516 }
2517 }
2518
2519 impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetPowerSaveModeResponse {
2520 type Borrowed<'a> = &'a Self;
2521 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2522 value
2523 }
2524 }
2525
2526 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetPowerSaveModeResponse {
2527 type Owned = Self;
2528
2529 #[inline(always)]
2530 fn inline_align(_context: fidl::encoding::Context) -> usize {
2531 4
2532 }
2533
2534 #[inline(always)]
2535 fn inline_size(_context: fidl::encoding::Context) -> usize {
2536 4
2537 }
2538 #[inline(always)]
2539 fn encode_is_copy() -> bool {
2540 true
2541 }
2542
2543 #[inline(always)]
2544 fn decode_is_copy() -> bool {
2545 true
2546 }
2547 }
2548
2549 unsafe impl<D: fidl::encoding::ResourceDialect>
2550 fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeResponse, D>
2551 for &DeviceMonitorSetPowerSaveModeResponse
2552 {
2553 #[inline]
2554 unsafe fn encode(
2555 self,
2556 encoder: &mut fidl::encoding::Encoder<'_, D>,
2557 offset: usize,
2558 _depth: fidl::encoding::Depth,
2559 ) -> fidl::Result<()> {
2560 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeResponse>(offset);
2561 unsafe {
2562 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2564 (buf_ptr as *mut DeviceMonitorSetPowerSaveModeResponse)
2565 .write_unaligned((self as *const DeviceMonitorSetPowerSaveModeResponse).read());
2566 }
2569 Ok(())
2570 }
2571 }
2572 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
2573 fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeResponse, D> for (T0,)
2574 {
2575 #[inline]
2576 unsafe fn encode(
2577 self,
2578 encoder: &mut fidl::encoding::Encoder<'_, D>,
2579 offset: usize,
2580 depth: fidl::encoding::Depth,
2581 ) -> fidl::Result<()> {
2582 encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeResponse>(offset);
2583 self.0.encode(encoder, offset + 0, depth)?;
2587 Ok(())
2588 }
2589 }
2590
2591 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2592 for DeviceMonitorSetPowerSaveModeResponse
2593 {
2594 #[inline(always)]
2595 fn new_empty() -> Self {
2596 Self { status: fidl::new_empty!(i32, D) }
2597 }
2598
2599 #[inline]
2600 unsafe fn decode(
2601 &mut self,
2602 decoder: &mut fidl::encoding::Decoder<'_, D>,
2603 offset: usize,
2604 _depth: fidl::encoding::Depth,
2605 ) -> fidl::Result<()> {
2606 decoder.debug_check_bounds::<Self>(offset);
2607 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2608 unsafe {
2611 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
2612 }
2613 Ok(())
2614 }
2615 }
2616
2617 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetCountryResponse {
2618 type Borrowed<'a> = &'a Self;
2619 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2620 value
2621 }
2622 }
2623
2624 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetCountryResponse {
2625 type Owned = Self;
2626
2627 #[inline(always)]
2628 fn inline_align(_context: fidl::encoding::Context) -> usize {
2629 1
2630 }
2631
2632 #[inline(always)]
2633 fn inline_size(_context: fidl::encoding::Context) -> usize {
2634 2
2635 }
2636 #[inline(always)]
2637 fn encode_is_copy() -> bool {
2638 true
2639 }
2640
2641 #[inline(always)]
2642 fn decode_is_copy() -> bool {
2643 true
2644 }
2645 }
2646
2647 unsafe impl<D: fidl::encoding::ResourceDialect>
2648 fidl::encoding::Encode<DeviceMonitorGetCountryResponse, D>
2649 for &DeviceMonitorGetCountryResponse
2650 {
2651 #[inline]
2652 unsafe fn encode(
2653 self,
2654 encoder: &mut fidl::encoding::Encoder<'_, D>,
2655 offset: usize,
2656 _depth: fidl::encoding::Depth,
2657 ) -> fidl::Result<()> {
2658 encoder.debug_check_bounds::<DeviceMonitorGetCountryResponse>(offset);
2659 unsafe {
2660 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2662 (buf_ptr as *mut DeviceMonitorGetCountryResponse)
2663 .write_unaligned((self as *const DeviceMonitorGetCountryResponse).read());
2664 }
2667 Ok(())
2668 }
2669 }
2670 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<GetCountryResponse, D>>
2671 fidl::encoding::Encode<DeviceMonitorGetCountryResponse, D> for (T0,)
2672 {
2673 #[inline]
2674 unsafe fn encode(
2675 self,
2676 encoder: &mut fidl::encoding::Encoder<'_, D>,
2677 offset: usize,
2678 depth: fidl::encoding::Depth,
2679 ) -> fidl::Result<()> {
2680 encoder.debug_check_bounds::<DeviceMonitorGetCountryResponse>(offset);
2681 self.0.encode(encoder, offset + 0, depth)?;
2685 Ok(())
2686 }
2687 }
2688
2689 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2690 for DeviceMonitorGetCountryResponse
2691 {
2692 #[inline(always)]
2693 fn new_empty() -> Self {
2694 Self { resp: fidl::new_empty!(GetCountryResponse, D) }
2695 }
2696
2697 #[inline]
2698 unsafe fn decode(
2699 &mut self,
2700 decoder: &mut fidl::encoding::Decoder<'_, D>,
2701 offset: usize,
2702 _depth: fidl::encoding::Depth,
2703 ) -> fidl::Result<()> {
2704 decoder.debug_check_bounds::<Self>(offset);
2705 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2706 unsafe {
2709 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2710 }
2711 Ok(())
2712 }
2713 }
2714
2715 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerSaveModeResponse {
2716 type Borrowed<'a> = &'a Self;
2717 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2718 value
2719 }
2720 }
2721
2722 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerSaveModeResponse {
2723 type Owned = Self;
2724
2725 #[inline(always)]
2726 fn inline_align(_context: fidl::encoding::Context) -> usize {
2727 4
2728 }
2729
2730 #[inline(always)]
2731 fn inline_size(_context: fidl::encoding::Context) -> usize {
2732 4
2733 }
2734 }
2735
2736 unsafe impl<D: fidl::encoding::ResourceDialect>
2737 fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeResponse, D>
2738 for &DeviceMonitorGetPowerSaveModeResponse
2739 {
2740 #[inline]
2741 unsafe fn encode(
2742 self,
2743 encoder: &mut fidl::encoding::Encoder<'_, D>,
2744 offset: usize,
2745 _depth: fidl::encoding::Depth,
2746 ) -> fidl::Result<()> {
2747 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeResponse>(offset);
2748 fidl::encoding::Encode::<DeviceMonitorGetPowerSaveModeResponse, D>::encode(
2750 (<GetPowerSaveModeResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2751 encoder,
2752 offset,
2753 _depth,
2754 )
2755 }
2756 }
2757 unsafe impl<
2758 D: fidl::encoding::ResourceDialect,
2759 T0: fidl::encoding::Encode<GetPowerSaveModeResponse, D>,
2760 > fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeResponse, D> for (T0,)
2761 {
2762 #[inline]
2763 unsafe fn encode(
2764 self,
2765 encoder: &mut fidl::encoding::Encoder<'_, D>,
2766 offset: usize,
2767 depth: fidl::encoding::Depth,
2768 ) -> fidl::Result<()> {
2769 encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeResponse>(offset);
2770 self.0.encode(encoder, offset + 0, depth)?;
2774 Ok(())
2775 }
2776 }
2777
2778 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2779 for DeviceMonitorGetPowerSaveModeResponse
2780 {
2781 #[inline(always)]
2782 fn new_empty() -> Self {
2783 Self { resp: fidl::new_empty!(GetPowerSaveModeResponse, D) }
2784 }
2785
2786 #[inline]
2787 unsafe fn decode(
2788 &mut self,
2789 decoder: &mut fidl::encoding::Decoder<'_, D>,
2790 offset: usize,
2791 _depth: fidl::encoding::Depth,
2792 ) -> fidl::Result<()> {
2793 decoder.debug_check_bounds::<Self>(offset);
2794 fidl::decode!(
2796 GetPowerSaveModeResponse,
2797 D,
2798 &mut self.resp,
2799 decoder,
2800 offset + 0,
2801 _depth
2802 )?;
2803 Ok(())
2804 }
2805 }
2806
2807 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerStateResponse {
2808 type Borrowed<'a> = &'a Self;
2809 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2810 value
2811 }
2812 }
2813
2814 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerStateResponse {
2815 type Owned = Self;
2816
2817 #[inline(always)]
2818 fn inline_align(_context: fidl::encoding::Context) -> usize {
2819 1
2820 }
2821
2822 #[inline(always)]
2823 fn inline_size(_context: fidl::encoding::Context) -> usize {
2824 1
2825 }
2826 }
2827
2828 unsafe impl<D: fidl::encoding::ResourceDialect>
2829 fidl::encoding::Encode<DeviceMonitorGetPowerStateResponse, D>
2830 for &DeviceMonitorGetPowerStateResponse
2831 {
2832 #[inline]
2833 unsafe fn encode(
2834 self,
2835 encoder: &mut fidl::encoding::Encoder<'_, D>,
2836 offset: usize,
2837 _depth: fidl::encoding::Depth,
2838 ) -> fidl::Result<()> {
2839 encoder.debug_check_bounds::<DeviceMonitorGetPowerStateResponse>(offset);
2840 fidl::encoding::Encode::<DeviceMonitorGetPowerStateResponse, D>::encode(
2842 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.power_on),),
2843 encoder,
2844 offset,
2845 _depth,
2846 )
2847 }
2848 }
2849 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2850 fidl::encoding::Encode<DeviceMonitorGetPowerStateResponse, D> for (T0,)
2851 {
2852 #[inline]
2853 unsafe fn encode(
2854 self,
2855 encoder: &mut fidl::encoding::Encoder<'_, D>,
2856 offset: usize,
2857 depth: fidl::encoding::Depth,
2858 ) -> fidl::Result<()> {
2859 encoder.debug_check_bounds::<DeviceMonitorGetPowerStateResponse>(offset);
2860 self.0.encode(encoder, offset + 0, depth)?;
2864 Ok(())
2865 }
2866 }
2867
2868 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2869 for DeviceMonitorGetPowerStateResponse
2870 {
2871 #[inline(always)]
2872 fn new_empty() -> Self {
2873 Self { power_on: fidl::new_empty!(bool, D) }
2874 }
2875
2876 #[inline]
2877 unsafe fn decode(
2878 &mut self,
2879 decoder: &mut fidl::encoding::Decoder<'_, D>,
2880 offset: usize,
2881 _depth: fidl::encoding::Depth,
2882 ) -> fidl::Result<()> {
2883 decoder.debug_check_bounds::<Self>(offset);
2884 fidl::decode!(bool, D, &mut self.power_on, decoder, offset + 0, _depth)?;
2886 Ok(())
2887 }
2888 }
2889
2890 impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetSupportedMacRolesResponse {
2891 type Borrowed<'a> = &'a Self;
2892 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2893 value
2894 }
2895 }
2896
2897 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetSupportedMacRolesResponse {
2898 type Owned = Self;
2899
2900 #[inline(always)]
2901 fn inline_align(_context: fidl::encoding::Context) -> usize {
2902 8
2903 }
2904
2905 #[inline(always)]
2906 fn inline_size(_context: fidl::encoding::Context) -> usize {
2907 16
2908 }
2909 }
2910
2911 unsafe impl<D: fidl::encoding::ResourceDialect>
2912 fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesResponse, D>
2913 for &DeviceMonitorGetSupportedMacRolesResponse
2914 {
2915 #[inline]
2916 unsafe fn encode(
2917 self,
2918 encoder: &mut fidl::encoding::Encoder<'_, D>,
2919 offset: usize,
2920 _depth: fidl::encoding::Depth,
2921 ) -> fidl::Result<()> {
2922 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesResponse>(offset);
2923 fidl::encoding::Encode::<DeviceMonitorGetSupportedMacRolesResponse, D>::encode(
2925 (
2926 <fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.supported_mac_roles),
2927 ),
2928 encoder, offset, _depth
2929 )
2930 }
2931 }
2932 unsafe impl<
2933 D: fidl::encoding::ResourceDialect,
2934 T0: fidl::encoding::Encode<
2935 fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>,
2936 D,
2937 >,
2938 > fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesResponse, D> for (T0,)
2939 {
2940 #[inline]
2941 unsafe fn encode(
2942 self,
2943 encoder: &mut fidl::encoding::Encoder<'_, D>,
2944 offset: usize,
2945 depth: fidl::encoding::Depth,
2946 ) -> fidl::Result<()> {
2947 encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesResponse>(offset);
2948 self.0.encode(encoder, offset + 0, depth)?;
2952 Ok(())
2953 }
2954 }
2955
2956 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2957 for DeviceMonitorGetSupportedMacRolesResponse
2958 {
2959 #[inline(always)]
2960 fn new_empty() -> Self {
2961 Self {
2962 supported_mac_roles: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>, D),
2963 }
2964 }
2965
2966 #[inline]
2967 unsafe fn decode(
2968 &mut self,
2969 decoder: &mut fidl::encoding::Decoder<'_, D>,
2970 offset: usize,
2971 _depth: fidl::encoding::Depth,
2972 ) -> fidl::Result<()> {
2973 decoder.debug_check_bounds::<Self>(offset);
2974 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>, D, &mut self.supported_mac_roles, decoder, offset + 0, _depth)?;
2976 Ok(())
2977 }
2978 }
2979
2980 impl fidl::encoding::ValueTypeMarker for DeviceMonitorQueryIfaceResponse {
2981 type Borrowed<'a> = &'a Self;
2982 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2983 value
2984 }
2985 }
2986
2987 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorQueryIfaceResponse {
2988 type Owned = Self;
2989
2990 #[inline(always)]
2991 fn inline_align(_context: fidl::encoding::Context) -> usize {
2992 4
2993 }
2994
2995 #[inline(always)]
2996 fn inline_size(_context: fidl::encoding::Context) -> usize {
2997 16
2998 }
2999 }
3000
3001 unsafe impl<D: fidl::encoding::ResourceDialect>
3002 fidl::encoding::Encode<DeviceMonitorQueryIfaceResponse, D>
3003 for &DeviceMonitorQueryIfaceResponse
3004 {
3005 #[inline]
3006 unsafe fn encode(
3007 self,
3008 encoder: &mut fidl::encoding::Encoder<'_, D>,
3009 offset: usize,
3010 _depth: fidl::encoding::Depth,
3011 ) -> fidl::Result<()> {
3012 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceResponse>(offset);
3013 fidl::encoding::Encode::<DeviceMonitorQueryIfaceResponse, D>::encode(
3015 (<QueryIfaceResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
3016 encoder,
3017 offset,
3018 _depth,
3019 )
3020 }
3021 }
3022 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<QueryIfaceResponse, D>>
3023 fidl::encoding::Encode<DeviceMonitorQueryIfaceResponse, D> for (T0,)
3024 {
3025 #[inline]
3026 unsafe fn encode(
3027 self,
3028 encoder: &mut fidl::encoding::Encoder<'_, D>,
3029 offset: usize,
3030 depth: fidl::encoding::Depth,
3031 ) -> fidl::Result<()> {
3032 encoder.debug_check_bounds::<DeviceMonitorQueryIfaceResponse>(offset);
3033 self.0.encode(encoder, offset + 0, depth)?;
3037 Ok(())
3038 }
3039 }
3040
3041 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3042 for DeviceMonitorQueryIfaceResponse
3043 {
3044 #[inline(always)]
3045 fn new_empty() -> Self {
3046 Self { resp: fidl::new_empty!(QueryIfaceResponse, D) }
3047 }
3048
3049 #[inline]
3050 unsafe fn decode(
3051 &mut self,
3052 decoder: &mut fidl::encoding::Decoder<'_, D>,
3053 offset: usize,
3054 _depth: fidl::encoding::Depth,
3055 ) -> fidl::Result<()> {
3056 decoder.debug_check_bounds::<Self>(offset);
3057 fidl::decode!(QueryIfaceResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
3059 Ok(())
3060 }
3061 }
3062
3063 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnIfaceAddedRequest {
3064 type Borrowed<'a> = &'a Self;
3065 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3066 value
3067 }
3068 }
3069
3070 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnIfaceAddedRequest {
3071 type Owned = Self;
3072
3073 #[inline(always)]
3074 fn inline_align(_context: fidl::encoding::Context) -> usize {
3075 2
3076 }
3077
3078 #[inline(always)]
3079 fn inline_size(_context: fidl::encoding::Context) -> usize {
3080 2
3081 }
3082 #[inline(always)]
3083 fn encode_is_copy() -> bool {
3084 true
3085 }
3086
3087 #[inline(always)]
3088 fn decode_is_copy() -> bool {
3089 true
3090 }
3091 }
3092
3093 unsafe impl<D: fidl::encoding::ResourceDialect>
3094 fidl::encoding::Encode<DeviceWatcherOnIfaceAddedRequest, D>
3095 for &DeviceWatcherOnIfaceAddedRequest
3096 {
3097 #[inline]
3098 unsafe fn encode(
3099 self,
3100 encoder: &mut fidl::encoding::Encoder<'_, D>,
3101 offset: usize,
3102 _depth: fidl::encoding::Depth,
3103 ) -> fidl::Result<()> {
3104 encoder.debug_check_bounds::<DeviceWatcherOnIfaceAddedRequest>(offset);
3105 unsafe {
3106 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3108 (buf_ptr as *mut DeviceWatcherOnIfaceAddedRequest)
3109 .write_unaligned((self as *const DeviceWatcherOnIfaceAddedRequest).read());
3110 }
3113 Ok(())
3114 }
3115 }
3116 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
3117 fidl::encoding::Encode<DeviceWatcherOnIfaceAddedRequest, D> for (T0,)
3118 {
3119 #[inline]
3120 unsafe fn encode(
3121 self,
3122 encoder: &mut fidl::encoding::Encoder<'_, D>,
3123 offset: usize,
3124 depth: fidl::encoding::Depth,
3125 ) -> fidl::Result<()> {
3126 encoder.debug_check_bounds::<DeviceWatcherOnIfaceAddedRequest>(offset);
3127 self.0.encode(encoder, offset + 0, depth)?;
3131 Ok(())
3132 }
3133 }
3134
3135 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3136 for DeviceWatcherOnIfaceAddedRequest
3137 {
3138 #[inline(always)]
3139 fn new_empty() -> Self {
3140 Self { iface_id: fidl::new_empty!(u16, D) }
3141 }
3142
3143 #[inline]
3144 unsafe fn decode(
3145 &mut self,
3146 decoder: &mut fidl::encoding::Decoder<'_, D>,
3147 offset: usize,
3148 _depth: fidl::encoding::Depth,
3149 ) -> fidl::Result<()> {
3150 decoder.debug_check_bounds::<Self>(offset);
3151 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3152 unsafe {
3155 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3156 }
3157 Ok(())
3158 }
3159 }
3160
3161 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnIfaceRemovedRequest {
3162 type Borrowed<'a> = &'a Self;
3163 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3164 value
3165 }
3166 }
3167
3168 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnIfaceRemovedRequest {
3169 type Owned = Self;
3170
3171 #[inline(always)]
3172 fn inline_align(_context: fidl::encoding::Context) -> usize {
3173 2
3174 }
3175
3176 #[inline(always)]
3177 fn inline_size(_context: fidl::encoding::Context) -> usize {
3178 2
3179 }
3180 #[inline(always)]
3181 fn encode_is_copy() -> bool {
3182 true
3183 }
3184
3185 #[inline(always)]
3186 fn decode_is_copy() -> bool {
3187 true
3188 }
3189 }
3190
3191 unsafe impl<D: fidl::encoding::ResourceDialect>
3192 fidl::encoding::Encode<DeviceWatcherOnIfaceRemovedRequest, D>
3193 for &DeviceWatcherOnIfaceRemovedRequest
3194 {
3195 #[inline]
3196 unsafe fn encode(
3197 self,
3198 encoder: &mut fidl::encoding::Encoder<'_, D>,
3199 offset: usize,
3200 _depth: fidl::encoding::Depth,
3201 ) -> fidl::Result<()> {
3202 encoder.debug_check_bounds::<DeviceWatcherOnIfaceRemovedRequest>(offset);
3203 unsafe {
3204 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3206 (buf_ptr as *mut DeviceWatcherOnIfaceRemovedRequest)
3207 .write_unaligned((self as *const DeviceWatcherOnIfaceRemovedRequest).read());
3208 }
3211 Ok(())
3212 }
3213 }
3214 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
3215 fidl::encoding::Encode<DeviceWatcherOnIfaceRemovedRequest, D> for (T0,)
3216 {
3217 #[inline]
3218 unsafe fn encode(
3219 self,
3220 encoder: &mut fidl::encoding::Encoder<'_, D>,
3221 offset: usize,
3222 depth: fidl::encoding::Depth,
3223 ) -> fidl::Result<()> {
3224 encoder.debug_check_bounds::<DeviceWatcherOnIfaceRemovedRequest>(offset);
3225 self.0.encode(encoder, offset + 0, depth)?;
3229 Ok(())
3230 }
3231 }
3232
3233 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3234 for DeviceWatcherOnIfaceRemovedRequest
3235 {
3236 #[inline(always)]
3237 fn new_empty() -> Self {
3238 Self { iface_id: fidl::new_empty!(u16, D) }
3239 }
3240
3241 #[inline]
3242 unsafe fn decode(
3243 &mut self,
3244 decoder: &mut fidl::encoding::Decoder<'_, D>,
3245 offset: usize,
3246 _depth: fidl::encoding::Depth,
3247 ) -> fidl::Result<()> {
3248 decoder.debug_check_bounds::<Self>(offset);
3249 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3250 unsafe {
3253 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3254 }
3255 Ok(())
3256 }
3257 }
3258
3259 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnPhyAddedRequest {
3260 type Borrowed<'a> = &'a Self;
3261 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3262 value
3263 }
3264 }
3265
3266 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnPhyAddedRequest {
3267 type Owned = Self;
3268
3269 #[inline(always)]
3270 fn inline_align(_context: fidl::encoding::Context) -> usize {
3271 2
3272 }
3273
3274 #[inline(always)]
3275 fn inline_size(_context: fidl::encoding::Context) -> usize {
3276 2
3277 }
3278 #[inline(always)]
3279 fn encode_is_copy() -> bool {
3280 true
3281 }
3282
3283 #[inline(always)]
3284 fn decode_is_copy() -> bool {
3285 true
3286 }
3287 }
3288
3289 unsafe impl<D: fidl::encoding::ResourceDialect>
3290 fidl::encoding::Encode<DeviceWatcherOnPhyAddedRequest, D>
3291 for &DeviceWatcherOnPhyAddedRequest
3292 {
3293 #[inline]
3294 unsafe fn encode(
3295 self,
3296 encoder: &mut fidl::encoding::Encoder<'_, D>,
3297 offset: usize,
3298 _depth: fidl::encoding::Depth,
3299 ) -> fidl::Result<()> {
3300 encoder.debug_check_bounds::<DeviceWatcherOnPhyAddedRequest>(offset);
3301 unsafe {
3302 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3304 (buf_ptr as *mut DeviceWatcherOnPhyAddedRequest)
3305 .write_unaligned((self as *const DeviceWatcherOnPhyAddedRequest).read());
3306 }
3309 Ok(())
3310 }
3311 }
3312 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
3313 fidl::encoding::Encode<DeviceWatcherOnPhyAddedRequest, D> for (T0,)
3314 {
3315 #[inline]
3316 unsafe fn encode(
3317 self,
3318 encoder: &mut fidl::encoding::Encoder<'_, D>,
3319 offset: usize,
3320 depth: fidl::encoding::Depth,
3321 ) -> fidl::Result<()> {
3322 encoder.debug_check_bounds::<DeviceWatcherOnPhyAddedRequest>(offset);
3323 self.0.encode(encoder, offset + 0, depth)?;
3327 Ok(())
3328 }
3329 }
3330
3331 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3332 for DeviceWatcherOnPhyAddedRequest
3333 {
3334 #[inline(always)]
3335 fn new_empty() -> Self {
3336 Self { phy_id: fidl::new_empty!(u16, D) }
3337 }
3338
3339 #[inline]
3340 unsafe fn decode(
3341 &mut self,
3342 decoder: &mut fidl::encoding::Decoder<'_, D>,
3343 offset: usize,
3344 _depth: fidl::encoding::Depth,
3345 ) -> fidl::Result<()> {
3346 decoder.debug_check_bounds::<Self>(offset);
3347 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3348 unsafe {
3351 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3352 }
3353 Ok(())
3354 }
3355 }
3356
3357 impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnPhyRemovedRequest {
3358 type Borrowed<'a> = &'a Self;
3359 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3360 value
3361 }
3362 }
3363
3364 unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnPhyRemovedRequest {
3365 type Owned = Self;
3366
3367 #[inline(always)]
3368 fn inline_align(_context: fidl::encoding::Context) -> usize {
3369 2
3370 }
3371
3372 #[inline(always)]
3373 fn inline_size(_context: fidl::encoding::Context) -> usize {
3374 2
3375 }
3376 #[inline(always)]
3377 fn encode_is_copy() -> bool {
3378 true
3379 }
3380
3381 #[inline(always)]
3382 fn decode_is_copy() -> bool {
3383 true
3384 }
3385 }
3386
3387 unsafe impl<D: fidl::encoding::ResourceDialect>
3388 fidl::encoding::Encode<DeviceWatcherOnPhyRemovedRequest, D>
3389 for &DeviceWatcherOnPhyRemovedRequest
3390 {
3391 #[inline]
3392 unsafe fn encode(
3393 self,
3394 encoder: &mut fidl::encoding::Encoder<'_, D>,
3395 offset: usize,
3396 _depth: fidl::encoding::Depth,
3397 ) -> fidl::Result<()> {
3398 encoder.debug_check_bounds::<DeviceWatcherOnPhyRemovedRequest>(offset);
3399 unsafe {
3400 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3402 (buf_ptr as *mut DeviceWatcherOnPhyRemovedRequest)
3403 .write_unaligned((self as *const DeviceWatcherOnPhyRemovedRequest).read());
3404 }
3407 Ok(())
3408 }
3409 }
3410 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
3411 fidl::encoding::Encode<DeviceWatcherOnPhyRemovedRequest, D> for (T0,)
3412 {
3413 #[inline]
3414 unsafe fn encode(
3415 self,
3416 encoder: &mut fidl::encoding::Encoder<'_, D>,
3417 offset: usize,
3418 depth: fidl::encoding::Depth,
3419 ) -> fidl::Result<()> {
3420 encoder.debug_check_bounds::<DeviceWatcherOnPhyRemovedRequest>(offset);
3421 self.0.encode(encoder, offset + 0, depth)?;
3425 Ok(())
3426 }
3427 }
3428
3429 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3430 for DeviceWatcherOnPhyRemovedRequest
3431 {
3432 #[inline(always)]
3433 fn new_empty() -> Self {
3434 Self { phy_id: fidl::new_empty!(u16, D) }
3435 }
3436
3437 #[inline]
3438 unsafe fn decode(
3439 &mut self,
3440 decoder: &mut fidl::encoding::Decoder<'_, D>,
3441 offset: usize,
3442 _depth: fidl::encoding::Depth,
3443 ) -> fidl::Result<()> {
3444 decoder.debug_check_bounds::<Self>(offset);
3445 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3446 unsafe {
3449 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3450 }
3451 Ok(())
3452 }
3453 }
3454
3455 impl fidl::encoding::ValueTypeMarker for GetCountryResponse {
3456 type Borrowed<'a> = &'a Self;
3457 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3458 value
3459 }
3460 }
3461
3462 unsafe impl fidl::encoding::TypeMarker for GetCountryResponse {
3463 type Owned = Self;
3464
3465 #[inline(always)]
3466 fn inline_align(_context: fidl::encoding::Context) -> usize {
3467 1
3468 }
3469
3470 #[inline(always)]
3471 fn inline_size(_context: fidl::encoding::Context) -> usize {
3472 2
3473 }
3474 #[inline(always)]
3475 fn encode_is_copy() -> bool {
3476 true
3477 }
3478
3479 #[inline(always)]
3480 fn decode_is_copy() -> bool {
3481 true
3482 }
3483 }
3484
3485 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GetCountryResponse, D>
3486 for &GetCountryResponse
3487 {
3488 #[inline]
3489 unsafe fn encode(
3490 self,
3491 encoder: &mut fidl::encoding::Encoder<'_, D>,
3492 offset: usize,
3493 _depth: fidl::encoding::Depth,
3494 ) -> fidl::Result<()> {
3495 encoder.debug_check_bounds::<GetCountryResponse>(offset);
3496 unsafe {
3497 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3499 (buf_ptr as *mut GetCountryResponse)
3500 .write_unaligned((self as *const GetCountryResponse).read());
3501 }
3504 Ok(())
3505 }
3506 }
3507 unsafe impl<
3508 D: fidl::encoding::ResourceDialect,
3509 T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
3510 > fidl::encoding::Encode<GetCountryResponse, D> for (T0,)
3511 {
3512 #[inline]
3513 unsafe fn encode(
3514 self,
3515 encoder: &mut fidl::encoding::Encoder<'_, D>,
3516 offset: usize,
3517 depth: fidl::encoding::Depth,
3518 ) -> fidl::Result<()> {
3519 encoder.debug_check_bounds::<GetCountryResponse>(offset);
3520 self.0.encode(encoder, offset + 0, depth)?;
3524 Ok(())
3525 }
3526 }
3527
3528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetCountryResponse {
3529 #[inline(always)]
3530 fn new_empty() -> Self {
3531 Self { alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D) }
3532 }
3533
3534 #[inline]
3535 unsafe fn decode(
3536 &mut self,
3537 decoder: &mut fidl::encoding::Decoder<'_, D>,
3538 offset: usize,
3539 _depth: fidl::encoding::Depth,
3540 ) -> fidl::Result<()> {
3541 decoder.debug_check_bounds::<Self>(offset);
3542 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3543 unsafe {
3546 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3547 }
3548 Ok(())
3549 }
3550 }
3551
3552 impl fidl::encoding::ValueTypeMarker for GetPowerSaveModeResponse {
3553 type Borrowed<'a> = &'a Self;
3554 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3555 value
3556 }
3557 }
3558
3559 unsafe impl fidl::encoding::TypeMarker for GetPowerSaveModeResponse {
3560 type Owned = Self;
3561
3562 #[inline(always)]
3563 fn inline_align(_context: fidl::encoding::Context) -> usize {
3564 4
3565 }
3566
3567 #[inline(always)]
3568 fn inline_size(_context: fidl::encoding::Context) -> usize {
3569 4
3570 }
3571 }
3572
3573 unsafe impl<D: fidl::encoding::ResourceDialect>
3574 fidl::encoding::Encode<GetPowerSaveModeResponse, D> for &GetPowerSaveModeResponse
3575 {
3576 #[inline]
3577 unsafe fn encode(
3578 self,
3579 encoder: &mut fidl::encoding::Encoder<'_, D>,
3580 offset: usize,
3581 _depth: fidl::encoding::Depth,
3582 ) -> fidl::Result<()> {
3583 encoder.debug_check_bounds::<GetPowerSaveModeResponse>(offset);
3584 fidl::encoding::Encode::<GetPowerSaveModeResponse, D>::encode(
3586 (
3587 <fidl_fuchsia_wlan_common__common::PowerSaveType as fidl::encoding::ValueTypeMarker>::borrow(&self.ps_mode),
3588 ),
3589 encoder, offset, _depth
3590 )
3591 }
3592 }
3593 unsafe impl<
3594 D: fidl::encoding::ResourceDialect,
3595 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::PowerSaveType, D>,
3596 > fidl::encoding::Encode<GetPowerSaveModeResponse, D> for (T0,)
3597 {
3598 #[inline]
3599 unsafe fn encode(
3600 self,
3601 encoder: &mut fidl::encoding::Encoder<'_, D>,
3602 offset: usize,
3603 depth: fidl::encoding::Depth,
3604 ) -> fidl::Result<()> {
3605 encoder.debug_check_bounds::<GetPowerSaveModeResponse>(offset);
3606 self.0.encode(encoder, offset + 0, depth)?;
3610 Ok(())
3611 }
3612 }
3613
3614 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3615 for GetPowerSaveModeResponse
3616 {
3617 #[inline(always)]
3618 fn new_empty() -> Self {
3619 Self { ps_mode: fidl::new_empty!(fidl_fuchsia_wlan_common__common::PowerSaveType, D) }
3620 }
3621
3622 #[inline]
3623 unsafe fn decode(
3624 &mut self,
3625 decoder: &mut fidl::encoding::Decoder<'_, D>,
3626 offset: usize,
3627 _depth: fidl::encoding::Depth,
3628 ) -> fidl::Result<()> {
3629 decoder.debug_check_bounds::<Self>(offset);
3630 fidl::decode!(
3632 fidl_fuchsia_wlan_common__common::PowerSaveType,
3633 D,
3634 &mut self.ps_mode,
3635 decoder,
3636 offset + 0,
3637 _depth
3638 )?;
3639 Ok(())
3640 }
3641 }
3642
3643 impl fidl::encoding::ValueTypeMarker for QueryIfaceResponse {
3644 type Borrowed<'a> = &'a Self;
3645 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3646 value
3647 }
3648 }
3649
3650 unsafe impl fidl::encoding::TypeMarker for QueryIfaceResponse {
3651 type Owned = Self;
3652
3653 #[inline(always)]
3654 fn inline_align(_context: fidl::encoding::Context) -> usize {
3655 4
3656 }
3657
3658 #[inline(always)]
3659 fn inline_size(_context: fidl::encoding::Context) -> usize {
3660 16
3661 }
3662 }
3663
3664 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<QueryIfaceResponse, D>
3665 for &QueryIfaceResponse
3666 {
3667 #[inline]
3668 unsafe fn encode(
3669 self,
3670 encoder: &mut fidl::encoding::Encoder<'_, D>,
3671 offset: usize,
3672 _depth: fidl::encoding::Depth,
3673 ) -> fidl::Result<()> {
3674 encoder.debug_check_bounds::<QueryIfaceResponse>(offset);
3675 fidl::encoding::Encode::<QueryIfaceResponse, D>::encode(
3677 (
3678 <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow(&self.role),
3679 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3680 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_id),
3681 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_assigned_id),
3682 <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.sta_addr),
3683 ),
3684 encoder, offset, _depth
3685 )
3686 }
3687 }
3688 unsafe impl<
3689 D: fidl::encoding::ResourceDialect,
3690 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanMacRole, D>,
3691 T1: fidl::encoding::Encode<u16, D>,
3692 T2: fidl::encoding::Encode<u16, D>,
3693 T3: fidl::encoding::Encode<u16, D>,
3694 T4: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3695 > fidl::encoding::Encode<QueryIfaceResponse, D> for (T0, T1, T2, T3, T4)
3696 {
3697 #[inline]
3698 unsafe fn encode(
3699 self,
3700 encoder: &mut fidl::encoding::Encoder<'_, D>,
3701 offset: usize,
3702 depth: fidl::encoding::Depth,
3703 ) -> fidl::Result<()> {
3704 encoder.debug_check_bounds::<QueryIfaceResponse>(offset);
3705 self.0.encode(encoder, offset + 0, depth)?;
3709 self.1.encode(encoder, offset + 4, depth)?;
3710 self.2.encode(encoder, offset + 6, depth)?;
3711 self.3.encode(encoder, offset + 8, depth)?;
3712 self.4.encode(encoder, offset + 10, depth)?;
3713 Ok(())
3714 }
3715 }
3716
3717 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for QueryIfaceResponse {
3718 #[inline(always)]
3719 fn new_empty() -> Self {
3720 Self {
3721 role: fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D),
3722 id: fidl::new_empty!(u16, D),
3723 phy_id: fidl::new_empty!(u16, D),
3724 phy_assigned_id: fidl::new_empty!(u16, D),
3725 sta_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3726 }
3727 }
3728
3729 #[inline]
3730 unsafe fn decode(
3731 &mut self,
3732 decoder: &mut fidl::encoding::Decoder<'_, D>,
3733 offset: usize,
3734 _depth: fidl::encoding::Depth,
3735 ) -> fidl::Result<()> {
3736 decoder.debug_check_bounds::<Self>(offset);
3737 fidl::decode!(
3739 fidl_fuchsia_wlan_common__common::WlanMacRole,
3740 D,
3741 &mut self.role,
3742 decoder,
3743 offset + 0,
3744 _depth
3745 )?;
3746 fidl::decode!(u16, D, &mut self.id, decoder, offset + 4, _depth)?;
3747 fidl::decode!(u16, D, &mut self.phy_id, decoder, offset + 6, _depth)?;
3748 fidl::decode!(u16, D, &mut self.phy_assigned_id, decoder, offset + 8, _depth)?;
3749 fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_addr, decoder, offset + 10, _depth)?;
3750 Ok(())
3751 }
3752 }
3753
3754 impl fidl::encoding::ValueTypeMarker for SetCountryRequest {
3755 type Borrowed<'a> = &'a Self;
3756 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3757 value
3758 }
3759 }
3760
3761 unsafe impl fidl::encoding::TypeMarker for SetCountryRequest {
3762 type Owned = Self;
3763
3764 #[inline(always)]
3765 fn inline_align(_context: fidl::encoding::Context) -> usize {
3766 2
3767 }
3768
3769 #[inline(always)]
3770 fn inline_size(_context: fidl::encoding::Context) -> usize {
3771 4
3772 }
3773 #[inline(always)]
3774 fn encode_is_copy() -> bool {
3775 true
3776 }
3777
3778 #[inline(always)]
3779 fn decode_is_copy() -> bool {
3780 true
3781 }
3782 }
3783
3784 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetCountryRequest, D>
3785 for &SetCountryRequest
3786 {
3787 #[inline]
3788 unsafe fn encode(
3789 self,
3790 encoder: &mut fidl::encoding::Encoder<'_, D>,
3791 offset: usize,
3792 _depth: fidl::encoding::Depth,
3793 ) -> fidl::Result<()> {
3794 encoder.debug_check_bounds::<SetCountryRequest>(offset);
3795 unsafe {
3796 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3798 (buf_ptr as *mut SetCountryRequest)
3799 .write_unaligned((self as *const SetCountryRequest).read());
3800 }
3803 Ok(())
3804 }
3805 }
3806 unsafe impl<
3807 D: fidl::encoding::ResourceDialect,
3808 T0: fidl::encoding::Encode<u16, D>,
3809 T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
3810 > fidl::encoding::Encode<SetCountryRequest, D> for (T0, T1)
3811 {
3812 #[inline]
3813 unsafe fn encode(
3814 self,
3815 encoder: &mut fidl::encoding::Encoder<'_, D>,
3816 offset: usize,
3817 depth: fidl::encoding::Depth,
3818 ) -> fidl::Result<()> {
3819 encoder.debug_check_bounds::<SetCountryRequest>(offset);
3820 self.0.encode(encoder, offset + 0, depth)?;
3824 self.1.encode(encoder, offset + 2, depth)?;
3825 Ok(())
3826 }
3827 }
3828
3829 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetCountryRequest {
3830 #[inline(always)]
3831 fn new_empty() -> Self {
3832 Self {
3833 phy_id: fidl::new_empty!(u16, D),
3834 alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D),
3835 }
3836 }
3837
3838 #[inline]
3839 unsafe fn decode(
3840 &mut self,
3841 decoder: &mut fidl::encoding::Decoder<'_, D>,
3842 offset: usize,
3843 _depth: fidl::encoding::Depth,
3844 ) -> fidl::Result<()> {
3845 decoder.debug_check_bounds::<Self>(offset);
3846 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3847 unsafe {
3850 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
3851 }
3852 Ok(())
3853 }
3854 }
3855
3856 impl fidl::encoding::ValueTypeMarker for SetPowerSaveModeRequest {
3857 type Borrowed<'a> = &'a Self;
3858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3859 value
3860 }
3861 }
3862
3863 unsafe impl fidl::encoding::TypeMarker for SetPowerSaveModeRequest {
3864 type Owned = Self;
3865
3866 #[inline(always)]
3867 fn inline_align(_context: fidl::encoding::Context) -> usize {
3868 4
3869 }
3870
3871 #[inline(always)]
3872 fn inline_size(_context: fidl::encoding::Context) -> usize {
3873 8
3874 }
3875 }
3876
3877 unsafe impl<D: fidl::encoding::ResourceDialect>
3878 fidl::encoding::Encode<SetPowerSaveModeRequest, D> for &SetPowerSaveModeRequest
3879 {
3880 #[inline]
3881 unsafe fn encode(
3882 self,
3883 encoder: &mut fidl::encoding::Encoder<'_, D>,
3884 offset: usize,
3885 _depth: fidl::encoding::Depth,
3886 ) -> fidl::Result<()> {
3887 encoder.debug_check_bounds::<SetPowerSaveModeRequest>(offset);
3888 fidl::encoding::Encode::<SetPowerSaveModeRequest, D>::encode(
3890 (
3891 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_id),
3892 <fidl_fuchsia_wlan_common__common::PowerSaveType as fidl::encoding::ValueTypeMarker>::borrow(&self.ps_mode),
3893 ),
3894 encoder, offset, _depth
3895 )
3896 }
3897 }
3898 unsafe impl<
3899 D: fidl::encoding::ResourceDialect,
3900 T0: fidl::encoding::Encode<u16, D>,
3901 T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::PowerSaveType, D>,
3902 > fidl::encoding::Encode<SetPowerSaveModeRequest, D> for (T0, T1)
3903 {
3904 #[inline]
3905 unsafe fn encode(
3906 self,
3907 encoder: &mut fidl::encoding::Encoder<'_, D>,
3908 offset: usize,
3909 depth: fidl::encoding::Depth,
3910 ) -> fidl::Result<()> {
3911 encoder.debug_check_bounds::<SetPowerSaveModeRequest>(offset);
3912 unsafe {
3915 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3916 (ptr as *mut u32).write_unaligned(0);
3917 }
3918 self.0.encode(encoder, offset + 0, depth)?;
3920 self.1.encode(encoder, offset + 4, depth)?;
3921 Ok(())
3922 }
3923 }
3924
3925 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3926 for SetPowerSaveModeRequest
3927 {
3928 #[inline(always)]
3929 fn new_empty() -> Self {
3930 Self {
3931 phy_id: fidl::new_empty!(u16, D),
3932 ps_mode: fidl::new_empty!(fidl_fuchsia_wlan_common__common::PowerSaveType, D),
3933 }
3934 }
3935
3936 #[inline]
3937 unsafe fn decode(
3938 &mut self,
3939 decoder: &mut fidl::encoding::Decoder<'_, D>,
3940 offset: usize,
3941 _depth: fidl::encoding::Depth,
3942 ) -> fidl::Result<()> {
3943 decoder.debug_check_bounds::<Self>(offset);
3944 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3946 let padval = unsafe { (ptr as *const u32).read_unaligned() };
3947 let mask = 0xffff0000u32;
3948 let maskedval = padval & mask;
3949 if maskedval != 0 {
3950 return Err(fidl::Error::NonZeroPadding {
3951 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3952 });
3953 }
3954 fidl::decode!(u16, D, &mut self.phy_id, decoder, offset + 0, _depth)?;
3955 fidl::decode!(
3956 fidl_fuchsia_wlan_common__common::PowerSaveType,
3957 D,
3958 &mut self.ps_mode,
3959 decoder,
3960 offset + 4,
3961 _depth
3962 )?;
3963 Ok(())
3964 }
3965 }
3966
3967 impl DeviceMonitorCreateIfaceRequest {
3968 #[inline(always)]
3969 fn max_ordinal_present(&self) -> u64 {
3970 if let Some(_) = self.sta_address {
3971 return 3;
3972 }
3973 if let Some(_) = self.role {
3974 return 2;
3975 }
3976 if let Some(_) = self.phy_id {
3977 return 1;
3978 }
3979 0
3980 }
3981 }
3982
3983 impl fidl::encoding::ValueTypeMarker for DeviceMonitorCreateIfaceRequest {
3984 type Borrowed<'a> = &'a Self;
3985 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3986 value
3987 }
3988 }
3989
3990 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorCreateIfaceRequest {
3991 type Owned = Self;
3992
3993 #[inline(always)]
3994 fn inline_align(_context: fidl::encoding::Context) -> usize {
3995 8
3996 }
3997
3998 #[inline(always)]
3999 fn inline_size(_context: fidl::encoding::Context) -> usize {
4000 16
4001 }
4002 }
4003
4004 unsafe impl<D: fidl::encoding::ResourceDialect>
4005 fidl::encoding::Encode<DeviceMonitorCreateIfaceRequest, D>
4006 for &DeviceMonitorCreateIfaceRequest
4007 {
4008 unsafe fn encode(
4009 self,
4010 encoder: &mut fidl::encoding::Encoder<'_, D>,
4011 offset: usize,
4012 mut depth: fidl::encoding::Depth,
4013 ) -> fidl::Result<()> {
4014 encoder.debug_check_bounds::<DeviceMonitorCreateIfaceRequest>(offset);
4015 let max_ordinal: u64 = self.max_ordinal_present();
4017 encoder.write_num(max_ordinal, offset);
4018 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4019 if max_ordinal == 0 {
4021 return Ok(());
4022 }
4023 depth.increment()?;
4024 let envelope_size = 8;
4025 let bytes_len = max_ordinal as usize * envelope_size;
4026 #[allow(unused_variables)]
4027 let offset = encoder.out_of_line_offset(bytes_len);
4028 let mut _prev_end_offset: usize = 0;
4029 if 1 > max_ordinal {
4030 return Ok(());
4031 }
4032
4033 let cur_offset: usize = (1 - 1) * envelope_size;
4036
4037 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4039
4040 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4045 self.phy_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4046 encoder,
4047 offset + cur_offset,
4048 depth,
4049 )?;
4050
4051 _prev_end_offset = cur_offset + envelope_size;
4052 if 2 > max_ordinal {
4053 return Ok(());
4054 }
4055
4056 let cur_offset: usize = (2 - 1) * envelope_size;
4059
4060 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4062
4063 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
4068 self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
4069 encoder, offset + cur_offset, depth
4070 )?;
4071
4072 _prev_end_offset = cur_offset + envelope_size;
4073 if 3 > max_ordinal {
4074 return Ok(());
4075 }
4076
4077 let cur_offset: usize = (3 - 1) * envelope_size;
4080
4081 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4083
4084 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4089 self.sta_address
4090 .as_ref()
4091 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4092 encoder,
4093 offset + cur_offset,
4094 depth,
4095 )?;
4096
4097 _prev_end_offset = cur_offset + envelope_size;
4098
4099 Ok(())
4100 }
4101 }
4102
4103 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4104 for DeviceMonitorCreateIfaceRequest
4105 {
4106 #[inline(always)]
4107 fn new_empty() -> Self {
4108 Self::default()
4109 }
4110
4111 unsafe fn decode(
4112 &mut self,
4113 decoder: &mut fidl::encoding::Decoder<'_, D>,
4114 offset: usize,
4115 mut depth: fidl::encoding::Depth,
4116 ) -> fidl::Result<()> {
4117 decoder.debug_check_bounds::<Self>(offset);
4118 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4119 None => return Err(fidl::Error::NotNullable),
4120 Some(len) => len,
4121 };
4122 if len == 0 {
4124 return Ok(());
4125 };
4126 depth.increment()?;
4127 let envelope_size = 8;
4128 let bytes_len = len * envelope_size;
4129 let offset = decoder.out_of_line_offset(bytes_len)?;
4130 let mut _next_ordinal_to_read = 0;
4132 let mut next_offset = offset;
4133 let end_offset = offset + bytes_len;
4134 _next_ordinal_to_read += 1;
4135 if next_offset >= end_offset {
4136 return Ok(());
4137 }
4138
4139 while _next_ordinal_to_read < 1 {
4141 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4142 _next_ordinal_to_read += 1;
4143 next_offset += envelope_size;
4144 }
4145
4146 let next_out_of_line = decoder.next_out_of_line();
4147 let handles_before = decoder.remaining_handles();
4148 if let Some((inlined, num_bytes, num_handles)) =
4149 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4150 {
4151 let member_inline_size =
4152 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4153 if inlined != (member_inline_size <= 4) {
4154 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4155 }
4156 let inner_offset;
4157 let mut inner_depth = depth.clone();
4158 if inlined {
4159 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4160 inner_offset = next_offset;
4161 } else {
4162 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4163 inner_depth.increment()?;
4164 }
4165 let val_ref = self.phy_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
4166 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4167 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4168 {
4169 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4170 }
4171 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4172 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4173 }
4174 }
4175
4176 next_offset += envelope_size;
4177 _next_ordinal_to_read += 1;
4178 if next_offset >= end_offset {
4179 return Ok(());
4180 }
4181
4182 while _next_ordinal_to_read < 2 {
4184 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4185 _next_ordinal_to_read += 1;
4186 next_offset += envelope_size;
4187 }
4188
4189 let next_out_of_line = decoder.next_out_of_line();
4190 let handles_before = decoder.remaining_handles();
4191 if let Some((inlined, num_bytes, num_handles)) =
4192 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4193 {
4194 let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4195 if inlined != (member_inline_size <= 4) {
4196 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4197 }
4198 let inner_offset;
4199 let mut inner_depth = depth.clone();
4200 if inlined {
4201 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4202 inner_offset = next_offset;
4203 } else {
4204 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4205 inner_depth.increment()?;
4206 }
4207 let val_ref = self.role.get_or_insert_with(|| {
4208 fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
4209 });
4210 fidl::decode!(
4211 fidl_fuchsia_wlan_common__common::WlanMacRole,
4212 D,
4213 val_ref,
4214 decoder,
4215 inner_offset,
4216 inner_depth
4217 )?;
4218 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4219 {
4220 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4221 }
4222 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4223 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4224 }
4225 }
4226
4227 next_offset += envelope_size;
4228 _next_ordinal_to_read += 1;
4229 if next_offset >= end_offset {
4230 return Ok(());
4231 }
4232
4233 while _next_ordinal_to_read < 3 {
4235 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4236 _next_ordinal_to_read += 1;
4237 next_offset += envelope_size;
4238 }
4239
4240 let next_out_of_line = decoder.next_out_of_line();
4241 let handles_before = decoder.remaining_handles();
4242 if let Some((inlined, num_bytes, num_handles)) =
4243 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4244 {
4245 let member_inline_size =
4246 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4247 decoder.context,
4248 );
4249 if inlined != (member_inline_size <= 4) {
4250 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4251 }
4252 let inner_offset;
4253 let mut inner_depth = depth.clone();
4254 if inlined {
4255 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4256 inner_offset = next_offset;
4257 } else {
4258 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4259 inner_depth.increment()?;
4260 }
4261 let val_ref = self
4262 .sta_address
4263 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4264 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4265 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4266 {
4267 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4268 }
4269 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4270 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4271 }
4272 }
4273
4274 next_offset += envelope_size;
4275
4276 while next_offset < end_offset {
4278 _next_ordinal_to_read += 1;
4279 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4280 next_offset += envelope_size;
4281 }
4282
4283 Ok(())
4284 }
4285 }
4286
4287 impl DeviceMonitorCreateIfaceResponse {
4288 #[inline(always)]
4289 fn max_ordinal_present(&self) -> u64 {
4290 if let Some(_) = self.iface_id {
4291 return 1;
4292 }
4293 0
4294 }
4295 }
4296
4297 impl fidl::encoding::ValueTypeMarker for DeviceMonitorCreateIfaceResponse {
4298 type Borrowed<'a> = &'a Self;
4299 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4300 value
4301 }
4302 }
4303
4304 unsafe impl fidl::encoding::TypeMarker for DeviceMonitorCreateIfaceResponse {
4305 type Owned = Self;
4306
4307 #[inline(always)]
4308 fn inline_align(_context: fidl::encoding::Context) -> usize {
4309 8
4310 }
4311
4312 #[inline(always)]
4313 fn inline_size(_context: fidl::encoding::Context) -> usize {
4314 16
4315 }
4316 }
4317
4318 unsafe impl<D: fidl::encoding::ResourceDialect>
4319 fidl::encoding::Encode<DeviceMonitorCreateIfaceResponse, D>
4320 for &DeviceMonitorCreateIfaceResponse
4321 {
4322 unsafe fn encode(
4323 self,
4324 encoder: &mut fidl::encoding::Encoder<'_, D>,
4325 offset: usize,
4326 mut depth: fidl::encoding::Depth,
4327 ) -> fidl::Result<()> {
4328 encoder.debug_check_bounds::<DeviceMonitorCreateIfaceResponse>(offset);
4329 let max_ordinal: u64 = self.max_ordinal_present();
4331 encoder.write_num(max_ordinal, offset);
4332 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4333 if max_ordinal == 0 {
4335 return Ok(());
4336 }
4337 depth.increment()?;
4338 let envelope_size = 8;
4339 let bytes_len = max_ordinal as usize * envelope_size;
4340 #[allow(unused_variables)]
4341 let offset = encoder.out_of_line_offset(bytes_len);
4342 let mut _prev_end_offset: usize = 0;
4343 if 1 > max_ordinal {
4344 return Ok(());
4345 }
4346
4347 let cur_offset: usize = (1 - 1) * envelope_size;
4350
4351 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4353
4354 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4359 self.iface_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4360 encoder,
4361 offset + cur_offset,
4362 depth,
4363 )?;
4364
4365 _prev_end_offset = cur_offset + envelope_size;
4366
4367 Ok(())
4368 }
4369 }
4370
4371 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4372 for DeviceMonitorCreateIfaceResponse
4373 {
4374 #[inline(always)]
4375 fn new_empty() -> Self {
4376 Self::default()
4377 }
4378
4379 unsafe fn decode(
4380 &mut self,
4381 decoder: &mut fidl::encoding::Decoder<'_, D>,
4382 offset: usize,
4383 mut depth: fidl::encoding::Depth,
4384 ) -> fidl::Result<()> {
4385 decoder.debug_check_bounds::<Self>(offset);
4386 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4387 None => return Err(fidl::Error::NotNullable),
4388 Some(len) => len,
4389 };
4390 if len == 0 {
4392 return Ok(());
4393 };
4394 depth.increment()?;
4395 let envelope_size = 8;
4396 let bytes_len = len * envelope_size;
4397 let offset = decoder.out_of_line_offset(bytes_len)?;
4398 let mut _next_ordinal_to_read = 0;
4400 let mut next_offset = offset;
4401 let end_offset = offset + bytes_len;
4402 _next_ordinal_to_read += 1;
4403 if next_offset >= end_offset {
4404 return Ok(());
4405 }
4406
4407 while _next_ordinal_to_read < 1 {
4409 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4410 _next_ordinal_to_read += 1;
4411 next_offset += envelope_size;
4412 }
4413
4414 let next_out_of_line = decoder.next_out_of_line();
4415 let handles_before = decoder.remaining_handles();
4416 if let Some((inlined, num_bytes, num_handles)) =
4417 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4418 {
4419 let member_inline_size =
4420 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4421 if inlined != (member_inline_size <= 4) {
4422 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4423 }
4424 let inner_offset;
4425 let mut inner_depth = depth.clone();
4426 if inlined {
4427 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4428 inner_offset = next_offset;
4429 } else {
4430 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4431 inner_depth.increment()?;
4432 }
4433 let val_ref = self.iface_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
4434 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4435 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4436 {
4437 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4438 }
4439 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4440 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4441 }
4442 }
4443
4444 next_offset += envelope_size;
4445
4446 while next_offset < end_offset {
4448 _next_ordinal_to_read += 1;
4449 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4450 next_offset += envelope_size;
4451 }
4452
4453 Ok(())
4454 }
4455 }
4456
4457 impl fidl::encoding::ValueTypeMarker for GetIfaceHistogramStatsResponse {
4458 type Borrowed<'a> = &'a Self;
4459 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4460 value
4461 }
4462 }
4463
4464 unsafe impl fidl::encoding::TypeMarker for GetIfaceHistogramStatsResponse {
4465 type Owned = Self;
4466
4467 #[inline(always)]
4468 fn inline_align(_context: fidl::encoding::Context) -> usize {
4469 8
4470 }
4471
4472 #[inline(always)]
4473 fn inline_size(_context: fidl::encoding::Context) -> usize {
4474 16
4475 }
4476 }
4477
4478 unsafe impl<D: fidl::encoding::ResourceDialect>
4479 fidl::encoding::Encode<GetIfaceHistogramStatsResponse, D>
4480 for &GetIfaceHistogramStatsResponse
4481 {
4482 #[inline]
4483 unsafe fn encode(
4484 self,
4485 encoder: &mut fidl::encoding::Encoder<'_, D>,
4486 offset: usize,
4487 _depth: fidl::encoding::Depth,
4488 ) -> fidl::Result<()> {
4489 encoder.debug_check_bounds::<GetIfaceHistogramStatsResponse>(offset);
4490 encoder.write_num::<u64>(self.ordinal(), offset);
4491 match self {
4492 GetIfaceHistogramStatsResponse::Stats(ref val) => {
4493 fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>(
4494 <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(val),
4495 encoder, offset + 8, _depth
4496 )
4497 }
4498 GetIfaceHistogramStatsResponse::ErrorStatus(ref val) => {
4499 fidl::encoding::encode_in_envelope::<i32, D>(
4500 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
4501 encoder, offset + 8, _depth
4502 )
4503 }
4504 }
4505 }
4506 }
4507
4508 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4509 for GetIfaceHistogramStatsResponse
4510 {
4511 #[inline(always)]
4512 fn new_empty() -> Self {
4513 Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D))
4514 }
4515
4516 #[inline]
4517 unsafe fn decode(
4518 &mut self,
4519 decoder: &mut fidl::encoding::Decoder<'_, D>,
4520 offset: usize,
4521 mut depth: fidl::encoding::Depth,
4522 ) -> fidl::Result<()> {
4523 decoder.debug_check_bounds::<Self>(offset);
4524 #[allow(unused_variables)]
4525 let next_out_of_line = decoder.next_out_of_line();
4526 let handles_before = decoder.remaining_handles();
4527 let (ordinal, inlined, num_bytes, num_handles) =
4528 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4529
4530 let member_inline_size = match ordinal {
4531 1 => <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4532 2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4533 _ => return Err(fidl::Error::UnknownUnionTag),
4534 };
4535
4536 if inlined != (member_inline_size <= 4) {
4537 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4538 }
4539 let _inner_offset;
4540 if inlined {
4541 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4542 _inner_offset = offset + 8;
4543 } else {
4544 depth.increment()?;
4545 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4546 }
4547 match ordinal {
4548 1 => {
4549 #[allow(irrefutable_let_patterns)]
4550 if let GetIfaceHistogramStatsResponse::Stats(_) = self {
4551 } else {
4553 *self = GetIfaceHistogramStatsResponse::Stats(fidl::new_empty!(
4555 fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
4556 D
4557 ));
4558 }
4559 #[allow(irrefutable_let_patterns)]
4560 if let GetIfaceHistogramStatsResponse::Stats(ref mut val) = self {
4561 fidl::decode!(
4562 fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
4563 D,
4564 val,
4565 decoder,
4566 _inner_offset,
4567 depth
4568 )?;
4569 } else {
4570 unreachable!()
4571 }
4572 }
4573 2 => {
4574 #[allow(irrefutable_let_patterns)]
4575 if let GetIfaceHistogramStatsResponse::ErrorStatus(_) = self {
4576 } else {
4578 *self =
4580 GetIfaceHistogramStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
4581 }
4582 #[allow(irrefutable_let_patterns)]
4583 if let GetIfaceHistogramStatsResponse::ErrorStatus(ref mut val) = self {
4584 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
4585 } else {
4586 unreachable!()
4587 }
4588 }
4589 ordinal => panic!("unexpected ordinal {:?}", ordinal),
4590 }
4591 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4592 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4593 }
4594 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4595 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4596 }
4597 Ok(())
4598 }
4599 }
4600}