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