fidl_fuchsia_net_test_realm__common/
fidl_fuchsia_net_test_realm__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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_UDP_POLL_LENGTH: u16 = 1024;
12
13/// Standard error codes for the `Controller` protocol.
14#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
15#[repr(u32)]
16pub enum Error {
17    /// The controller encountered an unspecified error while performing the
18    /// desired operation.
19    Internal = 1,
20    /// A hermetic network realm was expected to exist, but no such realm was
21    /// found to be running.
22    HermeticNetworkRealmNotRunning = 2,
23    /// A network interface was expected to exist, but was not found.
24    InterfaceNotFound = 3,
25    /// A stub was expected to exist, but was not found.
26    StubNotRunning = 4,
27    /// At least one argument was not valid.
28    InvalidArguments = 5,
29    /// The relevant component was not found.
30    ComponentNotFound = 6,
31    /// The operation could not be performed within the specified timeout.
32    TimeoutExceeded = 7,
33    /// A ping unexpectedly failed.
34    PingFailed = 8,
35    /// The requested address is not available.
36    AddressNotAvailable = 9,
37    /// The requested address is in use.
38    AddressInUse = 10,
39    /// The resource already exists.
40    AlreadyExists = 11,
41    /// The target address is unreachable (e.g. no route exists to it).
42    AddressUnreachable = 12,
43    /// A DHCPv6 client was expected to be running, but none was found.
44    Dhcpv6ClientNotRunning = 13,
45    /// A DHCPv4 client was expected to be running, but none was found.
46    Dhcpv4ClientNotRunning = 14,
47    /// Failed to shutdown the DHCPv4 client.
48    Dhcpv4ClientShutdownFailed = 15,
49}
50
51impl Error {
52    #[inline]
53    pub fn from_primitive(prim: u32) -> Option<Self> {
54        match prim {
55            1 => Some(Self::Internal),
56            2 => Some(Self::HermeticNetworkRealmNotRunning),
57            3 => Some(Self::InterfaceNotFound),
58            4 => Some(Self::StubNotRunning),
59            5 => Some(Self::InvalidArguments),
60            6 => Some(Self::ComponentNotFound),
61            7 => Some(Self::TimeoutExceeded),
62            8 => Some(Self::PingFailed),
63            9 => Some(Self::AddressNotAvailable),
64            10 => Some(Self::AddressInUse),
65            11 => Some(Self::AlreadyExists),
66            12 => Some(Self::AddressUnreachable),
67            13 => Some(Self::Dhcpv6ClientNotRunning),
68            14 => Some(Self::Dhcpv4ClientNotRunning),
69            15 => Some(Self::Dhcpv4ClientShutdownFailed),
70            _ => None,
71        }
72    }
73
74    #[inline]
75    pub const fn into_primitive(self) -> u32 {
76        self as u32
77    }
78}
79
80#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
81#[repr(u32)]
82pub enum Netstack {
83    /// Netstack2.
84    V2 = 1,
85    /// Netstack3.
86    V3 = 2,
87}
88
89impl Netstack {
90    #[inline]
91    pub fn from_primitive(prim: u32) -> Option<Self> {
92        match prim {
93            1 => Some(Self::V2),
94            2 => Some(Self::V3),
95            _ => None,
96        }
97    }
98
99    #[inline]
100    pub const fn into_primitive(self) -> u32 {
101        self as u32
102    }
103}
104
105#[derive(Clone, Debug, PartialEq)]
106pub struct ControllerAddInterfaceRequest {
107    pub mac_address: fidl_fuchsia_net__common::MacAddress,
108    pub name: String,
109    pub wait_any_ip_address: bool,
110}
111
112impl fidl::Persistable for ControllerAddInterfaceRequest {}
113
114#[derive(Clone, Debug, PartialEq)]
115pub struct ControllerJoinMulticastGroupRequest {
116    pub address: fidl_fuchsia_net__common::IpAddress,
117    pub interface_id: u64,
118}
119
120impl fidl::Persistable for ControllerJoinMulticastGroupRequest {}
121
122#[derive(Clone, Debug, PartialEq)]
123pub struct ControllerLeaveMulticastGroupRequest {
124    pub address: fidl_fuchsia_net__common::IpAddress,
125    pub interface_id: u64,
126}
127
128impl fidl::Persistable for ControllerLeaveMulticastGroupRequest {}
129
130#[derive(Clone, Debug, PartialEq)]
131pub struct ControllerPingRequest {
132    pub target: fidl_fuchsia_net__common::IpAddress,
133    pub payload_length: u16,
134    pub interface_name: Option<String>,
135    pub timeout: i64,
136}
137
138impl fidl::Persistable for ControllerPingRequest {}
139
140#[derive(Clone, Debug, PartialEq)]
141pub struct ControllerPollUdpRequest {
142    pub target: fidl_fuchsia_net__common::SocketAddress,
143    pub payload: Vec<u8>,
144    pub timeout: i64,
145    pub num_retries: u16,
146}
147
148impl fidl::Persistable for ControllerPollUdpRequest {}
149
150#[derive(Clone, Debug, PartialEq)]
151pub struct ControllerStartDhcpv6ClientRequest {
152    pub params: fidl_fuchsia_net_dhcpv6__common::NewClientParams,
153}
154
155impl fidl::Persistable for ControllerStartDhcpv6ClientRequest {}
156
157#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
158pub struct ControllerStartHermeticNetworkRealmRequest {
159    pub netstack: Netstack,
160}
161
162impl fidl::Persistable for ControllerStartHermeticNetworkRealmRequest {}
163
164#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
165pub struct ControllerStartStubRequest {
166    pub component_url: String,
167}
168
169impl fidl::Persistable for ControllerStartStubRequest {}
170
171#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
172pub struct ControllerPollUdpResponse {
173    pub payload: Vec<u8>,
174}
175
176impl fidl::Persistable for ControllerPollUdpResponse {}
177
178#[derive(Clone, Debug, Default, PartialEq)]
179pub struct ControllerStartOutOfStackDhcpv4ClientRequest {
180    pub interface_id: Option<u64>,
181    #[doc(hidden)]
182    pub __source_breaking: fidl::marker::SourceBreaking,
183}
184
185impl fidl::Persistable for ControllerStartOutOfStackDhcpv4ClientRequest {}
186
187#[derive(Clone, Debug, Default, PartialEq)]
188pub struct ControllerStopOutOfStackDhcpv4ClientRequest {
189    pub interface_id: Option<u64>,
190    #[doc(hidden)]
191    pub __source_breaking: fidl::marker::SourceBreaking,
192}
193
194impl fidl::Persistable for ControllerStopOutOfStackDhcpv4ClientRequest {}
195
196mod internal {
197    use super::*;
198    unsafe impl fidl::encoding::TypeMarker for Error {
199        type Owned = Self;
200
201        #[inline(always)]
202        fn inline_align(_context: fidl::encoding::Context) -> usize {
203            std::mem::align_of::<u32>()
204        }
205
206        #[inline(always)]
207        fn inline_size(_context: fidl::encoding::Context) -> usize {
208            std::mem::size_of::<u32>()
209        }
210
211        #[inline(always)]
212        fn encode_is_copy() -> bool {
213            true
214        }
215
216        #[inline(always)]
217        fn decode_is_copy() -> bool {
218            false
219        }
220    }
221
222    impl fidl::encoding::ValueTypeMarker for Error {
223        type Borrowed<'a> = Self;
224        #[inline(always)]
225        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
226            *value
227        }
228    }
229
230    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
231        #[inline]
232        unsafe fn encode(
233            self,
234            encoder: &mut fidl::encoding::Encoder<'_, D>,
235            offset: usize,
236            _depth: fidl::encoding::Depth,
237        ) -> fidl::Result<()> {
238            encoder.debug_check_bounds::<Self>(offset);
239            encoder.write_num(self.into_primitive(), offset);
240            Ok(())
241        }
242    }
243
244    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
245        #[inline(always)]
246        fn new_empty() -> Self {
247            Self::Internal
248        }
249
250        #[inline]
251        unsafe fn decode(
252            &mut self,
253            decoder: &mut fidl::encoding::Decoder<'_, D>,
254            offset: usize,
255            _depth: fidl::encoding::Depth,
256        ) -> fidl::Result<()> {
257            decoder.debug_check_bounds::<Self>(offset);
258            let prim = decoder.read_num::<u32>(offset);
259
260            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
261            Ok(())
262        }
263    }
264    unsafe impl fidl::encoding::TypeMarker for Netstack {
265        type Owned = Self;
266
267        #[inline(always)]
268        fn inline_align(_context: fidl::encoding::Context) -> usize {
269            std::mem::align_of::<u32>()
270        }
271
272        #[inline(always)]
273        fn inline_size(_context: fidl::encoding::Context) -> usize {
274            std::mem::size_of::<u32>()
275        }
276
277        #[inline(always)]
278        fn encode_is_copy() -> bool {
279            true
280        }
281
282        #[inline(always)]
283        fn decode_is_copy() -> bool {
284            false
285        }
286    }
287
288    impl fidl::encoding::ValueTypeMarker for Netstack {
289        type Borrowed<'a> = Self;
290        #[inline(always)]
291        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
292            *value
293        }
294    }
295
296    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Netstack {
297        #[inline]
298        unsafe fn encode(
299            self,
300            encoder: &mut fidl::encoding::Encoder<'_, D>,
301            offset: usize,
302            _depth: fidl::encoding::Depth,
303        ) -> fidl::Result<()> {
304            encoder.debug_check_bounds::<Self>(offset);
305            encoder.write_num(self.into_primitive(), offset);
306            Ok(())
307        }
308    }
309
310    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Netstack {
311        #[inline(always)]
312        fn new_empty() -> Self {
313            Self::V2
314        }
315
316        #[inline]
317        unsafe fn decode(
318            &mut self,
319            decoder: &mut fidl::encoding::Decoder<'_, D>,
320            offset: usize,
321            _depth: fidl::encoding::Depth,
322        ) -> fidl::Result<()> {
323            decoder.debug_check_bounds::<Self>(offset);
324            let prim = decoder.read_num::<u32>(offset);
325
326            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
327            Ok(())
328        }
329    }
330
331    impl fidl::encoding::ValueTypeMarker for ControllerAddInterfaceRequest {
332        type Borrowed<'a> = &'a Self;
333        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
334            value
335        }
336    }
337
338    unsafe impl fidl::encoding::TypeMarker for ControllerAddInterfaceRequest {
339        type Owned = Self;
340
341        #[inline(always)]
342        fn inline_align(_context: fidl::encoding::Context) -> usize {
343            8
344        }
345
346        #[inline(always)]
347        fn inline_size(_context: fidl::encoding::Context) -> usize {
348            32
349        }
350    }
351
352    unsafe impl<D: fidl::encoding::ResourceDialect>
353        fidl::encoding::Encode<ControllerAddInterfaceRequest, D>
354        for &ControllerAddInterfaceRequest
355    {
356        #[inline]
357        unsafe fn encode(
358            self,
359            encoder: &mut fidl::encoding::Encoder<'_, D>,
360            offset: usize,
361            _depth: fidl::encoding::Depth,
362        ) -> fidl::Result<()> {
363            encoder.debug_check_bounds::<ControllerAddInterfaceRequest>(offset);
364            // Delegate to tuple encoding.
365            fidl::encoding::Encode::<ControllerAddInterfaceRequest, D>::encode(
366                (
367                    <fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.mac_address),
368                    <fidl::encoding::BoundedString<15> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
369                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.wait_any_ip_address),
370                ),
371                encoder, offset, _depth
372            )
373        }
374    }
375    unsafe impl<
376            D: fidl::encoding::ResourceDialect,
377            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::MacAddress, D>,
378            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<15>, D>,
379            T2: fidl::encoding::Encode<bool, D>,
380        > fidl::encoding::Encode<ControllerAddInterfaceRequest, D> for (T0, T1, T2)
381    {
382        #[inline]
383        unsafe fn encode(
384            self,
385            encoder: &mut fidl::encoding::Encoder<'_, D>,
386            offset: usize,
387            depth: fidl::encoding::Depth,
388        ) -> fidl::Result<()> {
389            encoder.debug_check_bounds::<ControllerAddInterfaceRequest>(offset);
390            // Zero out padding regions. There's no need to apply masks
391            // because the unmasked parts will be overwritten by fields.
392            unsafe {
393                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
394                (ptr as *mut u64).write_unaligned(0);
395            }
396            unsafe {
397                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
398                (ptr as *mut u64).write_unaligned(0);
399            }
400            // Write the fields.
401            self.0.encode(encoder, offset + 0, depth)?;
402            self.1.encode(encoder, offset + 8, depth)?;
403            self.2.encode(encoder, offset + 24, depth)?;
404            Ok(())
405        }
406    }
407
408    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
409        for ControllerAddInterfaceRequest
410    {
411        #[inline(always)]
412        fn new_empty() -> Self {
413            Self {
414                mac_address: fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D),
415                name: fidl::new_empty!(fidl::encoding::BoundedString<15>, D),
416                wait_any_ip_address: fidl::new_empty!(bool, D),
417            }
418        }
419
420        #[inline]
421        unsafe fn decode(
422            &mut self,
423            decoder: &mut fidl::encoding::Decoder<'_, D>,
424            offset: usize,
425            _depth: fidl::encoding::Depth,
426        ) -> fidl::Result<()> {
427            decoder.debug_check_bounds::<Self>(offset);
428            // Verify that padding bytes are zero.
429            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
430            let padval = unsafe { (ptr as *const u64).read_unaligned() };
431            let mask = 0xffff000000000000u64;
432            let maskedval = padval & mask;
433            if maskedval != 0 {
434                return Err(fidl::Error::NonZeroPadding {
435                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
436                });
437            }
438            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
439            let padval = unsafe { (ptr as *const u64).read_unaligned() };
440            let mask = 0xffffffffffffff00u64;
441            let maskedval = padval & mask;
442            if maskedval != 0 {
443                return Err(fidl::Error::NonZeroPadding {
444                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
445                });
446            }
447            fidl::decode!(
448                fidl_fuchsia_net__common::MacAddress,
449                D,
450                &mut self.mac_address,
451                decoder,
452                offset + 0,
453                _depth
454            )?;
455            fidl::decode!(
456                fidl::encoding::BoundedString<15>,
457                D,
458                &mut self.name,
459                decoder,
460                offset + 8,
461                _depth
462            )?;
463            fidl::decode!(bool, D, &mut self.wait_any_ip_address, decoder, offset + 24, _depth)?;
464            Ok(())
465        }
466    }
467
468    impl fidl::encoding::ValueTypeMarker for ControllerJoinMulticastGroupRequest {
469        type Borrowed<'a> = &'a Self;
470        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
471            value
472        }
473    }
474
475    unsafe impl fidl::encoding::TypeMarker for ControllerJoinMulticastGroupRequest {
476        type Owned = Self;
477
478        #[inline(always)]
479        fn inline_align(_context: fidl::encoding::Context) -> usize {
480            8
481        }
482
483        #[inline(always)]
484        fn inline_size(_context: fidl::encoding::Context) -> usize {
485            24
486        }
487    }
488
489    unsafe impl<D: fidl::encoding::ResourceDialect>
490        fidl::encoding::Encode<ControllerJoinMulticastGroupRequest, D>
491        for &ControllerJoinMulticastGroupRequest
492    {
493        #[inline]
494        unsafe fn encode(
495            self,
496            encoder: &mut fidl::encoding::Encoder<'_, D>,
497            offset: usize,
498            _depth: fidl::encoding::Depth,
499        ) -> fidl::Result<()> {
500            encoder.debug_check_bounds::<ControllerJoinMulticastGroupRequest>(offset);
501            // Delegate to tuple encoding.
502            fidl::encoding::Encode::<ControllerJoinMulticastGroupRequest, D>::encode(
503                (
504                    <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
505                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_id),
506                ),
507                encoder, offset, _depth
508            )
509        }
510    }
511    unsafe impl<
512            D: fidl::encoding::ResourceDialect,
513            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
514            T1: fidl::encoding::Encode<u64, D>,
515        > fidl::encoding::Encode<ControllerJoinMulticastGroupRequest, D> for (T0, T1)
516    {
517        #[inline]
518        unsafe fn encode(
519            self,
520            encoder: &mut fidl::encoding::Encoder<'_, D>,
521            offset: usize,
522            depth: fidl::encoding::Depth,
523        ) -> fidl::Result<()> {
524            encoder.debug_check_bounds::<ControllerJoinMulticastGroupRequest>(offset);
525            // Zero out padding regions. There's no need to apply masks
526            // because the unmasked parts will be overwritten by fields.
527            // Write the fields.
528            self.0.encode(encoder, offset + 0, depth)?;
529            self.1.encode(encoder, offset + 16, depth)?;
530            Ok(())
531        }
532    }
533
534    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
535        for ControllerJoinMulticastGroupRequest
536    {
537        #[inline(always)]
538        fn new_empty() -> Self {
539            Self {
540                address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
541                interface_id: fidl::new_empty!(u64, D),
542            }
543        }
544
545        #[inline]
546        unsafe fn decode(
547            &mut self,
548            decoder: &mut fidl::encoding::Decoder<'_, D>,
549            offset: usize,
550            _depth: fidl::encoding::Depth,
551        ) -> fidl::Result<()> {
552            decoder.debug_check_bounds::<Self>(offset);
553            // Verify that padding bytes are zero.
554            fidl::decode!(
555                fidl_fuchsia_net__common::IpAddress,
556                D,
557                &mut self.address,
558                decoder,
559                offset + 0,
560                _depth
561            )?;
562            fidl::decode!(u64, D, &mut self.interface_id, decoder, offset + 16, _depth)?;
563            Ok(())
564        }
565    }
566
567    impl fidl::encoding::ValueTypeMarker for ControllerLeaveMulticastGroupRequest {
568        type Borrowed<'a> = &'a Self;
569        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
570            value
571        }
572    }
573
574    unsafe impl fidl::encoding::TypeMarker for ControllerLeaveMulticastGroupRequest {
575        type Owned = Self;
576
577        #[inline(always)]
578        fn inline_align(_context: fidl::encoding::Context) -> usize {
579            8
580        }
581
582        #[inline(always)]
583        fn inline_size(_context: fidl::encoding::Context) -> usize {
584            24
585        }
586    }
587
588    unsafe impl<D: fidl::encoding::ResourceDialect>
589        fidl::encoding::Encode<ControllerLeaveMulticastGroupRequest, D>
590        for &ControllerLeaveMulticastGroupRequest
591    {
592        #[inline]
593        unsafe fn encode(
594            self,
595            encoder: &mut fidl::encoding::Encoder<'_, D>,
596            offset: usize,
597            _depth: fidl::encoding::Depth,
598        ) -> fidl::Result<()> {
599            encoder.debug_check_bounds::<ControllerLeaveMulticastGroupRequest>(offset);
600            // Delegate to tuple encoding.
601            fidl::encoding::Encode::<ControllerLeaveMulticastGroupRequest, D>::encode(
602                (
603                    <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
604                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_id),
605                ),
606                encoder, offset, _depth
607            )
608        }
609    }
610    unsafe impl<
611            D: fidl::encoding::ResourceDialect,
612            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
613            T1: fidl::encoding::Encode<u64, D>,
614        > fidl::encoding::Encode<ControllerLeaveMulticastGroupRequest, D> for (T0, T1)
615    {
616        #[inline]
617        unsafe fn encode(
618            self,
619            encoder: &mut fidl::encoding::Encoder<'_, D>,
620            offset: usize,
621            depth: fidl::encoding::Depth,
622        ) -> fidl::Result<()> {
623            encoder.debug_check_bounds::<ControllerLeaveMulticastGroupRequest>(offset);
624            // Zero out padding regions. There's no need to apply masks
625            // because the unmasked parts will be overwritten by fields.
626            // Write the fields.
627            self.0.encode(encoder, offset + 0, depth)?;
628            self.1.encode(encoder, offset + 16, depth)?;
629            Ok(())
630        }
631    }
632
633    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
634        for ControllerLeaveMulticastGroupRequest
635    {
636        #[inline(always)]
637        fn new_empty() -> Self {
638            Self {
639                address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
640                interface_id: fidl::new_empty!(u64, D),
641            }
642        }
643
644        #[inline]
645        unsafe fn decode(
646            &mut self,
647            decoder: &mut fidl::encoding::Decoder<'_, D>,
648            offset: usize,
649            _depth: fidl::encoding::Depth,
650        ) -> fidl::Result<()> {
651            decoder.debug_check_bounds::<Self>(offset);
652            // Verify that padding bytes are zero.
653            fidl::decode!(
654                fidl_fuchsia_net__common::IpAddress,
655                D,
656                &mut self.address,
657                decoder,
658                offset + 0,
659                _depth
660            )?;
661            fidl::decode!(u64, D, &mut self.interface_id, decoder, offset + 16, _depth)?;
662            Ok(())
663        }
664    }
665
666    impl fidl::encoding::ValueTypeMarker for ControllerPingRequest {
667        type Borrowed<'a> = &'a Self;
668        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
669            value
670        }
671    }
672
673    unsafe impl fidl::encoding::TypeMarker for ControllerPingRequest {
674        type Owned = Self;
675
676        #[inline(always)]
677        fn inline_align(_context: fidl::encoding::Context) -> usize {
678            8
679        }
680
681        #[inline(always)]
682        fn inline_size(_context: fidl::encoding::Context) -> usize {
683            48
684        }
685    }
686
687    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControllerPingRequest, D>
688        for &ControllerPingRequest
689    {
690        #[inline]
691        unsafe fn encode(
692            self,
693            encoder: &mut fidl::encoding::Encoder<'_, D>,
694            offset: usize,
695            _depth: fidl::encoding::Depth,
696        ) -> fidl::Result<()> {
697            encoder.debug_check_bounds::<ControllerPingRequest>(offset);
698            // Delegate to tuple encoding.
699            fidl::encoding::Encode::<ControllerPingRequest, D>::encode(
700                (
701                    <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.target),
702                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.payload_length),
703                    <fidl::encoding::Optional<fidl::encoding::BoundedString<15>> as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_name),
704                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
705                ),
706                encoder, offset, _depth
707            )
708        }
709    }
710    unsafe impl<
711            D: fidl::encoding::ResourceDialect,
712            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
713            T1: fidl::encoding::Encode<u16, D>,
714            T2: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<15>>, D>,
715            T3: fidl::encoding::Encode<i64, D>,
716        > fidl::encoding::Encode<ControllerPingRequest, D> for (T0, T1, T2, T3)
717    {
718        #[inline]
719        unsafe fn encode(
720            self,
721            encoder: &mut fidl::encoding::Encoder<'_, D>,
722            offset: usize,
723            depth: fidl::encoding::Depth,
724        ) -> fidl::Result<()> {
725            encoder.debug_check_bounds::<ControllerPingRequest>(offset);
726            // Zero out padding regions. There's no need to apply masks
727            // because the unmasked parts will be overwritten by fields.
728            unsafe {
729                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
730                (ptr as *mut u64).write_unaligned(0);
731            }
732            // Write the fields.
733            self.0.encode(encoder, offset + 0, depth)?;
734            self.1.encode(encoder, offset + 16, depth)?;
735            self.2.encode(encoder, offset + 24, depth)?;
736            self.3.encode(encoder, offset + 40, depth)?;
737            Ok(())
738        }
739    }
740
741    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControllerPingRequest {
742        #[inline(always)]
743        fn new_empty() -> Self {
744            Self {
745                target: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
746                payload_length: fidl::new_empty!(u16, D),
747                interface_name: fidl::new_empty!(
748                    fidl::encoding::Optional<fidl::encoding::BoundedString<15>>,
749                    D
750                ),
751                timeout: fidl::new_empty!(i64, D),
752            }
753        }
754
755        #[inline]
756        unsafe fn decode(
757            &mut self,
758            decoder: &mut fidl::encoding::Decoder<'_, D>,
759            offset: usize,
760            _depth: fidl::encoding::Depth,
761        ) -> fidl::Result<()> {
762            decoder.debug_check_bounds::<Self>(offset);
763            // Verify that padding bytes are zero.
764            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
765            let padval = unsafe { (ptr as *const u64).read_unaligned() };
766            let mask = 0xffffffffffff0000u64;
767            let maskedval = padval & mask;
768            if maskedval != 0 {
769                return Err(fidl::Error::NonZeroPadding {
770                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
771                });
772            }
773            fidl::decode!(
774                fidl_fuchsia_net__common::IpAddress,
775                D,
776                &mut self.target,
777                decoder,
778                offset + 0,
779                _depth
780            )?;
781            fidl::decode!(u16, D, &mut self.payload_length, decoder, offset + 16, _depth)?;
782            fidl::decode!(
783                fidl::encoding::Optional<fidl::encoding::BoundedString<15>>,
784                D,
785                &mut self.interface_name,
786                decoder,
787                offset + 24,
788                _depth
789            )?;
790            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 40, _depth)?;
791            Ok(())
792        }
793    }
794
795    impl fidl::encoding::ValueTypeMarker for ControllerPollUdpRequest {
796        type Borrowed<'a> = &'a Self;
797        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
798            value
799        }
800    }
801
802    unsafe impl fidl::encoding::TypeMarker for ControllerPollUdpRequest {
803        type Owned = Self;
804
805        #[inline(always)]
806        fn inline_align(_context: fidl::encoding::Context) -> usize {
807            8
808        }
809
810        #[inline(always)]
811        fn inline_size(_context: fidl::encoding::Context) -> usize {
812            48
813        }
814    }
815
816    unsafe impl<D: fidl::encoding::ResourceDialect>
817        fidl::encoding::Encode<ControllerPollUdpRequest, D> for &ControllerPollUdpRequest
818    {
819        #[inline]
820        unsafe fn encode(
821            self,
822            encoder: &mut fidl::encoding::Encoder<'_, D>,
823            offset: usize,
824            _depth: fidl::encoding::Depth,
825        ) -> fidl::Result<()> {
826            encoder.debug_check_bounds::<ControllerPollUdpRequest>(offset);
827            // Delegate to tuple encoding.
828            fidl::encoding::Encode::<ControllerPollUdpRequest, D>::encode(
829                (
830                    <fidl_fuchsia_net__common::SocketAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.target),
831                    <fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.payload),
832                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
833                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_retries),
834                ),
835                encoder, offset, _depth
836            )
837        }
838    }
839    unsafe impl<
840            D: fidl::encoding::ResourceDialect,
841            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::SocketAddress, D>,
842            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 1024>, D>,
843            T2: fidl::encoding::Encode<i64, D>,
844            T3: fidl::encoding::Encode<u16, D>,
845        > fidl::encoding::Encode<ControllerPollUdpRequest, D> for (T0, T1, T2, T3)
846    {
847        #[inline]
848        unsafe fn encode(
849            self,
850            encoder: &mut fidl::encoding::Encoder<'_, D>,
851            offset: usize,
852            depth: fidl::encoding::Depth,
853        ) -> fidl::Result<()> {
854            encoder.debug_check_bounds::<ControllerPollUdpRequest>(offset);
855            // Zero out padding regions. There's no need to apply masks
856            // because the unmasked parts will be overwritten by fields.
857            unsafe {
858                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
859                (ptr as *mut u64).write_unaligned(0);
860            }
861            // Write the fields.
862            self.0.encode(encoder, offset + 0, depth)?;
863            self.1.encode(encoder, offset + 16, depth)?;
864            self.2.encode(encoder, offset + 32, depth)?;
865            self.3.encode(encoder, offset + 40, depth)?;
866            Ok(())
867        }
868    }
869
870    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
871        for ControllerPollUdpRequest
872    {
873        #[inline(always)]
874        fn new_empty() -> Self {
875            Self {
876                target: fidl::new_empty!(fidl_fuchsia_net__common::SocketAddress, D),
877                payload: fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, D),
878                timeout: fidl::new_empty!(i64, D),
879                num_retries: fidl::new_empty!(u16, D),
880            }
881        }
882
883        #[inline]
884        unsafe fn decode(
885            &mut self,
886            decoder: &mut fidl::encoding::Decoder<'_, D>,
887            offset: usize,
888            _depth: fidl::encoding::Depth,
889        ) -> fidl::Result<()> {
890            decoder.debug_check_bounds::<Self>(offset);
891            // Verify that padding bytes are zero.
892            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
893            let padval = unsafe { (ptr as *const u64).read_unaligned() };
894            let mask = 0xffffffffffff0000u64;
895            let maskedval = padval & mask;
896            if maskedval != 0 {
897                return Err(fidl::Error::NonZeroPadding {
898                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
899                });
900            }
901            fidl::decode!(
902                fidl_fuchsia_net__common::SocketAddress,
903                D,
904                &mut self.target,
905                decoder,
906                offset + 0,
907                _depth
908            )?;
909            fidl::decode!(fidl::encoding::Vector<u8, 1024>, D, &mut self.payload, decoder, offset + 16, _depth)?;
910            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 32, _depth)?;
911            fidl::decode!(u16, D, &mut self.num_retries, decoder, offset + 40, _depth)?;
912            Ok(())
913        }
914    }
915
916    impl fidl::encoding::ValueTypeMarker for ControllerStartDhcpv6ClientRequest {
917        type Borrowed<'a> = &'a Self;
918        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
919            value
920        }
921    }
922
923    unsafe impl fidl::encoding::TypeMarker for ControllerStartDhcpv6ClientRequest {
924        type Owned = Self;
925
926        #[inline(always)]
927        fn inline_align(_context: fidl::encoding::Context) -> usize {
928            8
929        }
930
931        #[inline(always)]
932        fn inline_size(_context: fidl::encoding::Context) -> usize {
933            16
934        }
935    }
936
937    unsafe impl<D: fidl::encoding::ResourceDialect>
938        fidl::encoding::Encode<ControllerStartDhcpv6ClientRequest, D>
939        for &ControllerStartDhcpv6ClientRequest
940    {
941        #[inline]
942        unsafe fn encode(
943            self,
944            encoder: &mut fidl::encoding::Encoder<'_, D>,
945            offset: usize,
946            _depth: fidl::encoding::Depth,
947        ) -> fidl::Result<()> {
948            encoder.debug_check_bounds::<ControllerStartDhcpv6ClientRequest>(offset);
949            // Delegate to tuple encoding.
950            fidl::encoding::Encode::<ControllerStartDhcpv6ClientRequest, D>::encode(
951                (
952                    <fidl_fuchsia_net_dhcpv6__common::NewClientParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
953                ),
954                encoder, offset, _depth
955            )
956        }
957    }
958    unsafe impl<
959            D: fidl::encoding::ResourceDialect,
960            T0: fidl::encoding::Encode<fidl_fuchsia_net_dhcpv6__common::NewClientParams, D>,
961        > fidl::encoding::Encode<ControllerStartDhcpv6ClientRequest, D> for (T0,)
962    {
963        #[inline]
964        unsafe fn encode(
965            self,
966            encoder: &mut fidl::encoding::Encoder<'_, D>,
967            offset: usize,
968            depth: fidl::encoding::Depth,
969        ) -> fidl::Result<()> {
970            encoder.debug_check_bounds::<ControllerStartDhcpv6ClientRequest>(offset);
971            // Zero out padding regions. There's no need to apply masks
972            // because the unmasked parts will be overwritten by fields.
973            // Write the fields.
974            self.0.encode(encoder, offset + 0, depth)?;
975            Ok(())
976        }
977    }
978
979    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
980        for ControllerStartDhcpv6ClientRequest
981    {
982        #[inline(always)]
983        fn new_empty() -> Self {
984            Self { params: fidl::new_empty!(fidl_fuchsia_net_dhcpv6__common::NewClientParams, D) }
985        }
986
987        #[inline]
988        unsafe fn decode(
989            &mut self,
990            decoder: &mut fidl::encoding::Decoder<'_, D>,
991            offset: usize,
992            _depth: fidl::encoding::Depth,
993        ) -> fidl::Result<()> {
994            decoder.debug_check_bounds::<Self>(offset);
995            // Verify that padding bytes are zero.
996            fidl::decode!(
997                fidl_fuchsia_net_dhcpv6__common::NewClientParams,
998                D,
999                &mut self.params,
1000                decoder,
1001                offset + 0,
1002                _depth
1003            )?;
1004            Ok(())
1005        }
1006    }
1007
1008    impl fidl::encoding::ValueTypeMarker for ControllerStartHermeticNetworkRealmRequest {
1009        type Borrowed<'a> = &'a Self;
1010        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1011            value
1012        }
1013    }
1014
1015    unsafe impl fidl::encoding::TypeMarker for ControllerStartHermeticNetworkRealmRequest {
1016        type Owned = Self;
1017
1018        #[inline(always)]
1019        fn inline_align(_context: fidl::encoding::Context) -> usize {
1020            4
1021        }
1022
1023        #[inline(always)]
1024        fn inline_size(_context: fidl::encoding::Context) -> usize {
1025            4
1026        }
1027    }
1028
1029    unsafe impl<D: fidl::encoding::ResourceDialect>
1030        fidl::encoding::Encode<ControllerStartHermeticNetworkRealmRequest, D>
1031        for &ControllerStartHermeticNetworkRealmRequest
1032    {
1033        #[inline]
1034        unsafe fn encode(
1035            self,
1036            encoder: &mut fidl::encoding::Encoder<'_, D>,
1037            offset: usize,
1038            _depth: fidl::encoding::Depth,
1039        ) -> fidl::Result<()> {
1040            encoder.debug_check_bounds::<ControllerStartHermeticNetworkRealmRequest>(offset);
1041            // Delegate to tuple encoding.
1042            fidl::encoding::Encode::<ControllerStartHermeticNetworkRealmRequest, D>::encode(
1043                (<Netstack as fidl::encoding::ValueTypeMarker>::borrow(&self.netstack),),
1044                encoder,
1045                offset,
1046                _depth,
1047            )
1048        }
1049    }
1050    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Netstack, D>>
1051        fidl::encoding::Encode<ControllerStartHermeticNetworkRealmRequest, D> for (T0,)
1052    {
1053        #[inline]
1054        unsafe fn encode(
1055            self,
1056            encoder: &mut fidl::encoding::Encoder<'_, D>,
1057            offset: usize,
1058            depth: fidl::encoding::Depth,
1059        ) -> fidl::Result<()> {
1060            encoder.debug_check_bounds::<ControllerStartHermeticNetworkRealmRequest>(offset);
1061            // Zero out padding regions. There's no need to apply masks
1062            // because the unmasked parts will be overwritten by fields.
1063            // Write the fields.
1064            self.0.encode(encoder, offset + 0, depth)?;
1065            Ok(())
1066        }
1067    }
1068
1069    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1070        for ControllerStartHermeticNetworkRealmRequest
1071    {
1072        #[inline(always)]
1073        fn new_empty() -> Self {
1074            Self { netstack: fidl::new_empty!(Netstack, D) }
1075        }
1076
1077        #[inline]
1078        unsafe fn decode(
1079            &mut self,
1080            decoder: &mut fidl::encoding::Decoder<'_, D>,
1081            offset: usize,
1082            _depth: fidl::encoding::Depth,
1083        ) -> fidl::Result<()> {
1084            decoder.debug_check_bounds::<Self>(offset);
1085            // Verify that padding bytes are zero.
1086            fidl::decode!(Netstack, D, &mut self.netstack, decoder, offset + 0, _depth)?;
1087            Ok(())
1088        }
1089    }
1090
1091    impl fidl::encoding::ValueTypeMarker for ControllerStartStubRequest {
1092        type Borrowed<'a> = &'a Self;
1093        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1094            value
1095        }
1096    }
1097
1098    unsafe impl fidl::encoding::TypeMarker for ControllerStartStubRequest {
1099        type Owned = Self;
1100
1101        #[inline(always)]
1102        fn inline_align(_context: fidl::encoding::Context) -> usize {
1103            8
1104        }
1105
1106        #[inline(always)]
1107        fn inline_size(_context: fidl::encoding::Context) -> usize {
1108            16
1109        }
1110    }
1111
1112    unsafe impl<D: fidl::encoding::ResourceDialect>
1113        fidl::encoding::Encode<ControllerStartStubRequest, D> for &ControllerStartStubRequest
1114    {
1115        #[inline]
1116        unsafe fn encode(
1117            self,
1118            encoder: &mut fidl::encoding::Encoder<'_, D>,
1119            offset: usize,
1120            _depth: fidl::encoding::Depth,
1121        ) -> fidl::Result<()> {
1122            encoder.debug_check_bounds::<ControllerStartStubRequest>(offset);
1123            // Delegate to tuple encoding.
1124            fidl::encoding::Encode::<ControllerStartStubRequest, D>::encode(
1125                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1126                    &self.component_url,
1127                ),),
1128                encoder,
1129                offset,
1130                _depth,
1131            )
1132        }
1133    }
1134    unsafe impl<
1135            D: fidl::encoding::ResourceDialect,
1136            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1137        > fidl::encoding::Encode<ControllerStartStubRequest, D> for (T0,)
1138    {
1139        #[inline]
1140        unsafe fn encode(
1141            self,
1142            encoder: &mut fidl::encoding::Encoder<'_, D>,
1143            offset: usize,
1144            depth: fidl::encoding::Depth,
1145        ) -> fidl::Result<()> {
1146            encoder.debug_check_bounds::<ControllerStartStubRequest>(offset);
1147            // Zero out padding regions. There's no need to apply masks
1148            // because the unmasked parts will be overwritten by fields.
1149            // Write the fields.
1150            self.0.encode(encoder, offset + 0, depth)?;
1151            Ok(())
1152        }
1153    }
1154
1155    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1156        for ControllerStartStubRequest
1157    {
1158        #[inline(always)]
1159        fn new_empty() -> Self {
1160            Self { component_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1161        }
1162
1163        #[inline]
1164        unsafe fn decode(
1165            &mut self,
1166            decoder: &mut fidl::encoding::Decoder<'_, D>,
1167            offset: usize,
1168            _depth: fidl::encoding::Depth,
1169        ) -> fidl::Result<()> {
1170            decoder.debug_check_bounds::<Self>(offset);
1171            // Verify that padding bytes are zero.
1172            fidl::decode!(
1173                fidl::encoding::BoundedString<4096>,
1174                D,
1175                &mut self.component_url,
1176                decoder,
1177                offset + 0,
1178                _depth
1179            )?;
1180            Ok(())
1181        }
1182    }
1183
1184    impl fidl::encoding::ValueTypeMarker for ControllerPollUdpResponse {
1185        type Borrowed<'a> = &'a Self;
1186        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1187            value
1188        }
1189    }
1190
1191    unsafe impl fidl::encoding::TypeMarker for ControllerPollUdpResponse {
1192        type Owned = Self;
1193
1194        #[inline(always)]
1195        fn inline_align(_context: fidl::encoding::Context) -> usize {
1196            8
1197        }
1198
1199        #[inline(always)]
1200        fn inline_size(_context: fidl::encoding::Context) -> usize {
1201            16
1202        }
1203    }
1204
1205    unsafe impl<D: fidl::encoding::ResourceDialect>
1206        fidl::encoding::Encode<ControllerPollUdpResponse, D> for &ControllerPollUdpResponse
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::<ControllerPollUdpResponse>(offset);
1216            // Delegate to tuple encoding.
1217            fidl::encoding::Encode::<ControllerPollUdpResponse, D>::encode(
1218                (<fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(
1219                    &self.payload,
1220                ),),
1221                encoder,
1222                offset,
1223                _depth,
1224            )
1225        }
1226    }
1227    unsafe impl<
1228            D: fidl::encoding::ResourceDialect,
1229            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 1024>, D>,
1230        > fidl::encoding::Encode<ControllerPollUdpResponse, D> for (T0,)
1231    {
1232        #[inline]
1233        unsafe fn encode(
1234            self,
1235            encoder: &mut fidl::encoding::Encoder<'_, D>,
1236            offset: usize,
1237            depth: fidl::encoding::Depth,
1238        ) -> fidl::Result<()> {
1239            encoder.debug_check_bounds::<ControllerPollUdpResponse>(offset);
1240            // Zero out padding regions. There's no need to apply masks
1241            // because the unmasked parts will be overwritten by fields.
1242            // Write the fields.
1243            self.0.encode(encoder, offset + 0, depth)?;
1244            Ok(())
1245        }
1246    }
1247
1248    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1249        for ControllerPollUdpResponse
1250    {
1251        #[inline(always)]
1252        fn new_empty() -> Self {
1253            Self { payload: fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, D) }
1254        }
1255
1256        #[inline]
1257        unsafe fn decode(
1258            &mut self,
1259            decoder: &mut fidl::encoding::Decoder<'_, D>,
1260            offset: usize,
1261            _depth: fidl::encoding::Depth,
1262        ) -> fidl::Result<()> {
1263            decoder.debug_check_bounds::<Self>(offset);
1264            // Verify that padding bytes are zero.
1265            fidl::decode!(fidl::encoding::Vector<u8, 1024>, D, &mut self.payload, decoder, offset + 0, _depth)?;
1266            Ok(())
1267        }
1268    }
1269
1270    impl ControllerStartOutOfStackDhcpv4ClientRequest {
1271        #[inline(always)]
1272        fn max_ordinal_present(&self) -> u64 {
1273            if let Some(_) = self.interface_id {
1274                return 1;
1275            }
1276            0
1277        }
1278    }
1279
1280    impl fidl::encoding::ValueTypeMarker for ControllerStartOutOfStackDhcpv4ClientRequest {
1281        type Borrowed<'a> = &'a Self;
1282        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1283            value
1284        }
1285    }
1286
1287    unsafe impl fidl::encoding::TypeMarker for ControllerStartOutOfStackDhcpv4ClientRequest {
1288        type Owned = Self;
1289
1290        #[inline(always)]
1291        fn inline_align(_context: fidl::encoding::Context) -> usize {
1292            8
1293        }
1294
1295        #[inline(always)]
1296        fn inline_size(_context: fidl::encoding::Context) -> usize {
1297            16
1298        }
1299    }
1300
1301    unsafe impl<D: fidl::encoding::ResourceDialect>
1302        fidl::encoding::Encode<ControllerStartOutOfStackDhcpv4ClientRequest, D>
1303        for &ControllerStartOutOfStackDhcpv4ClientRequest
1304    {
1305        unsafe fn encode(
1306            self,
1307            encoder: &mut fidl::encoding::Encoder<'_, D>,
1308            offset: usize,
1309            mut depth: fidl::encoding::Depth,
1310        ) -> fidl::Result<()> {
1311            encoder.debug_check_bounds::<ControllerStartOutOfStackDhcpv4ClientRequest>(offset);
1312            // Vector header
1313            let max_ordinal: u64 = self.max_ordinal_present();
1314            encoder.write_num(max_ordinal, offset);
1315            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1316            // Calling encoder.out_of_line_offset(0) is not allowed.
1317            if max_ordinal == 0 {
1318                return Ok(());
1319            }
1320            depth.increment()?;
1321            let envelope_size = 8;
1322            let bytes_len = max_ordinal as usize * envelope_size;
1323            #[allow(unused_variables)]
1324            let offset = encoder.out_of_line_offset(bytes_len);
1325            let mut _prev_end_offset: usize = 0;
1326            if 1 > max_ordinal {
1327                return Ok(());
1328            }
1329
1330            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1331            // are envelope_size bytes.
1332            let cur_offset: usize = (1 - 1) * envelope_size;
1333
1334            // Zero reserved fields.
1335            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1336
1337            // Safety:
1338            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1339            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1340            //   envelope_size bytes, there is always sufficient room.
1341            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1342                self.interface_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1343                encoder,
1344                offset + cur_offset,
1345                depth,
1346            )?;
1347
1348            _prev_end_offset = cur_offset + envelope_size;
1349
1350            Ok(())
1351        }
1352    }
1353
1354    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1355        for ControllerStartOutOfStackDhcpv4ClientRequest
1356    {
1357        #[inline(always)]
1358        fn new_empty() -> Self {
1359            Self::default()
1360        }
1361
1362        unsafe fn decode(
1363            &mut self,
1364            decoder: &mut fidl::encoding::Decoder<'_, D>,
1365            offset: usize,
1366            mut depth: fidl::encoding::Depth,
1367        ) -> fidl::Result<()> {
1368            decoder.debug_check_bounds::<Self>(offset);
1369            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1370                None => return Err(fidl::Error::NotNullable),
1371                Some(len) => len,
1372            };
1373            // Calling decoder.out_of_line_offset(0) is not allowed.
1374            if len == 0 {
1375                return Ok(());
1376            };
1377            depth.increment()?;
1378            let envelope_size = 8;
1379            let bytes_len = len * envelope_size;
1380            let offset = decoder.out_of_line_offset(bytes_len)?;
1381            // Decode the envelope for each type.
1382            let mut _next_ordinal_to_read = 0;
1383            let mut next_offset = offset;
1384            let end_offset = offset + bytes_len;
1385            _next_ordinal_to_read += 1;
1386            if next_offset >= end_offset {
1387                return Ok(());
1388            }
1389
1390            // Decode unknown envelopes for gaps in ordinals.
1391            while _next_ordinal_to_read < 1 {
1392                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1393                _next_ordinal_to_read += 1;
1394                next_offset += envelope_size;
1395            }
1396
1397            let next_out_of_line = decoder.next_out_of_line();
1398            let handles_before = decoder.remaining_handles();
1399            if let Some((inlined, num_bytes, num_handles)) =
1400                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1401            {
1402                let member_inline_size =
1403                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1404                if inlined != (member_inline_size <= 4) {
1405                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1406                }
1407                let inner_offset;
1408                let mut inner_depth = depth.clone();
1409                if inlined {
1410                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1411                    inner_offset = next_offset;
1412                } else {
1413                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1414                    inner_depth.increment()?;
1415                }
1416                let val_ref = self.interface_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
1417                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1418                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1419                {
1420                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1421                }
1422                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1423                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1424                }
1425            }
1426
1427            next_offset += envelope_size;
1428
1429            // Decode the remaining unknown envelopes.
1430            while next_offset < end_offset {
1431                _next_ordinal_to_read += 1;
1432                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1433                next_offset += envelope_size;
1434            }
1435
1436            Ok(())
1437        }
1438    }
1439
1440    impl ControllerStopOutOfStackDhcpv4ClientRequest {
1441        #[inline(always)]
1442        fn max_ordinal_present(&self) -> u64 {
1443            if let Some(_) = self.interface_id {
1444                return 1;
1445            }
1446            0
1447        }
1448    }
1449
1450    impl fidl::encoding::ValueTypeMarker for ControllerStopOutOfStackDhcpv4ClientRequest {
1451        type Borrowed<'a> = &'a Self;
1452        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1453            value
1454        }
1455    }
1456
1457    unsafe impl fidl::encoding::TypeMarker for ControllerStopOutOfStackDhcpv4ClientRequest {
1458        type Owned = Self;
1459
1460        #[inline(always)]
1461        fn inline_align(_context: fidl::encoding::Context) -> usize {
1462            8
1463        }
1464
1465        #[inline(always)]
1466        fn inline_size(_context: fidl::encoding::Context) -> usize {
1467            16
1468        }
1469    }
1470
1471    unsafe impl<D: fidl::encoding::ResourceDialect>
1472        fidl::encoding::Encode<ControllerStopOutOfStackDhcpv4ClientRequest, D>
1473        for &ControllerStopOutOfStackDhcpv4ClientRequest
1474    {
1475        unsafe fn encode(
1476            self,
1477            encoder: &mut fidl::encoding::Encoder<'_, D>,
1478            offset: usize,
1479            mut depth: fidl::encoding::Depth,
1480        ) -> fidl::Result<()> {
1481            encoder.debug_check_bounds::<ControllerStopOutOfStackDhcpv4ClientRequest>(offset);
1482            // Vector header
1483            let max_ordinal: u64 = self.max_ordinal_present();
1484            encoder.write_num(max_ordinal, offset);
1485            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1486            // Calling encoder.out_of_line_offset(0) is not allowed.
1487            if max_ordinal == 0 {
1488                return Ok(());
1489            }
1490            depth.increment()?;
1491            let envelope_size = 8;
1492            let bytes_len = max_ordinal as usize * envelope_size;
1493            #[allow(unused_variables)]
1494            let offset = encoder.out_of_line_offset(bytes_len);
1495            let mut _prev_end_offset: usize = 0;
1496            if 1 > max_ordinal {
1497                return Ok(());
1498            }
1499
1500            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1501            // are envelope_size bytes.
1502            let cur_offset: usize = (1 - 1) * envelope_size;
1503
1504            // Zero reserved fields.
1505            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1506
1507            // Safety:
1508            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1509            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1510            //   envelope_size bytes, there is always sufficient room.
1511            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1512                self.interface_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1513                encoder,
1514                offset + cur_offset,
1515                depth,
1516            )?;
1517
1518            _prev_end_offset = cur_offset + envelope_size;
1519
1520            Ok(())
1521        }
1522    }
1523
1524    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1525        for ControllerStopOutOfStackDhcpv4ClientRequest
1526    {
1527        #[inline(always)]
1528        fn new_empty() -> Self {
1529            Self::default()
1530        }
1531
1532        unsafe fn decode(
1533            &mut self,
1534            decoder: &mut fidl::encoding::Decoder<'_, D>,
1535            offset: usize,
1536            mut depth: fidl::encoding::Depth,
1537        ) -> fidl::Result<()> {
1538            decoder.debug_check_bounds::<Self>(offset);
1539            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1540                None => return Err(fidl::Error::NotNullable),
1541                Some(len) => len,
1542            };
1543            // Calling decoder.out_of_line_offset(0) is not allowed.
1544            if len == 0 {
1545                return Ok(());
1546            };
1547            depth.increment()?;
1548            let envelope_size = 8;
1549            let bytes_len = len * envelope_size;
1550            let offset = decoder.out_of_line_offset(bytes_len)?;
1551            // Decode the envelope for each type.
1552            let mut _next_ordinal_to_read = 0;
1553            let mut next_offset = offset;
1554            let end_offset = offset + bytes_len;
1555            _next_ordinal_to_read += 1;
1556            if next_offset >= end_offset {
1557                return Ok(());
1558            }
1559
1560            // Decode unknown envelopes for gaps in ordinals.
1561            while _next_ordinal_to_read < 1 {
1562                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1563                _next_ordinal_to_read += 1;
1564                next_offset += envelope_size;
1565            }
1566
1567            let next_out_of_line = decoder.next_out_of_line();
1568            let handles_before = decoder.remaining_handles();
1569            if let Some((inlined, num_bytes, num_handles)) =
1570                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1571            {
1572                let member_inline_size =
1573                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1574                if inlined != (member_inline_size <= 4) {
1575                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1576                }
1577                let inner_offset;
1578                let mut inner_depth = depth.clone();
1579                if inlined {
1580                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1581                    inner_offset = next_offset;
1582                } else {
1583                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1584                    inner_depth.increment()?;
1585                }
1586                let val_ref = self.interface_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
1587                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1588                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1589                {
1590                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1591                }
1592                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1593                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1594                }
1595            }
1596
1597            next_offset += envelope_size;
1598
1599            // Decode the remaining unknown envelopes.
1600            while next_offset < end_offset {
1601                _next_ordinal_to_read += 1;
1602                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1603                next_offset += envelope_size;
1604            }
1605
1606            Ok(())
1607        }
1608    }
1609}
fidl_fuchsia_net_test_realm__common/fidl_fuchsia_net_test_realm__common.rs

fidl_fuchsia_net_test_realm__common/
fidl_fuchsia_net_test_realm__common.rs
