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(&self.address),
521                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_id),
522                ),
523                encoder, offset, _depth
524            )
525        }
526    }
527    unsafe impl<
528            D: fidl::encoding::ResourceDialect,
529            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
530            T1: fidl::encoding::Encode<u64, D>,
531        > fidl::encoding::Encode<ControllerJoinMulticastGroupRequest, D> for (T0, T1)
532    {
533        #[inline]
534        unsafe fn encode(
535            self,
536            encoder: &mut fidl::encoding::Encoder<'_, D>,
537            offset: usize,
538            depth: fidl::encoding::Depth,
539        ) -> fidl::Result<()> {
540            encoder.debug_check_bounds::<ControllerJoinMulticastGroupRequest>(offset);
541            // Zero out padding regions. There's no need to apply masks
542            // because the unmasked parts will be overwritten by fields.
543            // Write the fields.
544            self.0.encode(encoder, offset + 0, depth)?;
545            self.1.encode(encoder, offset + 16, depth)?;
546            Ok(())
547        }
548    }
549
550    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
551        for ControllerJoinMulticastGroupRequest
552    {
553        #[inline(always)]
554        fn new_empty() -> Self {
555            Self {
556                address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
557                interface_id: fidl::new_empty!(u64, D),
558            }
559        }
560
561        #[inline]
562        unsafe fn decode(
563            &mut self,
564            decoder: &mut fidl::encoding::Decoder<'_, D>,
565            offset: usize,
566            _depth: fidl::encoding::Depth,
567        ) -> fidl::Result<()> {
568            decoder.debug_check_bounds::<Self>(offset);
569            // Verify that padding bytes are zero.
570            fidl::decode!(
571                fidl_fuchsia_net__common::IpAddress,
572                D,
573                &mut self.address,
574                decoder,
575                offset + 0,
576                _depth
577            )?;
578            fidl::decode!(u64, D, &mut self.interface_id, decoder, offset + 16, _depth)?;
579            Ok(())
580        }
581    }
582
583    impl fidl::encoding::ValueTypeMarker for ControllerLeaveMulticastGroupRequest {
584        type Borrowed<'a> = &'a Self;
585        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
586            value
587        }
588    }
589
590    unsafe impl fidl::encoding::TypeMarker for ControllerLeaveMulticastGroupRequest {
591        type Owned = Self;
592
593        #[inline(always)]
594        fn inline_align(_context: fidl::encoding::Context) -> usize {
595            8
596        }
597
598        #[inline(always)]
599        fn inline_size(_context: fidl::encoding::Context) -> usize {
600            24
601        }
602    }
603
604    unsafe impl<D: fidl::encoding::ResourceDialect>
605        fidl::encoding::Encode<ControllerLeaveMulticastGroupRequest, D>
606        for &ControllerLeaveMulticastGroupRequest
607    {
608        #[inline]
609        unsafe fn encode(
610            self,
611            encoder: &mut fidl::encoding::Encoder<'_, D>,
612            offset: usize,
613            _depth: fidl::encoding::Depth,
614        ) -> fidl::Result<()> {
615            encoder.debug_check_bounds::<ControllerLeaveMulticastGroupRequest>(offset);
616            // Delegate to tuple encoding.
617            fidl::encoding::Encode::<ControllerLeaveMulticastGroupRequest, D>::encode(
618                (
619                    <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
620                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_id),
621                ),
622                encoder, offset, _depth
623            )
624        }
625    }
626    unsafe impl<
627            D: fidl::encoding::ResourceDialect,
628            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
629            T1: fidl::encoding::Encode<u64, D>,
630        > fidl::encoding::Encode<ControllerLeaveMulticastGroupRequest, D> for (T0, T1)
631    {
632        #[inline]
633        unsafe fn encode(
634            self,
635            encoder: &mut fidl::encoding::Encoder<'_, D>,
636            offset: usize,
637            depth: fidl::encoding::Depth,
638        ) -> fidl::Result<()> {
639            encoder.debug_check_bounds::<ControllerLeaveMulticastGroupRequest>(offset);
640            // Zero out padding regions. There's no need to apply masks
641            // because the unmasked parts will be overwritten by fields.
642            // Write the fields.
643            self.0.encode(encoder, offset + 0, depth)?;
644            self.1.encode(encoder, offset + 16, depth)?;
645            Ok(())
646        }
647    }
648
649    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
650        for ControllerLeaveMulticastGroupRequest
651    {
652        #[inline(always)]
653        fn new_empty() -> Self {
654            Self {
655                address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
656                interface_id: fidl::new_empty!(u64, D),
657            }
658        }
659
660        #[inline]
661        unsafe fn decode(
662            &mut self,
663            decoder: &mut fidl::encoding::Decoder<'_, D>,
664            offset: usize,
665            _depth: fidl::encoding::Depth,
666        ) -> fidl::Result<()> {
667            decoder.debug_check_bounds::<Self>(offset);
668            // Verify that padding bytes are zero.
669            fidl::decode!(
670                fidl_fuchsia_net__common::IpAddress,
671                D,
672                &mut self.address,
673                decoder,
674                offset + 0,
675                _depth
676            )?;
677            fidl::decode!(u64, D, &mut self.interface_id, decoder, offset + 16, _depth)?;
678            Ok(())
679        }
680    }
681
682    impl fidl::encoding::ValueTypeMarker for ControllerPingRequest {
683        type Borrowed<'a> = &'a Self;
684        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
685            value
686        }
687    }
688
689    unsafe impl fidl::encoding::TypeMarker for ControllerPingRequest {
690        type Owned = Self;
691
692        #[inline(always)]
693        fn inline_align(_context: fidl::encoding::Context) -> usize {
694            8
695        }
696
697        #[inline(always)]
698        fn inline_size(_context: fidl::encoding::Context) -> usize {
699            48
700        }
701    }
702
703    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControllerPingRequest, D>
704        for &ControllerPingRequest
705    {
706        #[inline]
707        unsafe fn encode(
708            self,
709            encoder: &mut fidl::encoding::Encoder<'_, D>,
710            offset: usize,
711            _depth: fidl::encoding::Depth,
712        ) -> fidl::Result<()> {
713            encoder.debug_check_bounds::<ControllerPingRequest>(offset);
714            // Delegate to tuple encoding.
715            fidl::encoding::Encode::<ControllerPingRequest, D>::encode(
716                (
717                    <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.target),
718                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.payload_length),
719                    <fidl::encoding::Optional<fidl::encoding::BoundedString<15>> as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_name),
720                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
721                ),
722                encoder, offset, _depth
723            )
724        }
725    }
726    unsafe impl<
727            D: fidl::encoding::ResourceDialect,
728            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
729            T1: fidl::encoding::Encode<u16, D>,
730            T2: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<15>>, D>,
731            T3: fidl::encoding::Encode<i64, D>,
732        > fidl::encoding::Encode<ControllerPingRequest, D> for (T0, T1, T2, T3)
733    {
734        #[inline]
735        unsafe fn encode(
736            self,
737            encoder: &mut fidl::encoding::Encoder<'_, D>,
738            offset: usize,
739            depth: fidl::encoding::Depth,
740        ) -> fidl::Result<()> {
741            encoder.debug_check_bounds::<ControllerPingRequest>(offset);
742            // Zero out padding regions. There's no need to apply masks
743            // because the unmasked parts will be overwritten by fields.
744            unsafe {
745                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
746                (ptr as *mut u64).write_unaligned(0);
747            }
748            // Write the fields.
749            self.0.encode(encoder, offset + 0, depth)?;
750            self.1.encode(encoder, offset + 16, depth)?;
751            self.2.encode(encoder, offset + 24, depth)?;
752            self.3.encode(encoder, offset + 40, depth)?;
753            Ok(())
754        }
755    }
756
757    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControllerPingRequest {
758        #[inline(always)]
759        fn new_empty() -> Self {
760            Self {
761                target: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
762                payload_length: fidl::new_empty!(u16, D),
763                interface_name: fidl::new_empty!(
764                    fidl::encoding::Optional<fidl::encoding::BoundedString<15>>,
765                    D
766                ),
767                timeout: fidl::new_empty!(i64, D),
768            }
769        }
770
771        #[inline]
772        unsafe fn decode(
773            &mut self,
774            decoder: &mut fidl::encoding::Decoder<'_, D>,
775            offset: usize,
776            _depth: fidl::encoding::Depth,
777        ) -> fidl::Result<()> {
778            decoder.debug_check_bounds::<Self>(offset);
779            // Verify that padding bytes are zero.
780            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
781            let padval = unsafe { (ptr as *const u64).read_unaligned() };
782            let mask = 0xffffffffffff0000u64;
783            let maskedval = padval & mask;
784            if maskedval != 0 {
785                return Err(fidl::Error::NonZeroPadding {
786                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
787                });
788            }
789            fidl::decode!(
790                fidl_fuchsia_net__common::IpAddress,
791                D,
792                &mut self.target,
793                decoder,
794                offset + 0,
795                _depth
796            )?;
797            fidl::decode!(u16, D, &mut self.payload_length, decoder, offset + 16, _depth)?;
798            fidl::decode!(
799                fidl::encoding::Optional<fidl::encoding::BoundedString<15>>,
800                D,
801                &mut self.interface_name,
802                decoder,
803                offset + 24,
804                _depth
805            )?;
806            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 40, _depth)?;
807            Ok(())
808        }
809    }
810
811    impl fidl::encoding::ValueTypeMarker for ControllerPollUdpRequest {
812        type Borrowed<'a> = &'a Self;
813        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
814            value
815        }
816    }
817
818    unsafe impl fidl::encoding::TypeMarker for ControllerPollUdpRequest {
819        type Owned = Self;
820
821        #[inline(always)]
822        fn inline_align(_context: fidl::encoding::Context) -> usize {
823            8
824        }
825
826        #[inline(always)]
827        fn inline_size(_context: fidl::encoding::Context) -> usize {
828            48
829        }
830    }
831
832    unsafe impl<D: fidl::encoding::ResourceDialect>
833        fidl::encoding::Encode<ControllerPollUdpRequest, D> for &ControllerPollUdpRequest
834    {
835        #[inline]
836        unsafe fn encode(
837            self,
838            encoder: &mut fidl::encoding::Encoder<'_, D>,
839            offset: usize,
840            _depth: fidl::encoding::Depth,
841        ) -> fidl::Result<()> {
842            encoder.debug_check_bounds::<ControllerPollUdpRequest>(offset);
843            // Delegate to tuple encoding.
844            fidl::encoding::Encode::<ControllerPollUdpRequest, D>::encode(
845                (
846                    <fidl_fuchsia_net__common::SocketAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.target),
847                    <fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.payload),
848                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
849                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_retries),
850                ),
851                encoder, offset, _depth
852            )
853        }
854    }
855    unsafe impl<
856            D: fidl::encoding::ResourceDialect,
857            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::SocketAddress, D>,
858            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 1024>, D>,
859            T2: fidl::encoding::Encode<i64, D>,
860            T3: fidl::encoding::Encode<u16, D>,
861        > fidl::encoding::Encode<ControllerPollUdpRequest, D> for (T0, T1, T2, T3)
862    {
863        #[inline]
864        unsafe fn encode(
865            self,
866            encoder: &mut fidl::encoding::Encoder<'_, D>,
867            offset: usize,
868            depth: fidl::encoding::Depth,
869        ) -> fidl::Result<()> {
870            encoder.debug_check_bounds::<ControllerPollUdpRequest>(offset);
871            // Zero out padding regions. There's no need to apply masks
872            // because the unmasked parts will be overwritten by fields.
873            unsafe {
874                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
875                (ptr as *mut u64).write_unaligned(0);
876            }
877            // Write the fields.
878            self.0.encode(encoder, offset + 0, depth)?;
879            self.1.encode(encoder, offset + 16, depth)?;
880            self.2.encode(encoder, offset + 32, depth)?;
881            self.3.encode(encoder, offset + 40, depth)?;
882            Ok(())
883        }
884    }
885
886    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
887        for ControllerPollUdpRequest
888    {
889        #[inline(always)]
890        fn new_empty() -> Self {
891            Self {
892                target: fidl::new_empty!(fidl_fuchsia_net__common::SocketAddress, D),
893                payload: fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, D),
894                timeout: fidl::new_empty!(i64, D),
895                num_retries: fidl::new_empty!(u16, D),
896            }
897        }
898
899        #[inline]
900        unsafe fn decode(
901            &mut self,
902            decoder: &mut fidl::encoding::Decoder<'_, D>,
903            offset: usize,
904            _depth: fidl::encoding::Depth,
905        ) -> fidl::Result<()> {
906            decoder.debug_check_bounds::<Self>(offset);
907            // Verify that padding bytes are zero.
908            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
909            let padval = unsafe { (ptr as *const u64).read_unaligned() };
910            let mask = 0xffffffffffff0000u64;
911            let maskedval = padval & mask;
912            if maskedval != 0 {
913                return Err(fidl::Error::NonZeroPadding {
914                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
915                });
916            }
917            fidl::decode!(
918                fidl_fuchsia_net__common::SocketAddress,
919                D,
920                &mut self.target,
921                decoder,
922                offset + 0,
923                _depth
924            )?;
925            fidl::decode!(fidl::encoding::Vector<u8, 1024>, D, &mut self.payload, decoder, offset + 16, _depth)?;
926            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 32, _depth)?;
927            fidl::decode!(u16, D, &mut self.num_retries, decoder, offset + 40, _depth)?;
928            Ok(())
929        }
930    }
931
932    impl fidl::encoding::ValueTypeMarker for ControllerStartDhcpv6ClientRequest {
933        type Borrowed<'a> = &'a Self;
934        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
935            value
936        }
937    }
938
939    unsafe impl fidl::encoding::TypeMarker for ControllerStartDhcpv6ClientRequest {
940        type Owned = Self;
941
942        #[inline(always)]
943        fn inline_align(_context: fidl::encoding::Context) -> usize {
944            8
945        }
946
947        #[inline(always)]
948        fn inline_size(_context: fidl::encoding::Context) -> usize {
949            16
950        }
951    }
952
953    unsafe impl<D: fidl::encoding::ResourceDialect>
954        fidl::encoding::Encode<ControllerStartDhcpv6ClientRequest, D>
955        for &ControllerStartDhcpv6ClientRequest
956    {
957        #[inline]
958        unsafe fn encode(
959            self,
960            encoder: &mut fidl::encoding::Encoder<'_, D>,
961            offset: usize,
962            _depth: fidl::encoding::Depth,
963        ) -> fidl::Result<()> {
964            encoder.debug_check_bounds::<ControllerStartDhcpv6ClientRequest>(offset);
965            // Delegate to tuple encoding.
966            fidl::encoding::Encode::<ControllerStartDhcpv6ClientRequest, D>::encode(
967                (
968                    <fidl_fuchsia_net_dhcpv6__common::NewClientParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
969                ),
970                encoder, offset, _depth
971            )
972        }
973    }
974    unsafe impl<
975            D: fidl::encoding::ResourceDialect,
976            T0: fidl::encoding::Encode<fidl_fuchsia_net_dhcpv6__common::NewClientParams, D>,
977        > fidl::encoding::Encode<ControllerStartDhcpv6ClientRequest, D> for (T0,)
978    {
979        #[inline]
980        unsafe fn encode(
981            self,
982            encoder: &mut fidl::encoding::Encoder<'_, D>,
983            offset: usize,
984            depth: fidl::encoding::Depth,
985        ) -> fidl::Result<()> {
986            encoder.debug_check_bounds::<ControllerStartDhcpv6ClientRequest>(offset);
987            // Zero out padding regions. There's no need to apply masks
988            // because the unmasked parts will be overwritten by fields.
989            // Write the fields.
990            self.0.encode(encoder, offset + 0, depth)?;
991            Ok(())
992        }
993    }
994
995    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
996        for ControllerStartDhcpv6ClientRequest
997    {
998        #[inline(always)]
999        fn new_empty() -> Self {
1000            Self { params: fidl::new_empty!(fidl_fuchsia_net_dhcpv6__common::NewClientParams, D) }
1001        }
1002
1003        #[inline]
1004        unsafe fn decode(
1005            &mut self,
1006            decoder: &mut fidl::encoding::Decoder<'_, D>,
1007            offset: usize,
1008            _depth: fidl::encoding::Depth,
1009        ) -> fidl::Result<()> {
1010            decoder.debug_check_bounds::<Self>(offset);
1011            // Verify that padding bytes are zero.
1012            fidl::decode!(
1013                fidl_fuchsia_net_dhcpv6__common::NewClientParams,
1014                D,
1015                &mut self.params,
1016                decoder,
1017                offset + 0,
1018                _depth
1019            )?;
1020            Ok(())
1021        }
1022    }
1023
1024    impl fidl::encoding::ValueTypeMarker for ControllerStartHermeticNetworkRealmRequest {
1025        type Borrowed<'a> = &'a Self;
1026        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1027            value
1028        }
1029    }
1030
1031    unsafe impl fidl::encoding::TypeMarker for ControllerStartHermeticNetworkRealmRequest {
1032        type Owned = Self;
1033
1034        #[inline(always)]
1035        fn inline_align(_context: fidl::encoding::Context) -> usize {
1036            4
1037        }
1038
1039        #[inline(always)]
1040        fn inline_size(_context: fidl::encoding::Context) -> usize {
1041            4
1042        }
1043    }
1044
1045    unsafe impl<D: fidl::encoding::ResourceDialect>
1046        fidl::encoding::Encode<ControllerStartHermeticNetworkRealmRequest, D>
1047        for &ControllerStartHermeticNetworkRealmRequest
1048    {
1049        #[inline]
1050        unsafe fn encode(
1051            self,
1052            encoder: &mut fidl::encoding::Encoder<'_, D>,
1053            offset: usize,
1054            _depth: fidl::encoding::Depth,
1055        ) -> fidl::Result<()> {
1056            encoder.debug_check_bounds::<ControllerStartHermeticNetworkRealmRequest>(offset);
1057            // Delegate to tuple encoding.
1058            fidl::encoding::Encode::<ControllerStartHermeticNetworkRealmRequest, D>::encode(
1059                (<Netstack as fidl::encoding::ValueTypeMarker>::borrow(&self.netstack),),
1060                encoder,
1061                offset,
1062                _depth,
1063            )
1064        }
1065    }
1066    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Netstack, D>>
1067        fidl::encoding::Encode<ControllerStartHermeticNetworkRealmRequest, D> for (T0,)
1068    {
1069        #[inline]
1070        unsafe fn encode(
1071            self,
1072            encoder: &mut fidl::encoding::Encoder<'_, D>,
1073            offset: usize,
1074            depth: fidl::encoding::Depth,
1075        ) -> fidl::Result<()> {
1076            encoder.debug_check_bounds::<ControllerStartHermeticNetworkRealmRequest>(offset);
1077            // Zero out padding regions. There's no need to apply masks
1078            // because the unmasked parts will be overwritten by fields.
1079            // Write the fields.
1080            self.0.encode(encoder, offset + 0, depth)?;
1081            Ok(())
1082        }
1083    }
1084
1085    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1086        for ControllerStartHermeticNetworkRealmRequest
1087    {
1088        #[inline(always)]
1089        fn new_empty() -> Self {
1090            Self { netstack: fidl::new_empty!(Netstack, D) }
1091        }
1092
1093        #[inline]
1094        unsafe fn decode(
1095            &mut self,
1096            decoder: &mut fidl::encoding::Decoder<'_, D>,
1097            offset: usize,
1098            _depth: fidl::encoding::Depth,
1099        ) -> fidl::Result<()> {
1100            decoder.debug_check_bounds::<Self>(offset);
1101            // Verify that padding bytes are zero.
1102            fidl::decode!(Netstack, D, &mut self.netstack, decoder, offset + 0, _depth)?;
1103            Ok(())
1104        }
1105    }
1106
1107    impl fidl::encoding::ValueTypeMarker for ControllerStartStubRequest {
1108        type Borrowed<'a> = &'a Self;
1109        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1110            value
1111        }
1112    }
1113
1114    unsafe impl fidl::encoding::TypeMarker for ControllerStartStubRequest {
1115        type Owned = Self;
1116
1117        #[inline(always)]
1118        fn inline_align(_context: fidl::encoding::Context) -> usize {
1119            8
1120        }
1121
1122        #[inline(always)]
1123        fn inline_size(_context: fidl::encoding::Context) -> usize {
1124            16
1125        }
1126    }
1127
1128    unsafe impl<D: fidl::encoding::ResourceDialect>
1129        fidl::encoding::Encode<ControllerStartStubRequest, D> for &ControllerStartStubRequest
1130    {
1131        #[inline]
1132        unsafe fn encode(
1133            self,
1134            encoder: &mut fidl::encoding::Encoder<'_, D>,
1135            offset: usize,
1136            _depth: fidl::encoding::Depth,
1137        ) -> fidl::Result<()> {
1138            encoder.debug_check_bounds::<ControllerStartStubRequest>(offset);
1139            // Delegate to tuple encoding.
1140            fidl::encoding::Encode::<ControllerStartStubRequest, D>::encode(
1141                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1142                    &self.component_url,
1143                ),),
1144                encoder,
1145                offset,
1146                _depth,
1147            )
1148        }
1149    }
1150    unsafe impl<
1151            D: fidl::encoding::ResourceDialect,
1152            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1153        > fidl::encoding::Encode<ControllerStartStubRequest, D> for (T0,)
1154    {
1155        #[inline]
1156        unsafe fn encode(
1157            self,
1158            encoder: &mut fidl::encoding::Encoder<'_, D>,
1159            offset: usize,
1160            depth: fidl::encoding::Depth,
1161        ) -> fidl::Result<()> {
1162            encoder.debug_check_bounds::<ControllerStartStubRequest>(offset);
1163            // Zero out padding regions. There's no need to apply masks
1164            // because the unmasked parts will be overwritten by fields.
1165            // Write the fields.
1166            self.0.encode(encoder, offset + 0, depth)?;
1167            Ok(())
1168        }
1169    }
1170
1171    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1172        for ControllerStartStubRequest
1173    {
1174        #[inline(always)]
1175        fn new_empty() -> Self {
1176            Self { component_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1177        }
1178
1179        #[inline]
1180        unsafe fn decode(
1181            &mut self,
1182            decoder: &mut fidl::encoding::Decoder<'_, D>,
1183            offset: usize,
1184            _depth: fidl::encoding::Depth,
1185        ) -> fidl::Result<()> {
1186            decoder.debug_check_bounds::<Self>(offset);
1187            // Verify that padding bytes are zero.
1188            fidl::decode!(
1189                fidl::encoding::BoundedString<4096>,
1190                D,
1191                &mut self.component_url,
1192                decoder,
1193                offset + 0,
1194                _depth
1195            )?;
1196            Ok(())
1197        }
1198    }
1199
1200    impl fidl::encoding::ValueTypeMarker for ControllerPollUdpResponse {
1201        type Borrowed<'a> = &'a Self;
1202        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1203            value
1204        }
1205    }
1206
1207    unsafe impl fidl::encoding::TypeMarker for ControllerPollUdpResponse {
1208        type Owned = Self;
1209
1210        #[inline(always)]
1211        fn inline_align(_context: fidl::encoding::Context) -> usize {
1212            8
1213        }
1214
1215        #[inline(always)]
1216        fn inline_size(_context: fidl::encoding::Context) -> usize {
1217            16
1218        }
1219    }
1220
1221    unsafe impl<D: fidl::encoding::ResourceDialect>
1222        fidl::encoding::Encode<ControllerPollUdpResponse, D> for &ControllerPollUdpResponse
1223    {
1224        #[inline]
1225        unsafe fn encode(
1226            self,
1227            encoder: &mut fidl::encoding::Encoder<'_, D>,
1228            offset: usize,
1229            _depth: fidl::encoding::Depth,
1230        ) -> fidl::Result<()> {
1231            encoder.debug_check_bounds::<ControllerPollUdpResponse>(offset);
1232            // Delegate to tuple encoding.
1233            fidl::encoding::Encode::<ControllerPollUdpResponse, D>::encode(
1234                (<fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(
1235                    &self.payload,
1236                ),),
1237                encoder,
1238                offset,
1239                _depth,
1240            )
1241        }
1242    }
1243    unsafe impl<
1244            D: fidl::encoding::ResourceDialect,
1245            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 1024>, D>,
1246        > fidl::encoding::Encode<ControllerPollUdpResponse, D> for (T0,)
1247    {
1248        #[inline]
1249        unsafe fn encode(
1250            self,
1251            encoder: &mut fidl::encoding::Encoder<'_, D>,
1252            offset: usize,
1253            depth: fidl::encoding::Depth,
1254        ) -> fidl::Result<()> {
1255            encoder.debug_check_bounds::<ControllerPollUdpResponse>(offset);
1256            // Zero out padding regions. There's no need to apply masks
1257            // because the unmasked parts will be overwritten by fields.
1258            // Write the fields.
1259            self.0.encode(encoder, offset + 0, depth)?;
1260            Ok(())
1261        }
1262    }
1263
1264    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1265        for ControllerPollUdpResponse
1266    {
1267        #[inline(always)]
1268        fn new_empty() -> Self {
1269            Self { payload: fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, D) }
1270        }
1271
1272        #[inline]
1273        unsafe fn decode(
1274            &mut self,
1275            decoder: &mut fidl::encoding::Decoder<'_, D>,
1276            offset: usize,
1277            _depth: fidl::encoding::Depth,
1278        ) -> fidl::Result<()> {
1279            decoder.debug_check_bounds::<Self>(offset);
1280            // Verify that padding bytes are zero.
1281            fidl::decode!(fidl::encoding::Vector<u8, 1024>, D, &mut self.payload, decoder, offset + 0, _depth)?;
1282            Ok(())
1283        }
1284    }
1285
1286    impl ControllerStartOutOfStackDhcpv4ClientRequest {
1287        #[inline(always)]
1288        fn max_ordinal_present(&self) -> u64 {
1289            if let Some(_) = self.interface_id {
1290                return 1;
1291            }
1292            0
1293        }
1294    }
1295
1296    impl fidl::encoding::ValueTypeMarker for ControllerStartOutOfStackDhcpv4ClientRequest {
1297        type Borrowed<'a> = &'a Self;
1298        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1299            value
1300        }
1301    }
1302
1303    unsafe impl fidl::encoding::TypeMarker for ControllerStartOutOfStackDhcpv4ClientRequest {
1304        type Owned = Self;
1305
1306        #[inline(always)]
1307        fn inline_align(_context: fidl::encoding::Context) -> usize {
1308            8
1309        }
1310
1311        #[inline(always)]
1312        fn inline_size(_context: fidl::encoding::Context) -> usize {
1313            16
1314        }
1315    }
1316
1317    unsafe impl<D: fidl::encoding::ResourceDialect>
1318        fidl::encoding::Encode<ControllerStartOutOfStackDhcpv4ClientRequest, D>
1319        for &ControllerStartOutOfStackDhcpv4ClientRequest
1320    {
1321        unsafe fn encode(
1322            self,
1323            encoder: &mut fidl::encoding::Encoder<'_, D>,
1324            offset: usize,
1325            mut depth: fidl::encoding::Depth,
1326        ) -> fidl::Result<()> {
1327            encoder.debug_check_bounds::<ControllerStartOutOfStackDhcpv4ClientRequest>(offset);
1328            // Vector header
1329            let max_ordinal: u64 = self.max_ordinal_present();
1330            encoder.write_num(max_ordinal, offset);
1331            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1332            // Calling encoder.out_of_line_offset(0) is not allowed.
1333            if max_ordinal == 0 {
1334                return Ok(());
1335            }
1336            depth.increment()?;
1337            let envelope_size = 8;
1338            let bytes_len = max_ordinal as usize * envelope_size;
1339            #[allow(unused_variables)]
1340            let offset = encoder.out_of_line_offset(bytes_len);
1341            let mut _prev_end_offset: usize = 0;
1342            if 1 > max_ordinal {
1343                return Ok(());
1344            }
1345
1346            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1347            // are envelope_size bytes.
1348            let cur_offset: usize = (1 - 1) * envelope_size;
1349
1350            // Zero reserved fields.
1351            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1352
1353            // Safety:
1354            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1355            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1356            //   envelope_size bytes, there is always sufficient room.
1357            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1358                self.interface_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1359                encoder,
1360                offset + cur_offset,
1361                depth,
1362            )?;
1363
1364            _prev_end_offset = cur_offset + envelope_size;
1365
1366            Ok(())
1367        }
1368    }
1369
1370    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1371        for ControllerStartOutOfStackDhcpv4ClientRequest
1372    {
1373        #[inline(always)]
1374        fn new_empty() -> Self {
1375            Self::default()
1376        }
1377
1378        unsafe fn decode(
1379            &mut self,
1380            decoder: &mut fidl::encoding::Decoder<'_, D>,
1381            offset: usize,
1382            mut depth: fidl::encoding::Depth,
1383        ) -> fidl::Result<()> {
1384            decoder.debug_check_bounds::<Self>(offset);
1385            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1386                None => return Err(fidl::Error::NotNullable),
1387                Some(len) => len,
1388            };
1389            // Calling decoder.out_of_line_offset(0) is not allowed.
1390            if len == 0 {
1391                return Ok(());
1392            };
1393            depth.increment()?;
1394            let envelope_size = 8;
1395            let bytes_len = len * envelope_size;
1396            let offset = decoder.out_of_line_offset(bytes_len)?;
1397            // Decode the envelope for each type.
1398            let mut _next_ordinal_to_read = 0;
1399            let mut next_offset = offset;
1400            let end_offset = offset + bytes_len;
1401            _next_ordinal_to_read += 1;
1402            if next_offset >= end_offset {
1403                return Ok(());
1404            }
1405
1406            // Decode unknown envelopes for gaps in ordinals.
1407            while _next_ordinal_to_read < 1 {
1408                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1409                _next_ordinal_to_read += 1;
1410                next_offset += envelope_size;
1411            }
1412
1413            let next_out_of_line = decoder.next_out_of_line();
1414            let handles_before = decoder.remaining_handles();
1415            if let Some((inlined, num_bytes, num_handles)) =
1416                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1417            {
1418                let member_inline_size =
1419                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1420                if inlined != (member_inline_size <= 4) {
1421                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1422                }
1423                let inner_offset;
1424                let mut inner_depth = depth.clone();
1425                if inlined {
1426                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1427                    inner_offset = next_offset;
1428                } else {
1429                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1430                    inner_depth.increment()?;
1431                }
1432                let val_ref = self.interface_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
1433                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1434                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1435                {
1436                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1437                }
1438                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1439                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1440                }
1441            }
1442
1443            next_offset += envelope_size;
1444
1445            // Decode the remaining unknown envelopes.
1446            while next_offset < end_offset {
1447                _next_ordinal_to_read += 1;
1448                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1449                next_offset += envelope_size;
1450            }
1451
1452            Ok(())
1453        }
1454    }
1455
1456    impl ControllerStopOutOfStackDhcpv4ClientRequest {
1457        #[inline(always)]
1458        fn max_ordinal_present(&self) -> u64 {
1459            if let Some(_) = self.interface_id {
1460                return 1;
1461            }
1462            0
1463        }
1464    }
1465
1466    impl fidl::encoding::ValueTypeMarker for ControllerStopOutOfStackDhcpv4ClientRequest {
1467        type Borrowed<'a> = &'a Self;
1468        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1469            value
1470        }
1471    }
1472
1473    unsafe impl fidl::encoding::TypeMarker for ControllerStopOutOfStackDhcpv4ClientRequest {
1474        type Owned = Self;
1475
1476        #[inline(always)]
1477        fn inline_align(_context: fidl::encoding::Context) -> usize {
1478            8
1479        }
1480
1481        #[inline(always)]
1482        fn inline_size(_context: fidl::encoding::Context) -> usize {
1483            16
1484        }
1485    }
1486
1487    unsafe impl<D: fidl::encoding::ResourceDialect>
1488        fidl::encoding::Encode<ControllerStopOutOfStackDhcpv4ClientRequest, D>
1489        for &ControllerStopOutOfStackDhcpv4ClientRequest
1490    {
1491        unsafe fn encode(
1492            self,
1493            encoder: &mut fidl::encoding::Encoder<'_, D>,
1494            offset: usize,
1495            mut depth: fidl::encoding::Depth,
1496        ) -> fidl::Result<()> {
1497            encoder.debug_check_bounds::<ControllerStopOutOfStackDhcpv4ClientRequest>(offset);
1498            // Vector header
1499            let max_ordinal: u64 = self.max_ordinal_present();
1500            encoder.write_num(max_ordinal, offset);
1501            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1502            // Calling encoder.out_of_line_offset(0) is not allowed.
1503            if max_ordinal == 0 {
1504                return Ok(());
1505            }
1506            depth.increment()?;
1507            let envelope_size = 8;
1508            let bytes_len = max_ordinal as usize * envelope_size;
1509            #[allow(unused_variables)]
1510            let offset = encoder.out_of_line_offset(bytes_len);
1511            let mut _prev_end_offset: usize = 0;
1512            if 1 > max_ordinal {
1513                return Ok(());
1514            }
1515
1516            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1517            // are envelope_size bytes.
1518            let cur_offset: usize = (1 - 1) * envelope_size;
1519
1520            // Zero reserved fields.
1521            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1522
1523            // Safety:
1524            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1525            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1526            //   envelope_size bytes, there is always sufficient room.
1527            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1528                self.interface_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1529                encoder,
1530                offset + cur_offset,
1531                depth,
1532            )?;
1533
1534            _prev_end_offset = cur_offset + envelope_size;
1535
1536            Ok(())
1537        }
1538    }
1539
1540    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1541        for ControllerStopOutOfStackDhcpv4ClientRequest
1542    {
1543        #[inline(always)]
1544        fn new_empty() -> Self {
1545            Self::default()
1546        }
1547
1548        unsafe fn decode(
1549            &mut self,
1550            decoder: &mut fidl::encoding::Decoder<'_, D>,
1551            offset: usize,
1552            mut depth: fidl::encoding::Depth,
1553        ) -> fidl::Result<()> {
1554            decoder.debug_check_bounds::<Self>(offset);
1555            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1556                None => return Err(fidl::Error::NotNullable),
1557                Some(len) => len,
1558            };
1559            // Calling decoder.out_of_line_offset(0) is not allowed.
1560            if len == 0 {
1561                return Ok(());
1562            };
1563            depth.increment()?;
1564            let envelope_size = 8;
1565            let bytes_len = len * envelope_size;
1566            let offset = decoder.out_of_line_offset(bytes_len)?;
1567            // Decode the envelope for each type.
1568            let mut _next_ordinal_to_read = 0;
1569            let mut next_offset = offset;
1570            let end_offset = offset + bytes_len;
1571            _next_ordinal_to_read += 1;
1572            if next_offset >= end_offset {
1573                return Ok(());
1574            }
1575
1576            // Decode unknown envelopes for gaps in ordinals.
1577            while _next_ordinal_to_read < 1 {
1578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1579                _next_ordinal_to_read += 1;
1580                next_offset += envelope_size;
1581            }
1582
1583            let next_out_of_line = decoder.next_out_of_line();
1584            let handles_before = decoder.remaining_handles();
1585            if let Some((inlined, num_bytes, num_handles)) =
1586                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1587            {
1588                let member_inline_size =
1589                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1590                if inlined != (member_inline_size <= 4) {
1591                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1592                }
1593                let inner_offset;
1594                let mut inner_depth = depth.clone();
1595                if inlined {
1596                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1597                    inner_offset = next_offset;
1598                } else {
1599                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1600                    inner_depth.increment()?;
1601                }
1602                let val_ref = self.interface_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
1603                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1604                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1605                {
1606                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1607                }
1608                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1609                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1610                }
1611            }
1612
1613            next_offset += envelope_size;
1614
1615            // Decode the remaining unknown envelopes.
1616            while next_offset < end_offset {
1617                _next_ordinal_to_read += 1;
1618                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1619                next_offset += envelope_size;
1620            }
1621
1622            Ok(())
1623        }
1624    }
1625}
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
