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
11pub const MAX_CONNECT_MATCHES: u16 = 5;
12
13pub const MAX_NUM_MATCHES: u16 = 250;
14
15pub const NODE_NAME_MAX: u32 = 255;
16
17#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
19pub enum CompatibilityState {
20 Error,
22 Absent,
24 Supported,
26 Unknown,
28 Unsupported,
30 #[doc(hidden)]
31 __SourceBreaking { unknown_ordinal: u32 },
32}
33
34#[macro_export]
36macro_rules! CompatibilityStateUnknown {
37 () => {
38 _
39 };
40}
41
42impl CompatibilityState {
43 #[inline]
44 pub fn from_primitive(prim: u32) -> Option<Self> {
45 match prim {
46 0 => Some(Self::Error),
47 1 => Some(Self::Absent),
48 2 => Some(Self::Supported),
49 3 => Some(Self::Unknown),
50 4 => Some(Self::Unsupported),
51 _ => None,
52 }
53 }
54
55 #[inline]
56 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
57 match prim {
58 0 => Self::Error,
59 1 => Self::Absent,
60 2 => Self::Supported,
61 3 => Self::Unknown,
62 4 => Self::Unsupported,
63 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
64 }
65 }
66
67 #[inline]
68 pub fn unknown() -> Self {
69 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
70 }
71
72 #[inline]
73 pub const fn into_primitive(self) -> u32 {
74 match self {
75 Self::Error => 0,
76 Self::Absent => 1,
77 Self::Supported => 2,
78 Self::Unknown => 3,
79 Self::Unsupported => 4,
80 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
81 }
82 }
83
84 #[inline]
85 pub fn is_unknown(&self) -> bool {
86 match self {
87 Self::__SourceBreaking { unknown_ordinal: _ } => true,
88 _ => false,
89 }
90 }
91}
92
93#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
94pub enum ConnectCapabilityError {
95 InvalidMoniker,
96 NoMatchingCapabilities,
97 NoMatchingComponent,
98 CapabilityConnectFailed,
99 #[doc(hidden)]
100 __SourceBreaking {
101 unknown_ordinal: u32,
102 },
103}
104
105#[macro_export]
107macro_rules! ConnectCapabilityErrorUnknown {
108 () => {
109 _
110 };
111}
112
113impl ConnectCapabilityError {
114 #[inline]
115 pub fn from_primitive(prim: u32) -> Option<Self> {
116 match prim {
117 1 => Some(Self::InvalidMoniker),
118 2 => Some(Self::NoMatchingCapabilities),
119 3 => Some(Self::NoMatchingComponent),
120 4 => Some(Self::CapabilityConnectFailed),
121 _ => None,
122 }
123 }
124
125 #[inline]
126 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
127 match prim {
128 1 => Self::InvalidMoniker,
129 2 => Self::NoMatchingCapabilities,
130 3 => Self::NoMatchingComponent,
131 4 => Self::CapabilityConnectFailed,
132 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
133 }
134 }
135
136 #[inline]
137 pub fn unknown() -> Self {
138 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
139 }
140
141 #[inline]
142 pub const fn into_primitive(self) -> u32 {
143 match self {
144 Self::InvalidMoniker => 1,
145 Self::NoMatchingCapabilities => 2,
146 Self::NoMatchingComponent => 3,
147 Self::CapabilityConnectFailed => 4,
148 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
149 }
150 }
151
152 #[inline]
153 pub fn is_unknown(&self) -> bool {
154 match self {
155 Self::__SourceBreaking { unknown_ordinal: _ } => true,
156 _ => false,
157 }
158 }
159}
160
161#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
162pub enum IdentifyHostError {
163 ListInterfacesFailed,
164 GetDeviceNameFailed,
165 ProxyConnectionFailed,
166 #[doc(hidden)]
167 __SourceBreaking {
168 unknown_ordinal: u32,
169 },
170}
171
172#[macro_export]
174macro_rules! IdentifyHostErrorUnknown {
175 () => {
176 _
177 };
178}
179
180impl IdentifyHostError {
181 #[inline]
182 pub fn from_primitive(prim: u32) -> Option<Self> {
183 match prim {
184 1 => Some(Self::ListInterfacesFailed),
185 2 => Some(Self::GetDeviceNameFailed),
186 3 => Some(Self::ProxyConnectionFailed),
187 _ => None,
188 }
189 }
190
191 #[inline]
192 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
193 match prim {
194 1 => Self::ListInterfacesFailed,
195 2 => Self::GetDeviceNameFailed,
196 3 => Self::ProxyConnectionFailed,
197 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
198 }
199 }
200
201 #[inline]
202 pub fn unknown() -> Self {
203 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
204 }
205
206 #[inline]
207 pub const fn into_primitive(self) -> u32 {
208 match self {
209 Self::ListInterfacesFailed => 1,
210 Self::GetDeviceNameFailed => 2,
211 Self::ProxyConnectionFailed => 3,
212 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
213 }
214 }
215
216 #[inline]
217 pub fn is_unknown(&self) -> bool {
218 match self {
219 Self::__SourceBreaking { unknown_ordinal: _ } => true,
220 _ => false,
221 }
222 }
223}
224
225#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
226pub enum TunnelError {
227 ConnectFailed,
228 SocketFailed,
229 CallbackError,
230 #[doc(hidden)]
231 __SourceBreaking {
232 unknown_ordinal: u32,
233 },
234}
235
236#[macro_export]
238macro_rules! TunnelErrorUnknown {
239 () => {
240 _
241 };
242}
243
244impl TunnelError {
245 #[inline]
246 pub fn from_primitive(prim: u32) -> Option<Self> {
247 match prim {
248 1 => Some(Self::ConnectFailed),
249 2 => Some(Self::SocketFailed),
250 3 => Some(Self::CallbackError),
251 _ => None,
252 }
253 }
254
255 #[inline]
256 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
257 match prim {
258 1 => Self::ConnectFailed,
259 2 => Self::SocketFailed,
260 3 => Self::CallbackError,
261 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
262 }
263 }
264
265 #[inline]
266 pub fn unknown() -> Self {
267 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
268 }
269
270 #[inline]
271 pub const fn into_primitive(self) -> u32 {
272 match self {
273 Self::ConnectFailed => 1,
274 Self::SocketFailed => 2,
275 Self::CallbackError => 3,
276 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
277 }
278 }
279
280 #[inline]
281 pub fn is_unknown(&self) -> bool {
282 match self {
283 Self::__SourceBreaking { unknown_ordinal: _ } => true,
284 _ => false,
285 }
286 }
287}
288
289#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
291pub struct CompatibilityInfo {
292 pub state: CompatibilityState,
294 pub platform_abi: u64,
296 pub message: String,
298}
299
300impl fidl::Persistable for CompatibilityInfo {}
301
302#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
303pub struct RemoteControlEchoStringRequest {
304 pub value: String,
305}
306
307impl fidl::Persistable for RemoteControlEchoStringRequest {}
308
309#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
310pub struct RemoteControlEchoStringResponse {
311 pub response: String,
312}
313
314impl fidl::Persistable for RemoteControlEchoStringResponse {}
315
316#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
317#[repr(C)]
318pub struct RemoteControlGetBootTimeResponse {
319 pub time: fidl::BootInstant,
320}
321
322impl fidl::Persistable for RemoteControlGetBootTimeResponse {}
323
324#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
325#[repr(C)]
326pub struct RemoteControlGetTimeResponse {
327 pub time: fidl::MonotonicInstant,
328}
329
330impl fidl::Persistable for RemoteControlGetTimeResponse {}
331
332#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
333pub struct RemoteControlLogMessageRequest {
334 pub tag: String,
335 pub message: String,
336 pub severity: fidl_fuchsia_diagnostics_types__common::Severity,
337}
338
339impl fidl::Persistable for RemoteControlLogMessageRequest {}
340
341#[derive(Clone, Debug, PartialEq)]
342pub struct RemoteControlIdentifyHostResponse {
343 pub response: IdentifyHostResponse,
344}
345
346impl fidl::Persistable for RemoteControlIdentifyHostResponse {}
347
348#[derive(Clone, Debug, Default, PartialEq)]
349pub struct IdentifyHostResponse {
350 pub nodename: Option<String>,
351 pub boot_timestamp_nanos: Option<u64>,
352 pub serial_number: Option<String>,
353 pub ids: Option<Vec<u64>>,
354 pub product_config: Option<String>,
355 pub board_config: Option<String>,
356 pub addresses: Option<Vec<fidl_fuchsia_net__common::Subnet>>,
357 pub boot_id: Option<u64>,
358 #[doc(hidden)]
359 pub __source_breaking: fidl::marker::SourceBreaking,
360}
361
362impl fidl::Persistable for IdentifyHostResponse {}
363
364pub mod remote_control_ordinals {
365 pub const ECHO_STRING: u64 = 0x2bbec7ca8a72e82b;
366 pub const LOG_MESSAGE: u64 = 0x3da84acd5bbf3926;
367 pub const IDENTIFY_HOST: u64 = 0x6035e1ab368deee1;
368 pub const CONNECT_CAPABILITY: u64 = 0x3ae7a7c874dceceb;
369 pub const GET_TIME: u64 = 0x3588f31e9067748d;
370 pub const GET_BOOT_TIME: u64 = 0x55706f013cd79ebd;
371 pub const DEPRECATED_OPEN_CAPABILITY: u64 = 0x51b5801f3e27e431;
372}
373
374mod internal {
375 use super::*;
376 unsafe impl fidl::encoding::TypeMarker for CompatibilityState {
377 type Owned = Self;
378
379 #[inline(always)]
380 fn inline_align(_context: fidl::encoding::Context) -> usize {
381 std::mem::align_of::<u32>()
382 }
383
384 #[inline(always)]
385 fn inline_size(_context: fidl::encoding::Context) -> usize {
386 std::mem::size_of::<u32>()
387 }
388
389 #[inline(always)]
390 fn encode_is_copy() -> bool {
391 false
392 }
393
394 #[inline(always)]
395 fn decode_is_copy() -> bool {
396 false
397 }
398 }
399
400 impl fidl::encoding::ValueTypeMarker for CompatibilityState {
401 type Borrowed<'a> = Self;
402 #[inline(always)]
403 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
404 *value
405 }
406 }
407
408 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
409 for CompatibilityState
410 {
411 #[inline]
412 unsafe fn encode(
413 self,
414 encoder: &mut fidl::encoding::Encoder<'_, D>,
415 offset: usize,
416 _depth: fidl::encoding::Depth,
417 ) -> fidl::Result<()> {
418 encoder.debug_check_bounds::<Self>(offset);
419 encoder.write_num(self.into_primitive(), offset);
420 Ok(())
421 }
422 }
423
424 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompatibilityState {
425 #[inline(always)]
426 fn new_empty() -> Self {
427 Self::unknown()
428 }
429
430 #[inline]
431 unsafe fn decode(
432 &mut self,
433 decoder: &mut fidl::encoding::Decoder<'_, D>,
434 offset: usize,
435 _depth: fidl::encoding::Depth,
436 ) -> fidl::Result<()> {
437 decoder.debug_check_bounds::<Self>(offset);
438 let prim = decoder.read_num::<u32>(offset);
439
440 *self = Self::from_primitive_allow_unknown(prim);
441 Ok(())
442 }
443 }
444 unsafe impl fidl::encoding::TypeMarker for ConnectCapabilityError {
445 type Owned = Self;
446
447 #[inline(always)]
448 fn inline_align(_context: fidl::encoding::Context) -> usize {
449 std::mem::align_of::<u32>()
450 }
451
452 #[inline(always)]
453 fn inline_size(_context: fidl::encoding::Context) -> usize {
454 std::mem::size_of::<u32>()
455 }
456
457 #[inline(always)]
458 fn encode_is_copy() -> bool {
459 false
460 }
461
462 #[inline(always)]
463 fn decode_is_copy() -> bool {
464 false
465 }
466 }
467
468 impl fidl::encoding::ValueTypeMarker for ConnectCapabilityError {
469 type Borrowed<'a> = Self;
470 #[inline(always)]
471 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
472 *value
473 }
474 }
475
476 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
477 for ConnectCapabilityError
478 {
479 #[inline]
480 unsafe fn encode(
481 self,
482 encoder: &mut fidl::encoding::Encoder<'_, D>,
483 offset: usize,
484 _depth: fidl::encoding::Depth,
485 ) -> fidl::Result<()> {
486 encoder.debug_check_bounds::<Self>(offset);
487 encoder.write_num(self.into_primitive(), offset);
488 Ok(())
489 }
490 }
491
492 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
493 for ConnectCapabilityError
494 {
495 #[inline(always)]
496 fn new_empty() -> Self {
497 Self::unknown()
498 }
499
500 #[inline]
501 unsafe fn decode(
502 &mut self,
503 decoder: &mut fidl::encoding::Decoder<'_, D>,
504 offset: usize,
505 _depth: fidl::encoding::Depth,
506 ) -> fidl::Result<()> {
507 decoder.debug_check_bounds::<Self>(offset);
508 let prim = decoder.read_num::<u32>(offset);
509
510 *self = Self::from_primitive_allow_unknown(prim);
511 Ok(())
512 }
513 }
514 unsafe impl fidl::encoding::TypeMarker for IdentifyHostError {
515 type Owned = Self;
516
517 #[inline(always)]
518 fn inline_align(_context: fidl::encoding::Context) -> usize {
519 std::mem::align_of::<u32>()
520 }
521
522 #[inline(always)]
523 fn inline_size(_context: fidl::encoding::Context) -> usize {
524 std::mem::size_of::<u32>()
525 }
526
527 #[inline(always)]
528 fn encode_is_copy() -> bool {
529 false
530 }
531
532 #[inline(always)]
533 fn decode_is_copy() -> bool {
534 false
535 }
536 }
537
538 impl fidl::encoding::ValueTypeMarker for IdentifyHostError {
539 type Borrowed<'a> = Self;
540 #[inline(always)]
541 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
542 *value
543 }
544 }
545
546 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
547 for IdentifyHostError
548 {
549 #[inline]
550 unsafe fn encode(
551 self,
552 encoder: &mut fidl::encoding::Encoder<'_, D>,
553 offset: usize,
554 _depth: fidl::encoding::Depth,
555 ) -> fidl::Result<()> {
556 encoder.debug_check_bounds::<Self>(offset);
557 encoder.write_num(self.into_primitive(), offset);
558 Ok(())
559 }
560 }
561
562 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IdentifyHostError {
563 #[inline(always)]
564 fn new_empty() -> Self {
565 Self::unknown()
566 }
567
568 #[inline]
569 unsafe fn decode(
570 &mut self,
571 decoder: &mut fidl::encoding::Decoder<'_, D>,
572 offset: usize,
573 _depth: fidl::encoding::Depth,
574 ) -> fidl::Result<()> {
575 decoder.debug_check_bounds::<Self>(offset);
576 let prim = decoder.read_num::<u32>(offset);
577
578 *self = Self::from_primitive_allow_unknown(prim);
579 Ok(())
580 }
581 }
582 unsafe impl fidl::encoding::TypeMarker for TunnelError {
583 type Owned = Self;
584
585 #[inline(always)]
586 fn inline_align(_context: fidl::encoding::Context) -> usize {
587 std::mem::align_of::<u32>()
588 }
589
590 #[inline(always)]
591 fn inline_size(_context: fidl::encoding::Context) -> usize {
592 std::mem::size_of::<u32>()
593 }
594
595 #[inline(always)]
596 fn encode_is_copy() -> bool {
597 false
598 }
599
600 #[inline(always)]
601 fn decode_is_copy() -> bool {
602 false
603 }
604 }
605
606 impl fidl::encoding::ValueTypeMarker for TunnelError {
607 type Borrowed<'a> = Self;
608 #[inline(always)]
609 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
610 *value
611 }
612 }
613
614 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TunnelError {
615 #[inline]
616 unsafe fn encode(
617 self,
618 encoder: &mut fidl::encoding::Encoder<'_, D>,
619 offset: usize,
620 _depth: fidl::encoding::Depth,
621 ) -> fidl::Result<()> {
622 encoder.debug_check_bounds::<Self>(offset);
623 encoder.write_num(self.into_primitive(), offset);
624 Ok(())
625 }
626 }
627
628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TunnelError {
629 #[inline(always)]
630 fn new_empty() -> Self {
631 Self::unknown()
632 }
633
634 #[inline]
635 unsafe fn decode(
636 &mut self,
637 decoder: &mut fidl::encoding::Decoder<'_, D>,
638 offset: usize,
639 _depth: fidl::encoding::Depth,
640 ) -> fidl::Result<()> {
641 decoder.debug_check_bounds::<Self>(offset);
642 let prim = decoder.read_num::<u32>(offset);
643
644 *self = Self::from_primitive_allow_unknown(prim);
645 Ok(())
646 }
647 }
648
649 impl fidl::encoding::ValueTypeMarker for CompatibilityInfo {
650 type Borrowed<'a> = &'a Self;
651 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
652 value
653 }
654 }
655
656 unsafe impl fidl::encoding::TypeMarker for CompatibilityInfo {
657 type Owned = Self;
658
659 #[inline(always)]
660 fn inline_align(_context: fidl::encoding::Context) -> usize {
661 8
662 }
663
664 #[inline(always)]
665 fn inline_size(_context: fidl::encoding::Context) -> usize {
666 32
667 }
668 }
669
670 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompatibilityInfo, D>
671 for &CompatibilityInfo
672 {
673 #[inline]
674 unsafe fn encode(
675 self,
676 encoder: &mut fidl::encoding::Encoder<'_, D>,
677 offset: usize,
678 _depth: fidl::encoding::Depth,
679 ) -> fidl::Result<()> {
680 encoder.debug_check_bounds::<CompatibilityInfo>(offset);
681 fidl::encoding::Encode::<CompatibilityInfo, D>::encode(
683 (
684 <CompatibilityState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
685 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.platform_abi),
686 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
687 &self.message,
688 ),
689 ),
690 encoder,
691 offset,
692 _depth,
693 )
694 }
695 }
696 unsafe impl<
697 D: fidl::encoding::ResourceDialect,
698 T0: fidl::encoding::Encode<CompatibilityState, D>,
699 T1: fidl::encoding::Encode<u64, D>,
700 T2: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
701 > fidl::encoding::Encode<CompatibilityInfo, D> for (T0, T1, T2)
702 {
703 #[inline]
704 unsafe fn encode(
705 self,
706 encoder: &mut fidl::encoding::Encoder<'_, D>,
707 offset: usize,
708 depth: fidl::encoding::Depth,
709 ) -> fidl::Result<()> {
710 encoder.debug_check_bounds::<CompatibilityInfo>(offset);
711 unsafe {
714 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
715 (ptr as *mut u64).write_unaligned(0);
716 }
717 self.0.encode(encoder, offset + 0, depth)?;
719 self.1.encode(encoder, offset + 8, depth)?;
720 self.2.encode(encoder, offset + 16, depth)?;
721 Ok(())
722 }
723 }
724
725 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompatibilityInfo {
726 #[inline(always)]
727 fn new_empty() -> Self {
728 Self {
729 state: fidl::new_empty!(CompatibilityState, D),
730 platform_abi: fidl::new_empty!(u64, D),
731 message: fidl::new_empty!(fidl::encoding::UnboundedString, D),
732 }
733 }
734
735 #[inline]
736 unsafe fn decode(
737 &mut self,
738 decoder: &mut fidl::encoding::Decoder<'_, D>,
739 offset: usize,
740 _depth: fidl::encoding::Depth,
741 ) -> fidl::Result<()> {
742 decoder.debug_check_bounds::<Self>(offset);
743 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
745 let padval = unsafe { (ptr as *const u64).read_unaligned() };
746 let mask = 0xffffffff00000000u64;
747 let maskedval = padval & mask;
748 if maskedval != 0 {
749 return Err(fidl::Error::NonZeroPadding {
750 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
751 });
752 }
753 fidl::decode!(CompatibilityState, D, &mut self.state, decoder, offset + 0, _depth)?;
754 fidl::decode!(u64, D, &mut self.platform_abi, decoder, offset + 8, _depth)?;
755 fidl::decode!(
756 fidl::encoding::UnboundedString,
757 D,
758 &mut self.message,
759 decoder,
760 offset + 16,
761 _depth
762 )?;
763 Ok(())
764 }
765 }
766
767 impl fidl::encoding::ValueTypeMarker for RemoteControlEchoStringRequest {
768 type Borrowed<'a> = &'a Self;
769 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
770 value
771 }
772 }
773
774 unsafe impl fidl::encoding::TypeMarker for RemoteControlEchoStringRequest {
775 type Owned = Self;
776
777 #[inline(always)]
778 fn inline_align(_context: fidl::encoding::Context) -> usize {
779 8
780 }
781
782 #[inline(always)]
783 fn inline_size(_context: fidl::encoding::Context) -> usize {
784 16
785 }
786 }
787
788 unsafe impl<D: fidl::encoding::ResourceDialect>
789 fidl::encoding::Encode<RemoteControlEchoStringRequest, D>
790 for &RemoteControlEchoStringRequest
791 {
792 #[inline]
793 unsafe fn encode(
794 self,
795 encoder: &mut fidl::encoding::Encoder<'_, D>,
796 offset: usize,
797 _depth: fidl::encoding::Depth,
798 ) -> fidl::Result<()> {
799 encoder.debug_check_bounds::<RemoteControlEchoStringRequest>(offset);
800 fidl::encoding::Encode::<RemoteControlEchoStringRequest, D>::encode(
802 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
803 &self.value,
804 ),),
805 encoder,
806 offset,
807 _depth,
808 )
809 }
810 }
811 unsafe impl<
812 D: fidl::encoding::ResourceDialect,
813 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
814 > fidl::encoding::Encode<RemoteControlEchoStringRequest, D> for (T0,)
815 {
816 #[inline]
817 unsafe fn encode(
818 self,
819 encoder: &mut fidl::encoding::Encoder<'_, D>,
820 offset: usize,
821 depth: fidl::encoding::Depth,
822 ) -> fidl::Result<()> {
823 encoder.debug_check_bounds::<RemoteControlEchoStringRequest>(offset);
824 self.0.encode(encoder, offset + 0, depth)?;
828 Ok(())
829 }
830 }
831
832 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
833 for RemoteControlEchoStringRequest
834 {
835 #[inline(always)]
836 fn new_empty() -> Self {
837 Self { value: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
838 }
839
840 #[inline]
841 unsafe fn decode(
842 &mut self,
843 decoder: &mut fidl::encoding::Decoder<'_, D>,
844 offset: usize,
845 _depth: fidl::encoding::Depth,
846 ) -> fidl::Result<()> {
847 decoder.debug_check_bounds::<Self>(offset);
848 fidl::decode!(
850 fidl::encoding::BoundedString<255>,
851 D,
852 &mut self.value,
853 decoder,
854 offset + 0,
855 _depth
856 )?;
857 Ok(())
858 }
859 }
860
861 impl fidl::encoding::ValueTypeMarker for RemoteControlEchoStringResponse {
862 type Borrowed<'a> = &'a Self;
863 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
864 value
865 }
866 }
867
868 unsafe impl fidl::encoding::TypeMarker for RemoteControlEchoStringResponse {
869 type Owned = Self;
870
871 #[inline(always)]
872 fn inline_align(_context: fidl::encoding::Context) -> usize {
873 8
874 }
875
876 #[inline(always)]
877 fn inline_size(_context: fidl::encoding::Context) -> usize {
878 16
879 }
880 }
881
882 unsafe impl<D: fidl::encoding::ResourceDialect>
883 fidl::encoding::Encode<RemoteControlEchoStringResponse, D>
884 for &RemoteControlEchoStringResponse
885 {
886 #[inline]
887 unsafe fn encode(
888 self,
889 encoder: &mut fidl::encoding::Encoder<'_, D>,
890 offset: usize,
891 _depth: fidl::encoding::Depth,
892 ) -> fidl::Result<()> {
893 encoder.debug_check_bounds::<RemoteControlEchoStringResponse>(offset);
894 fidl::encoding::Encode::<RemoteControlEchoStringResponse, D>::encode(
896 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
897 &self.response,
898 ),),
899 encoder,
900 offset,
901 _depth,
902 )
903 }
904 }
905 unsafe impl<
906 D: fidl::encoding::ResourceDialect,
907 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
908 > fidl::encoding::Encode<RemoteControlEchoStringResponse, D> for (T0,)
909 {
910 #[inline]
911 unsafe fn encode(
912 self,
913 encoder: &mut fidl::encoding::Encoder<'_, D>,
914 offset: usize,
915 depth: fidl::encoding::Depth,
916 ) -> fidl::Result<()> {
917 encoder.debug_check_bounds::<RemoteControlEchoStringResponse>(offset);
918 self.0.encode(encoder, offset + 0, depth)?;
922 Ok(())
923 }
924 }
925
926 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
927 for RemoteControlEchoStringResponse
928 {
929 #[inline(always)]
930 fn new_empty() -> Self {
931 Self { response: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
932 }
933
934 #[inline]
935 unsafe fn decode(
936 &mut self,
937 decoder: &mut fidl::encoding::Decoder<'_, D>,
938 offset: usize,
939 _depth: fidl::encoding::Depth,
940 ) -> fidl::Result<()> {
941 decoder.debug_check_bounds::<Self>(offset);
942 fidl::decode!(
944 fidl::encoding::BoundedString<255>,
945 D,
946 &mut self.response,
947 decoder,
948 offset + 0,
949 _depth
950 )?;
951 Ok(())
952 }
953 }
954
955 impl fidl::encoding::ValueTypeMarker for RemoteControlGetBootTimeResponse {
956 type Borrowed<'a> = &'a Self;
957 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
958 value
959 }
960 }
961
962 unsafe impl fidl::encoding::TypeMarker for RemoteControlGetBootTimeResponse {
963 type Owned = Self;
964
965 #[inline(always)]
966 fn inline_align(_context: fidl::encoding::Context) -> usize {
967 8
968 }
969
970 #[inline(always)]
971 fn inline_size(_context: fidl::encoding::Context) -> usize {
972 8
973 }
974 #[inline(always)]
975 fn encode_is_copy() -> bool {
976 true
977 }
978
979 #[inline(always)]
980 fn decode_is_copy() -> bool {
981 true
982 }
983 }
984
985 unsafe impl<D: fidl::encoding::ResourceDialect>
986 fidl::encoding::Encode<RemoteControlGetBootTimeResponse, D>
987 for &RemoteControlGetBootTimeResponse
988 {
989 #[inline]
990 unsafe fn encode(
991 self,
992 encoder: &mut fidl::encoding::Encoder<'_, D>,
993 offset: usize,
994 _depth: fidl::encoding::Depth,
995 ) -> fidl::Result<()> {
996 encoder.debug_check_bounds::<RemoteControlGetBootTimeResponse>(offset);
997 unsafe {
998 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1000 (buf_ptr as *mut RemoteControlGetBootTimeResponse)
1001 .write_unaligned((self as *const RemoteControlGetBootTimeResponse).read());
1002 }
1005 Ok(())
1006 }
1007 }
1008 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<fidl::BootInstant, D>>
1009 fidl::encoding::Encode<RemoteControlGetBootTimeResponse, D> for (T0,)
1010 {
1011 #[inline]
1012 unsafe fn encode(
1013 self,
1014 encoder: &mut fidl::encoding::Encoder<'_, D>,
1015 offset: usize,
1016 depth: fidl::encoding::Depth,
1017 ) -> fidl::Result<()> {
1018 encoder.debug_check_bounds::<RemoteControlGetBootTimeResponse>(offset);
1019 self.0.encode(encoder, offset + 0, depth)?;
1023 Ok(())
1024 }
1025 }
1026
1027 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1028 for RemoteControlGetBootTimeResponse
1029 {
1030 #[inline(always)]
1031 fn new_empty() -> Self {
1032 Self { time: fidl::new_empty!(fidl::BootInstant, D) }
1033 }
1034
1035 #[inline]
1036 unsafe fn decode(
1037 &mut self,
1038 decoder: &mut fidl::encoding::Decoder<'_, D>,
1039 offset: usize,
1040 _depth: fidl::encoding::Depth,
1041 ) -> fidl::Result<()> {
1042 decoder.debug_check_bounds::<Self>(offset);
1043 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1044 unsafe {
1047 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1048 }
1049 Ok(())
1050 }
1051 }
1052
1053 impl fidl::encoding::ValueTypeMarker for RemoteControlGetTimeResponse {
1054 type Borrowed<'a> = &'a Self;
1055 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1056 value
1057 }
1058 }
1059
1060 unsafe impl fidl::encoding::TypeMarker for RemoteControlGetTimeResponse {
1061 type Owned = Self;
1062
1063 #[inline(always)]
1064 fn inline_align(_context: fidl::encoding::Context) -> usize {
1065 8
1066 }
1067
1068 #[inline(always)]
1069 fn inline_size(_context: fidl::encoding::Context) -> usize {
1070 8
1071 }
1072 #[inline(always)]
1073 fn encode_is_copy() -> bool {
1074 true
1075 }
1076
1077 #[inline(always)]
1078 fn decode_is_copy() -> bool {
1079 true
1080 }
1081 }
1082
1083 unsafe impl<D: fidl::encoding::ResourceDialect>
1084 fidl::encoding::Encode<RemoteControlGetTimeResponse, D> for &RemoteControlGetTimeResponse
1085 {
1086 #[inline]
1087 unsafe fn encode(
1088 self,
1089 encoder: &mut fidl::encoding::Encoder<'_, D>,
1090 offset: usize,
1091 _depth: fidl::encoding::Depth,
1092 ) -> fidl::Result<()> {
1093 encoder.debug_check_bounds::<RemoteControlGetTimeResponse>(offset);
1094 unsafe {
1095 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1097 (buf_ptr as *mut RemoteControlGetTimeResponse)
1098 .write_unaligned((self as *const RemoteControlGetTimeResponse).read());
1099 }
1102 Ok(())
1103 }
1104 }
1105 unsafe impl<
1106 D: fidl::encoding::ResourceDialect,
1107 T0: fidl::encoding::Encode<fidl::MonotonicInstant, D>,
1108 > fidl::encoding::Encode<RemoteControlGetTimeResponse, D> for (T0,)
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::<RemoteControlGetTimeResponse>(offset);
1118 self.0.encode(encoder, offset + 0, depth)?;
1122 Ok(())
1123 }
1124 }
1125
1126 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1127 for RemoteControlGetTimeResponse
1128 {
1129 #[inline(always)]
1130 fn new_empty() -> Self {
1131 Self { time: fidl::new_empty!(fidl::MonotonicInstant, D) }
1132 }
1133
1134 #[inline]
1135 unsafe fn decode(
1136 &mut self,
1137 decoder: &mut fidl::encoding::Decoder<'_, D>,
1138 offset: usize,
1139 _depth: fidl::encoding::Depth,
1140 ) -> fidl::Result<()> {
1141 decoder.debug_check_bounds::<Self>(offset);
1142 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1143 unsafe {
1146 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1147 }
1148 Ok(())
1149 }
1150 }
1151
1152 impl fidl::encoding::ValueTypeMarker for RemoteControlLogMessageRequest {
1153 type Borrowed<'a> = &'a Self;
1154 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1155 value
1156 }
1157 }
1158
1159 unsafe impl fidl::encoding::TypeMarker for RemoteControlLogMessageRequest {
1160 type Owned = Self;
1161
1162 #[inline(always)]
1163 fn inline_align(_context: fidl::encoding::Context) -> usize {
1164 8
1165 }
1166
1167 #[inline(always)]
1168 fn inline_size(_context: fidl::encoding::Context) -> usize {
1169 40
1170 }
1171 }
1172
1173 unsafe impl<D: fidl::encoding::ResourceDialect>
1174 fidl::encoding::Encode<RemoteControlLogMessageRequest, D>
1175 for &RemoteControlLogMessageRequest
1176 {
1177 #[inline]
1178 unsafe fn encode(
1179 self,
1180 encoder: &mut fidl::encoding::Encoder<'_, D>,
1181 offset: usize,
1182 _depth: fidl::encoding::Depth,
1183 ) -> fidl::Result<()> {
1184 encoder.debug_check_bounds::<RemoteControlLogMessageRequest>(offset);
1185 fidl::encoding::Encode::<RemoteControlLogMessageRequest, D>::encode(
1187 (
1188 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.tag),
1189 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.message),
1190 <fidl_fuchsia_diagnostics_types__common::Severity as fidl::encoding::ValueTypeMarker>::borrow(&self.severity),
1191 ),
1192 encoder, offset, _depth
1193 )
1194 }
1195 }
1196 unsafe impl<
1197 D: fidl::encoding::ResourceDialect,
1198 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
1199 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
1200 T2: fidl::encoding::Encode<fidl_fuchsia_diagnostics_types__common::Severity, D>,
1201 > fidl::encoding::Encode<RemoteControlLogMessageRequest, D> for (T0, T1, T2)
1202 {
1203 #[inline]
1204 unsafe fn encode(
1205 self,
1206 encoder: &mut fidl::encoding::Encoder<'_, D>,
1207 offset: usize,
1208 depth: fidl::encoding::Depth,
1209 ) -> fidl::Result<()> {
1210 encoder.debug_check_bounds::<RemoteControlLogMessageRequest>(offset);
1211 unsafe {
1214 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
1215 (ptr as *mut u64).write_unaligned(0);
1216 }
1217 self.0.encode(encoder, offset + 0, depth)?;
1219 self.1.encode(encoder, offset + 16, depth)?;
1220 self.2.encode(encoder, offset + 32, depth)?;
1221 Ok(())
1222 }
1223 }
1224
1225 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1226 for RemoteControlLogMessageRequest
1227 {
1228 #[inline(always)]
1229 fn new_empty() -> Self {
1230 Self {
1231 tag: fidl::new_empty!(fidl::encoding::UnboundedString, D),
1232 message: fidl::new_empty!(fidl::encoding::UnboundedString, D),
1233 severity: fidl::new_empty!(fidl_fuchsia_diagnostics_types__common::Severity, D),
1234 }
1235 }
1236
1237 #[inline]
1238 unsafe fn decode(
1239 &mut self,
1240 decoder: &mut fidl::encoding::Decoder<'_, D>,
1241 offset: usize,
1242 _depth: fidl::encoding::Depth,
1243 ) -> fidl::Result<()> {
1244 decoder.debug_check_bounds::<Self>(offset);
1245 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
1247 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1248 let mask = 0xffffffffffffff00u64;
1249 let maskedval = padval & mask;
1250 if maskedval != 0 {
1251 return Err(fidl::Error::NonZeroPadding {
1252 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
1253 });
1254 }
1255 fidl::decode!(
1256 fidl::encoding::UnboundedString,
1257 D,
1258 &mut self.tag,
1259 decoder,
1260 offset + 0,
1261 _depth
1262 )?;
1263 fidl::decode!(
1264 fidl::encoding::UnboundedString,
1265 D,
1266 &mut self.message,
1267 decoder,
1268 offset + 16,
1269 _depth
1270 )?;
1271 fidl::decode!(
1272 fidl_fuchsia_diagnostics_types__common::Severity,
1273 D,
1274 &mut self.severity,
1275 decoder,
1276 offset + 32,
1277 _depth
1278 )?;
1279 Ok(())
1280 }
1281 }
1282
1283 impl fidl::encoding::ValueTypeMarker for RemoteControlIdentifyHostResponse {
1284 type Borrowed<'a> = &'a Self;
1285 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286 value
1287 }
1288 }
1289
1290 unsafe impl fidl::encoding::TypeMarker for RemoteControlIdentifyHostResponse {
1291 type Owned = Self;
1292
1293 #[inline(always)]
1294 fn inline_align(_context: fidl::encoding::Context) -> usize {
1295 8
1296 }
1297
1298 #[inline(always)]
1299 fn inline_size(_context: fidl::encoding::Context) -> usize {
1300 16
1301 }
1302 }
1303
1304 unsafe impl<D: fidl::encoding::ResourceDialect>
1305 fidl::encoding::Encode<RemoteControlIdentifyHostResponse, D>
1306 for &RemoteControlIdentifyHostResponse
1307 {
1308 #[inline]
1309 unsafe fn encode(
1310 self,
1311 encoder: &mut fidl::encoding::Encoder<'_, D>,
1312 offset: usize,
1313 _depth: fidl::encoding::Depth,
1314 ) -> fidl::Result<()> {
1315 encoder.debug_check_bounds::<RemoteControlIdentifyHostResponse>(offset);
1316 fidl::encoding::Encode::<RemoteControlIdentifyHostResponse, D>::encode(
1318 (<IdentifyHostResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.response),),
1319 encoder,
1320 offset,
1321 _depth,
1322 )
1323 }
1324 }
1325 unsafe impl<
1326 D: fidl::encoding::ResourceDialect,
1327 T0: fidl::encoding::Encode<IdentifyHostResponse, D>,
1328 > fidl::encoding::Encode<RemoteControlIdentifyHostResponse, D> for (T0,)
1329 {
1330 #[inline]
1331 unsafe fn encode(
1332 self,
1333 encoder: &mut fidl::encoding::Encoder<'_, D>,
1334 offset: usize,
1335 depth: fidl::encoding::Depth,
1336 ) -> fidl::Result<()> {
1337 encoder.debug_check_bounds::<RemoteControlIdentifyHostResponse>(offset);
1338 self.0.encode(encoder, offset + 0, depth)?;
1342 Ok(())
1343 }
1344 }
1345
1346 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1347 for RemoteControlIdentifyHostResponse
1348 {
1349 #[inline(always)]
1350 fn new_empty() -> Self {
1351 Self { response: fidl::new_empty!(IdentifyHostResponse, D) }
1352 }
1353
1354 #[inline]
1355 unsafe fn decode(
1356 &mut self,
1357 decoder: &mut fidl::encoding::Decoder<'_, D>,
1358 offset: usize,
1359 _depth: fidl::encoding::Depth,
1360 ) -> fidl::Result<()> {
1361 decoder.debug_check_bounds::<Self>(offset);
1362 fidl::decode!(
1364 IdentifyHostResponse,
1365 D,
1366 &mut self.response,
1367 decoder,
1368 offset + 0,
1369 _depth
1370 )?;
1371 Ok(())
1372 }
1373 }
1374
1375 impl IdentifyHostResponse {
1376 #[inline(always)]
1377 fn max_ordinal_present(&self) -> u64 {
1378 if let Some(_) = self.boot_id {
1379 return 9;
1380 }
1381 if let Some(_) = self.addresses {
1382 return 8;
1383 }
1384 if let Some(_) = self.board_config {
1385 return 7;
1386 }
1387 if let Some(_) = self.product_config {
1388 return 6;
1389 }
1390 if let Some(_) = self.ids {
1391 return 5;
1392 }
1393 if let Some(_) = self.serial_number {
1394 return 4;
1395 }
1396 if let Some(_) = self.boot_timestamp_nanos {
1397 return 3;
1398 }
1399 if let Some(_) = self.nodename {
1400 return 2;
1401 }
1402 0
1403 }
1404 }
1405
1406 impl fidl::encoding::ValueTypeMarker for IdentifyHostResponse {
1407 type Borrowed<'a> = &'a Self;
1408 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1409 value
1410 }
1411 }
1412
1413 unsafe impl fidl::encoding::TypeMarker for IdentifyHostResponse {
1414 type Owned = Self;
1415
1416 #[inline(always)]
1417 fn inline_align(_context: fidl::encoding::Context) -> usize {
1418 8
1419 }
1420
1421 #[inline(always)]
1422 fn inline_size(_context: fidl::encoding::Context) -> usize {
1423 16
1424 }
1425 }
1426
1427 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IdentifyHostResponse, D>
1428 for &IdentifyHostResponse
1429 {
1430 unsafe fn encode(
1431 self,
1432 encoder: &mut fidl::encoding::Encoder<'_, D>,
1433 offset: usize,
1434 mut depth: fidl::encoding::Depth,
1435 ) -> fidl::Result<()> {
1436 encoder.debug_check_bounds::<IdentifyHostResponse>(offset);
1437 let max_ordinal: u64 = self.max_ordinal_present();
1439 encoder.write_num(max_ordinal, offset);
1440 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1441 if max_ordinal == 0 {
1443 return Ok(());
1444 }
1445 depth.increment()?;
1446 let envelope_size = 8;
1447 let bytes_len = max_ordinal as usize * envelope_size;
1448 #[allow(unused_variables)]
1449 let offset = encoder.out_of_line_offset(bytes_len);
1450 let mut _prev_end_offset: usize = 0;
1451 if 2 > max_ordinal {
1452 return Ok(());
1453 }
1454
1455 let cur_offset: usize = (2 - 1) * envelope_size;
1458
1459 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1461
1462 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1467 self.nodename.as_ref().map(
1468 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1469 ),
1470 encoder,
1471 offset + cur_offset,
1472 depth,
1473 )?;
1474
1475 _prev_end_offset = cur_offset + envelope_size;
1476 if 3 > max_ordinal {
1477 return Ok(());
1478 }
1479
1480 let cur_offset: usize = (3 - 1) * envelope_size;
1483
1484 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1486
1487 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1492 self.boot_timestamp_nanos
1493 .as_ref()
1494 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1495 encoder,
1496 offset + cur_offset,
1497 depth,
1498 )?;
1499
1500 _prev_end_offset = cur_offset + envelope_size;
1501 if 4 > max_ordinal {
1502 return Ok(());
1503 }
1504
1505 let cur_offset: usize = (4 - 1) * envelope_size;
1508
1509 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1511
1512 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1517 self.serial_number.as_ref().map(
1518 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1519 ),
1520 encoder,
1521 offset + cur_offset,
1522 depth,
1523 )?;
1524
1525 _prev_end_offset = cur_offset + envelope_size;
1526 if 5 > max_ordinal {
1527 return Ok(());
1528 }
1529
1530 let cur_offset: usize = (5 - 1) * envelope_size;
1533
1534 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1536
1537 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
1542 self.ids.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
1543 encoder, offset + cur_offset, depth
1544 )?;
1545
1546 _prev_end_offset = cur_offset + envelope_size;
1547 if 6 > max_ordinal {
1548 return Ok(());
1549 }
1550
1551 let cur_offset: usize = (6 - 1) * envelope_size;
1554
1555 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1557
1558 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1563 self.product_config.as_ref().map(
1564 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1565 ),
1566 encoder,
1567 offset + cur_offset,
1568 depth,
1569 )?;
1570
1571 _prev_end_offset = cur_offset + envelope_size;
1572 if 7 > max_ordinal {
1573 return Ok(());
1574 }
1575
1576 let cur_offset: usize = (7 - 1) * envelope_size;
1579
1580 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1582
1583 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1588 self.board_config.as_ref().map(
1589 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1590 ),
1591 encoder,
1592 offset + cur_offset,
1593 depth,
1594 )?;
1595
1596 _prev_end_offset = cur_offset + envelope_size;
1597 if 8 > max_ordinal {
1598 return Ok(());
1599 }
1600
1601 let cur_offset: usize = (8 - 1) * envelope_size;
1604
1605 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1607
1608 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet>, D>(
1613 self.addresses.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet> as fidl::encoding::ValueTypeMarker>::borrow),
1614 encoder, offset + cur_offset, depth
1615 )?;
1616
1617 _prev_end_offset = cur_offset + envelope_size;
1618 if 9 > max_ordinal {
1619 return Ok(());
1620 }
1621
1622 let cur_offset: usize = (9 - 1) * envelope_size;
1625
1626 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1628
1629 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1634 self.boot_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1635 encoder,
1636 offset + cur_offset,
1637 depth,
1638 )?;
1639
1640 _prev_end_offset = cur_offset + envelope_size;
1641
1642 Ok(())
1643 }
1644 }
1645
1646 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IdentifyHostResponse {
1647 #[inline(always)]
1648 fn new_empty() -> Self {
1649 Self::default()
1650 }
1651
1652 unsafe fn decode(
1653 &mut self,
1654 decoder: &mut fidl::encoding::Decoder<'_, D>,
1655 offset: usize,
1656 mut depth: fidl::encoding::Depth,
1657 ) -> fidl::Result<()> {
1658 decoder.debug_check_bounds::<Self>(offset);
1659 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1660 None => return Err(fidl::Error::NotNullable),
1661 Some(len) => len,
1662 };
1663 if len == 0 {
1665 return Ok(());
1666 };
1667 depth.increment()?;
1668 let envelope_size = 8;
1669 let bytes_len = len * envelope_size;
1670 let offset = decoder.out_of_line_offset(bytes_len)?;
1671 let mut _next_ordinal_to_read = 0;
1673 let mut next_offset = offset;
1674 let end_offset = offset + bytes_len;
1675 _next_ordinal_to_read += 1;
1676 if next_offset >= end_offset {
1677 return Ok(());
1678 }
1679
1680 while _next_ordinal_to_read < 2 {
1682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1683 _next_ordinal_to_read += 1;
1684 next_offset += envelope_size;
1685 }
1686
1687 let next_out_of_line = decoder.next_out_of_line();
1688 let handles_before = decoder.remaining_handles();
1689 if let Some((inlined, num_bytes, num_handles)) =
1690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1691 {
1692 let member_inline_size =
1693 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1694 decoder.context,
1695 );
1696 if inlined != (member_inline_size <= 4) {
1697 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1698 }
1699 let inner_offset;
1700 let mut inner_depth = depth.clone();
1701 if inlined {
1702 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1703 inner_offset = next_offset;
1704 } else {
1705 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1706 inner_depth.increment()?;
1707 }
1708 let val_ref = self
1709 .nodename
1710 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1711 fidl::decode!(
1712 fidl::encoding::BoundedString<255>,
1713 D,
1714 val_ref,
1715 decoder,
1716 inner_offset,
1717 inner_depth
1718 )?;
1719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1720 {
1721 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1722 }
1723 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1724 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1725 }
1726 }
1727
1728 next_offset += envelope_size;
1729 _next_ordinal_to_read += 1;
1730 if next_offset >= end_offset {
1731 return Ok(());
1732 }
1733
1734 while _next_ordinal_to_read < 3 {
1736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1737 _next_ordinal_to_read += 1;
1738 next_offset += envelope_size;
1739 }
1740
1741 let next_out_of_line = decoder.next_out_of_line();
1742 let handles_before = decoder.remaining_handles();
1743 if let Some((inlined, num_bytes, num_handles)) =
1744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1745 {
1746 let member_inline_size =
1747 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1748 if inlined != (member_inline_size <= 4) {
1749 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1750 }
1751 let inner_offset;
1752 let mut inner_depth = depth.clone();
1753 if inlined {
1754 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1755 inner_offset = next_offset;
1756 } else {
1757 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1758 inner_depth.increment()?;
1759 }
1760 let val_ref =
1761 self.boot_timestamp_nanos.get_or_insert_with(|| fidl::new_empty!(u64, D));
1762 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1763 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1764 {
1765 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1766 }
1767 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1768 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1769 }
1770 }
1771
1772 next_offset += envelope_size;
1773 _next_ordinal_to_read += 1;
1774 if next_offset >= end_offset {
1775 return Ok(());
1776 }
1777
1778 while _next_ordinal_to_read < 4 {
1780 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1781 _next_ordinal_to_read += 1;
1782 next_offset += envelope_size;
1783 }
1784
1785 let next_out_of_line = decoder.next_out_of_line();
1786 let handles_before = decoder.remaining_handles();
1787 if let Some((inlined, num_bytes, num_handles)) =
1788 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1789 {
1790 let member_inline_size =
1791 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1792 decoder.context,
1793 );
1794 if inlined != (member_inline_size <= 4) {
1795 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1796 }
1797 let inner_offset;
1798 let mut inner_depth = depth.clone();
1799 if inlined {
1800 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1801 inner_offset = next_offset;
1802 } else {
1803 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1804 inner_depth.increment()?;
1805 }
1806 let val_ref = self
1807 .serial_number
1808 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1809 fidl::decode!(
1810 fidl::encoding::BoundedString<255>,
1811 D,
1812 val_ref,
1813 decoder,
1814 inner_offset,
1815 inner_depth
1816 )?;
1817 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1818 {
1819 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1820 }
1821 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1822 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1823 }
1824 }
1825
1826 next_offset += envelope_size;
1827 _next_ordinal_to_read += 1;
1828 if next_offset >= end_offset {
1829 return Ok(());
1830 }
1831
1832 while _next_ordinal_to_read < 5 {
1834 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1835 _next_ordinal_to_read += 1;
1836 next_offset += envelope_size;
1837 }
1838
1839 let next_out_of_line = decoder.next_out_of_line();
1840 let handles_before = decoder.remaining_handles();
1841 if let Some((inlined, num_bytes, num_handles)) =
1842 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1843 {
1844 let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1845 if inlined != (member_inline_size <= 4) {
1846 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1847 }
1848 let inner_offset;
1849 let mut inner_depth = depth.clone();
1850 if inlined {
1851 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1852 inner_offset = next_offset;
1853 } else {
1854 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1855 inner_depth.increment()?;
1856 }
1857 let val_ref = self.ids.get_or_insert_with(|| {
1858 fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
1859 });
1860 fidl::decode!(
1861 fidl::encoding::UnboundedVector<u64>,
1862 D,
1863 val_ref,
1864 decoder,
1865 inner_offset,
1866 inner_depth
1867 )?;
1868 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1869 {
1870 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1871 }
1872 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1873 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1874 }
1875 }
1876
1877 next_offset += envelope_size;
1878 _next_ordinal_to_read += 1;
1879 if next_offset >= end_offset {
1880 return Ok(());
1881 }
1882
1883 while _next_ordinal_to_read < 6 {
1885 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1886 _next_ordinal_to_read += 1;
1887 next_offset += envelope_size;
1888 }
1889
1890 let next_out_of_line = decoder.next_out_of_line();
1891 let handles_before = decoder.remaining_handles();
1892 if let Some((inlined, num_bytes, num_handles)) =
1893 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1894 {
1895 let member_inline_size =
1896 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1897 decoder.context,
1898 );
1899 if inlined != (member_inline_size <= 4) {
1900 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1901 }
1902 let inner_offset;
1903 let mut inner_depth = depth.clone();
1904 if inlined {
1905 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1906 inner_offset = next_offset;
1907 } else {
1908 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1909 inner_depth.increment()?;
1910 }
1911 let val_ref = self
1912 .product_config
1913 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1914 fidl::decode!(
1915 fidl::encoding::BoundedString<100>,
1916 D,
1917 val_ref,
1918 decoder,
1919 inner_offset,
1920 inner_depth
1921 )?;
1922 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1923 {
1924 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1925 }
1926 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1927 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1928 }
1929 }
1930
1931 next_offset += envelope_size;
1932 _next_ordinal_to_read += 1;
1933 if next_offset >= end_offset {
1934 return Ok(());
1935 }
1936
1937 while _next_ordinal_to_read < 7 {
1939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1940 _next_ordinal_to_read += 1;
1941 next_offset += envelope_size;
1942 }
1943
1944 let next_out_of_line = decoder.next_out_of_line();
1945 let handles_before = decoder.remaining_handles();
1946 if let Some((inlined, num_bytes, num_handles)) =
1947 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1948 {
1949 let member_inline_size =
1950 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1951 decoder.context,
1952 );
1953 if inlined != (member_inline_size <= 4) {
1954 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1955 }
1956 let inner_offset;
1957 let mut inner_depth = depth.clone();
1958 if inlined {
1959 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1960 inner_offset = next_offset;
1961 } else {
1962 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1963 inner_depth.increment()?;
1964 }
1965 let val_ref = self
1966 .board_config
1967 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1968 fidl::decode!(
1969 fidl::encoding::BoundedString<100>,
1970 D,
1971 val_ref,
1972 decoder,
1973 inner_offset,
1974 inner_depth
1975 )?;
1976 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1977 {
1978 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1979 }
1980 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1981 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1982 }
1983 }
1984
1985 next_offset += envelope_size;
1986 _next_ordinal_to_read += 1;
1987 if next_offset >= end_offset {
1988 return Ok(());
1989 }
1990
1991 while _next_ordinal_to_read < 8 {
1993 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1994 _next_ordinal_to_read += 1;
1995 next_offset += envelope_size;
1996 }
1997
1998 let next_out_of_line = decoder.next_out_of_line();
1999 let handles_before = decoder.remaining_handles();
2000 if let Some((inlined, num_bytes, num_handles)) =
2001 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2002 {
2003 let member_inline_size = <fidl::encoding::UnboundedVector<
2004 fidl_fuchsia_net__common::Subnet,
2005 > as fidl::encoding::TypeMarker>::inline_size(
2006 decoder.context
2007 );
2008 if inlined != (member_inline_size <= 4) {
2009 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2010 }
2011 let inner_offset;
2012 let mut inner_depth = depth.clone();
2013 if inlined {
2014 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2015 inner_offset = next_offset;
2016 } else {
2017 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2018 inner_depth.increment()?;
2019 }
2020 let val_ref = self.addresses.get_or_insert_with(|| {
2021 fidl::new_empty!(
2022 fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet>,
2023 D
2024 )
2025 });
2026 fidl::decode!(
2027 fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet>,
2028 D,
2029 val_ref,
2030 decoder,
2031 inner_offset,
2032 inner_depth
2033 )?;
2034 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2035 {
2036 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2037 }
2038 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2039 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2040 }
2041 }
2042
2043 next_offset += envelope_size;
2044 _next_ordinal_to_read += 1;
2045 if next_offset >= end_offset {
2046 return Ok(());
2047 }
2048
2049 while _next_ordinal_to_read < 9 {
2051 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2052 _next_ordinal_to_read += 1;
2053 next_offset += envelope_size;
2054 }
2055
2056 let next_out_of_line = decoder.next_out_of_line();
2057 let handles_before = decoder.remaining_handles();
2058 if let Some((inlined, num_bytes, num_handles)) =
2059 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2060 {
2061 let member_inline_size =
2062 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2063 if inlined != (member_inline_size <= 4) {
2064 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2065 }
2066 let inner_offset;
2067 let mut inner_depth = depth.clone();
2068 if inlined {
2069 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2070 inner_offset = next_offset;
2071 } else {
2072 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2073 inner_depth.increment()?;
2074 }
2075 let val_ref = self.boot_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
2076 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2077 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2078 {
2079 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2080 }
2081 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2082 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2083 }
2084 }
2085
2086 next_offset += envelope_size;
2087
2088 while next_offset < end_offset {
2090 _next_ordinal_to_read += 1;
2091 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2092 next_offset += envelope_size;
2093 }
2094
2095 Ok(())
2096 }
2097 }
2098}