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