fidl_fuchsia_posix_socket_raw_common/
fidl_fuchsia_posix_socket_raw_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
11/// The protocol a raw socket may be associated with.
12pub type Protocol = u8;
13
14pub const SOCKET_PROTOCOL_NAME: &str = "fuchsia.posix.socket.raw/Socket";
15
16#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
17pub struct Empty;
18
19impl fidl::Persistable for Empty {}
20
21/// A filter for ICMPv6 types.
22#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
23#[repr(C)]
24pub struct Icmpv6Filter {
25    /// Indicates whether or not an ICMPv6 type should be blocked.
26    ///
27    /// Each bit index encodes an ICMPv6 type; bit 0 in `blocked_types[0]` holds
28    /// the flag for ICMPv6 type 0 and bit 31 in `blocked_types[7]` holds the
29    /// flag for ICMPv6 type 255.
30    ///
31    /// Equivalent to Linux's `icmp6_filter.icmp6_filt`.
32    pub blocked_types: [u32; 8],
33}
34
35impl fidl::Persistable for Icmpv6Filter {}
36
37#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
38pub struct ProviderSocketRequest {
39    pub domain: fidl_fuchsia_posix_socket::Domain,
40    pub proto: ProtocolAssociation,
41}
42
43impl fidl::Persistable for ProviderSocketRequest {}
44
45#[derive(Clone, Debug, PartialEq)]
46pub struct ProviderSocketWithOptionsRequest {
47    pub domain: fidl_fuchsia_posix_socket::Domain,
48    pub proto: ProtocolAssociation,
49    pub opts: fidl_fuchsia_posix_socket::SocketCreationOptions,
50}
51
52impl fidl::Persistable for ProviderSocketWithOptionsRequest {}
53
54#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
55pub struct SocketRecvMsgRequest {
56    pub want_addr: bool,
57    pub data_len: u32,
58    pub want_control: bool,
59    pub flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
60}
61
62impl fidl::Persistable for SocketRecvMsgRequest {}
63
64#[derive(Clone, Debug, PartialEq)]
65pub struct SocketSendMsgRequest {
66    pub addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
67    pub data: Vec<u8>,
68    pub control: fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
69    pub flags: fidl_fuchsia_posix_socket::SendMsgFlags,
70}
71
72impl fidl::Persistable for SocketSendMsgRequest {}
73
74#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
75#[repr(C)]
76pub struct SocketSetIcmpv6FilterRequest {
77    pub filter: Icmpv6Filter,
78}
79
80impl fidl::Persistable for SocketSetIcmpv6FilterRequest {}
81
82#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
83pub struct SocketSetIpHeaderIncludedRequest {
84    pub value: bool,
85}
86
87impl fidl::Persistable for SocketSetIpHeaderIncludedRequest {}
88
89#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
90pub struct SocketSetIpv6ChecksumRequest {
91    pub config: Ipv6ChecksumConfiguration,
92}
93
94impl fidl::Persistable for SocketSetIpv6ChecksumRequest {}
95
96#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
97#[repr(C)]
98pub struct SocketGetIcmpv6FilterResponse {
99    pub filter: Icmpv6Filter,
100}
101
102impl fidl::Persistable for SocketGetIcmpv6FilterResponse {}
103
104#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
105pub struct SocketGetInfoResponse {
106    pub domain: fidl_fuchsia_posix_socket::Domain,
107    pub proto: ProtocolAssociation,
108}
109
110impl fidl::Persistable for SocketGetInfoResponse {}
111
112#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
113pub struct SocketGetIpHeaderIncludedResponse {
114    pub value: bool,
115}
116
117impl fidl::Persistable for SocketGetIpHeaderIncludedResponse {}
118
119#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
120pub struct SocketGetIpv6ChecksumResponse {
121    pub config: Ipv6ChecksumConfiguration,
122}
123
124impl fidl::Persistable for SocketGetIpv6ChecksumResponse {}
125
126#[derive(Clone, Debug, PartialEq)]
127pub struct SocketRecvMsgResponse {
128    pub addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
129    pub data: Vec<u8>,
130    pub control: fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
131    pub truncated: u32,
132}
133
134impl fidl::Persistable for SocketRecvMsgResponse {}
135
136/// IPv6 socket checksum configuration.
137#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
138pub enum Ipv6ChecksumConfiguration {
139    /// Indicates that the stack should not calculate checksums for outgoing
140    /// packets and valiate checksums for incoming packets.
141    Disabled(Empty),
142    /// Indicates that the stack should calculate checksums for outgoing packets
143    /// and validate checksums for incoming packets.
144    ///
145    /// `offset` indicates where the checksum is found in the IPv6 packet's
146    /// payload.
147    ///
148    /// The offset must be aligned to the size of an internet checksum as
149    /// specified in RFC 1071. That is, the offset must be 2-byte aligned.
150    Offset(i32),
151}
152
153impl Ipv6ChecksumConfiguration {
154    #[inline]
155    pub fn ordinal(&self) -> u64 {
156        match *self {
157            Self::Disabled(_) => 1,
158            Self::Offset(_) => 2,
159        }
160    }
161
162    #[deprecated = "Strict unions should not use `is_unknown`"]
163    #[inline]
164    pub fn is_unknown(&self) -> bool {
165        false
166    }
167}
168
169impl fidl::Persistable for Ipv6ChecksumConfiguration {}
170
171/// The protocol a raw socket is associated with.
172#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
173pub enum ProtocolAssociation {
174    /// Indicates no association with any protocol.
175    ///
176    /// The socket will not receive packets. Sent packets must include the
177    /// network header.
178    Unassociated(Empty),
179    /// The associated protocol.
180    ///
181    /// The socket may only send and receive network packets for the associated
182    /// protocol.
183    Associated(u8),
184}
185
186impl ProtocolAssociation {
187    #[inline]
188    pub fn ordinal(&self) -> u64 {
189        match *self {
190            Self::Unassociated(_) => 1,
191            Self::Associated(_) => 2,
192        }
193    }
194
195    #[deprecated = "Strict unions should not use `is_unknown`"]
196    #[inline]
197    pub fn is_unknown(&self) -> bool {
198        false
199    }
200}
201
202impl fidl::Persistable for ProtocolAssociation {}
203
204mod internal {
205    use super::*;
206
207    impl fidl::encoding::ValueTypeMarker for Empty {
208        type Borrowed<'a> = &'a Self;
209        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
210            value
211        }
212    }
213
214    unsafe impl fidl::encoding::TypeMarker for Empty {
215        type Owned = Self;
216
217        #[inline(always)]
218        fn inline_align(_context: fidl::encoding::Context) -> usize {
219            1
220        }
221
222        #[inline(always)]
223        fn inline_size(_context: fidl::encoding::Context) -> usize {
224            1
225        }
226    }
227
228    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
229        #[inline]
230        unsafe fn encode(
231            self,
232            encoder: &mut fidl::encoding::Encoder<'_, D>,
233            offset: usize,
234            _depth: fidl::encoding::Depth,
235        ) -> fidl::Result<()> {
236            encoder.debug_check_bounds::<Empty>(offset);
237            encoder.write_num(0u8, offset);
238            Ok(())
239        }
240    }
241
242    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
243        #[inline(always)]
244        fn new_empty() -> Self {
245            Self
246        }
247
248        #[inline]
249        unsafe fn decode(
250            &mut self,
251            decoder: &mut fidl::encoding::Decoder<'_, D>,
252            offset: usize,
253            _depth: fidl::encoding::Depth,
254        ) -> fidl::Result<()> {
255            decoder.debug_check_bounds::<Self>(offset);
256            match decoder.read_num::<u8>(offset) {
257                0 => Ok(()),
258                _ => Err(fidl::Error::Invalid),
259            }
260        }
261    }
262
263    impl fidl::encoding::ValueTypeMarker for Icmpv6Filter {
264        type Borrowed<'a> = &'a Self;
265        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
266            value
267        }
268    }
269
270    unsafe impl fidl::encoding::TypeMarker for Icmpv6Filter {
271        type Owned = Self;
272
273        #[inline(always)]
274        fn inline_align(_context: fidl::encoding::Context) -> usize {
275            4
276        }
277
278        #[inline(always)]
279        fn inline_size(_context: fidl::encoding::Context) -> usize {
280            32
281        }
282        #[inline(always)]
283        fn encode_is_copy() -> bool {
284            true
285        }
286
287        #[inline(always)]
288        fn decode_is_copy() -> bool {
289            true
290        }
291    }
292
293    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Icmpv6Filter, D>
294        for &Icmpv6Filter
295    {
296        #[inline]
297        unsafe fn encode(
298            self,
299            encoder: &mut fidl::encoding::Encoder<'_, D>,
300            offset: usize,
301            _depth: fidl::encoding::Depth,
302        ) -> fidl::Result<()> {
303            encoder.debug_check_bounds::<Icmpv6Filter>(offset);
304            unsafe {
305                // Copy the object into the buffer.
306                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
307                (buf_ptr as *mut Icmpv6Filter)
308                    .write_unaligned((self as *const Icmpv6Filter).read());
309                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
310                // done second because the memcpy will write garbage to these bytes.
311            }
312            Ok(())
313        }
314    }
315    unsafe impl<
316            D: fidl::encoding::ResourceDialect,
317            T0: fidl::encoding::Encode<fidl::encoding::Array<u32, 8>, D>,
318        > fidl::encoding::Encode<Icmpv6Filter, D> for (T0,)
319    {
320        #[inline]
321        unsafe fn encode(
322            self,
323            encoder: &mut fidl::encoding::Encoder<'_, D>,
324            offset: usize,
325            depth: fidl::encoding::Depth,
326        ) -> fidl::Result<()> {
327            encoder.debug_check_bounds::<Icmpv6Filter>(offset);
328            // Zero out padding regions. There's no need to apply masks
329            // because the unmasked parts will be overwritten by fields.
330            // Write the fields.
331            self.0.encode(encoder, offset + 0, depth)?;
332            Ok(())
333        }
334    }
335
336    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Icmpv6Filter {
337        #[inline(always)]
338        fn new_empty() -> Self {
339            Self { blocked_types: fidl::new_empty!(fidl::encoding::Array<u32, 8>, D) }
340        }
341
342        #[inline]
343        unsafe fn decode(
344            &mut self,
345            decoder: &mut fidl::encoding::Decoder<'_, D>,
346            offset: usize,
347            _depth: fidl::encoding::Depth,
348        ) -> fidl::Result<()> {
349            decoder.debug_check_bounds::<Self>(offset);
350            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
351            // Verify that padding bytes are zero.
352            // Copy from the buffer into the object.
353            unsafe {
354                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
355            }
356            Ok(())
357        }
358    }
359
360    impl fidl::encoding::ValueTypeMarker for ProviderSocketRequest {
361        type Borrowed<'a> = &'a Self;
362        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
363            value
364        }
365    }
366
367    unsafe impl fidl::encoding::TypeMarker for ProviderSocketRequest {
368        type Owned = Self;
369
370        #[inline(always)]
371        fn inline_align(_context: fidl::encoding::Context) -> usize {
372            8
373        }
374
375        #[inline(always)]
376        fn inline_size(_context: fidl::encoding::Context) -> usize {
377            24
378        }
379    }
380
381    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderSocketRequest, D>
382        for &ProviderSocketRequest
383    {
384        #[inline]
385        unsafe fn encode(
386            self,
387            encoder: &mut fidl::encoding::Encoder<'_, D>,
388            offset: usize,
389            _depth: fidl::encoding::Depth,
390        ) -> fidl::Result<()> {
391            encoder.debug_check_bounds::<ProviderSocketRequest>(offset);
392            // Delegate to tuple encoding.
393            fidl::encoding::Encode::<ProviderSocketRequest, D>::encode(
394                (
395                    <fidl_fuchsia_posix_socket::Domain as fidl::encoding::ValueTypeMarker>::borrow(
396                        &self.domain,
397                    ),
398                    <ProtocolAssociation as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
399                ),
400                encoder,
401                offset,
402                _depth,
403            )
404        }
405    }
406    unsafe impl<
407            D: fidl::encoding::ResourceDialect,
408            T0: fidl::encoding::Encode<fidl_fuchsia_posix_socket::Domain, D>,
409            T1: fidl::encoding::Encode<ProtocolAssociation, D>,
410        > fidl::encoding::Encode<ProviderSocketRequest, D> for (T0, T1)
411    {
412        #[inline]
413        unsafe fn encode(
414            self,
415            encoder: &mut fidl::encoding::Encoder<'_, D>,
416            offset: usize,
417            depth: fidl::encoding::Depth,
418        ) -> fidl::Result<()> {
419            encoder.debug_check_bounds::<ProviderSocketRequest>(offset);
420            // Zero out padding regions. There's no need to apply masks
421            // because the unmasked parts will be overwritten by fields.
422            unsafe {
423                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
424                (ptr as *mut u64).write_unaligned(0);
425            }
426            // Write the fields.
427            self.0.encode(encoder, offset + 0, depth)?;
428            self.1.encode(encoder, offset + 8, depth)?;
429            Ok(())
430        }
431    }
432
433    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderSocketRequest {
434        #[inline(always)]
435        fn new_empty() -> Self {
436            Self {
437                domain: fidl::new_empty!(fidl_fuchsia_posix_socket::Domain, D),
438                proto: fidl::new_empty!(ProtocolAssociation, D),
439            }
440        }
441
442        #[inline]
443        unsafe fn decode(
444            &mut self,
445            decoder: &mut fidl::encoding::Decoder<'_, D>,
446            offset: usize,
447            _depth: fidl::encoding::Depth,
448        ) -> fidl::Result<()> {
449            decoder.debug_check_bounds::<Self>(offset);
450            // Verify that padding bytes are zero.
451            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
452            let padval = unsafe { (ptr as *const u64).read_unaligned() };
453            let mask = 0xffffffffffff0000u64;
454            let maskedval = padval & mask;
455            if maskedval != 0 {
456                return Err(fidl::Error::NonZeroPadding {
457                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
458                });
459            }
460            fidl::decode!(
461                fidl_fuchsia_posix_socket::Domain,
462                D,
463                &mut self.domain,
464                decoder,
465                offset + 0,
466                _depth
467            )?;
468            fidl::decode!(ProtocolAssociation, D, &mut self.proto, decoder, offset + 8, _depth)?;
469            Ok(())
470        }
471    }
472
473    impl fidl::encoding::ValueTypeMarker for ProviderSocketWithOptionsRequest {
474        type Borrowed<'a> = &'a Self;
475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
476            value
477        }
478    }
479
480    unsafe impl fidl::encoding::TypeMarker for ProviderSocketWithOptionsRequest {
481        type Owned = Self;
482
483        #[inline(always)]
484        fn inline_align(_context: fidl::encoding::Context) -> usize {
485            8
486        }
487
488        #[inline(always)]
489        fn inline_size(_context: fidl::encoding::Context) -> usize {
490            40
491        }
492    }
493
494    unsafe impl<D: fidl::encoding::ResourceDialect>
495        fidl::encoding::Encode<ProviderSocketWithOptionsRequest, D>
496        for &ProviderSocketWithOptionsRequest
497    {
498        #[inline]
499        unsafe fn encode(
500            self,
501            encoder: &mut fidl::encoding::Encoder<'_, D>,
502            offset: usize,
503            _depth: fidl::encoding::Depth,
504        ) -> fidl::Result<()> {
505            encoder.debug_check_bounds::<ProviderSocketWithOptionsRequest>(offset);
506            // Delegate to tuple encoding.
507            fidl::encoding::Encode::<ProviderSocketWithOptionsRequest, D>::encode(
508                (
509                    <fidl_fuchsia_posix_socket::Domain as fidl::encoding::ValueTypeMarker>::borrow(&self.domain),
510                    <ProtocolAssociation as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
511                    <fidl_fuchsia_posix_socket::SocketCreationOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.opts),
512                ),
513                encoder, offset, _depth
514            )
515        }
516    }
517    unsafe impl<
518            D: fidl::encoding::ResourceDialect,
519            T0: fidl::encoding::Encode<fidl_fuchsia_posix_socket::Domain, D>,
520            T1: fidl::encoding::Encode<ProtocolAssociation, D>,
521            T2: fidl::encoding::Encode<fidl_fuchsia_posix_socket::SocketCreationOptions, D>,
522        > fidl::encoding::Encode<ProviderSocketWithOptionsRequest, D> for (T0, T1, T2)
523    {
524        #[inline]
525        unsafe fn encode(
526            self,
527            encoder: &mut fidl::encoding::Encoder<'_, D>,
528            offset: usize,
529            depth: fidl::encoding::Depth,
530        ) -> fidl::Result<()> {
531            encoder.debug_check_bounds::<ProviderSocketWithOptionsRequest>(offset);
532            // Zero out padding regions. There's no need to apply masks
533            // because the unmasked parts will be overwritten by fields.
534            unsafe {
535                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
536                (ptr as *mut u64).write_unaligned(0);
537            }
538            // Write the fields.
539            self.0.encode(encoder, offset + 0, depth)?;
540            self.1.encode(encoder, offset + 8, depth)?;
541            self.2.encode(encoder, offset + 24, depth)?;
542            Ok(())
543        }
544    }
545
546    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
547        for ProviderSocketWithOptionsRequest
548    {
549        #[inline(always)]
550        fn new_empty() -> Self {
551            Self {
552                domain: fidl::new_empty!(fidl_fuchsia_posix_socket::Domain, D),
553                proto: fidl::new_empty!(ProtocolAssociation, D),
554                opts: fidl::new_empty!(fidl_fuchsia_posix_socket::SocketCreationOptions, D),
555            }
556        }
557
558        #[inline]
559        unsafe fn decode(
560            &mut self,
561            decoder: &mut fidl::encoding::Decoder<'_, D>,
562            offset: usize,
563            _depth: fidl::encoding::Depth,
564        ) -> fidl::Result<()> {
565            decoder.debug_check_bounds::<Self>(offset);
566            // Verify that padding bytes are zero.
567            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
568            let padval = unsafe { (ptr as *const u64).read_unaligned() };
569            let mask = 0xffffffffffff0000u64;
570            let maskedval = padval & mask;
571            if maskedval != 0 {
572                return Err(fidl::Error::NonZeroPadding {
573                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
574                });
575            }
576            fidl::decode!(
577                fidl_fuchsia_posix_socket::Domain,
578                D,
579                &mut self.domain,
580                decoder,
581                offset + 0,
582                _depth
583            )?;
584            fidl::decode!(ProtocolAssociation, D, &mut self.proto, decoder, offset + 8, _depth)?;
585            fidl::decode!(
586                fidl_fuchsia_posix_socket::SocketCreationOptions,
587                D,
588                &mut self.opts,
589                decoder,
590                offset + 24,
591                _depth
592            )?;
593            Ok(())
594        }
595    }
596
597    impl fidl::encoding::ValueTypeMarker for SocketRecvMsgRequest {
598        type Borrowed<'a> = &'a Self;
599        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
600            value
601        }
602    }
603
604    unsafe impl fidl::encoding::TypeMarker for SocketRecvMsgRequest {
605        type Owned = Self;
606
607        #[inline(always)]
608        fn inline_align(_context: fidl::encoding::Context) -> usize {
609            4
610        }
611
612        #[inline(always)]
613        fn inline_size(_context: fidl::encoding::Context) -> usize {
614            12
615        }
616    }
617
618    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketRecvMsgRequest, D>
619        for &SocketRecvMsgRequest
620    {
621        #[inline]
622        unsafe fn encode(
623            self,
624            encoder: &mut fidl::encoding::Encoder<'_, D>,
625            offset: usize,
626            _depth: fidl::encoding::Depth,
627        ) -> fidl::Result<()> {
628            encoder.debug_check_bounds::<SocketRecvMsgRequest>(offset);
629            // Delegate to tuple encoding.
630            fidl::encoding::Encode::<SocketRecvMsgRequest, D>::encode(
631                (
632                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.want_addr),
633                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.data_len),
634                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.want_control),
635                    <fidl_fuchsia_posix_socket::RecvMsgFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
636                ),
637                encoder, offset, _depth
638            )
639        }
640    }
641    unsafe impl<
642            D: fidl::encoding::ResourceDialect,
643            T0: fidl::encoding::Encode<bool, D>,
644            T1: fidl::encoding::Encode<u32, D>,
645            T2: fidl::encoding::Encode<bool, D>,
646            T3: fidl::encoding::Encode<fidl_fuchsia_posix_socket::RecvMsgFlags, D>,
647        > fidl::encoding::Encode<SocketRecvMsgRequest, D> for (T0, T1, T2, T3)
648    {
649        #[inline]
650        unsafe fn encode(
651            self,
652            encoder: &mut fidl::encoding::Encoder<'_, D>,
653            offset: usize,
654            depth: fidl::encoding::Depth,
655        ) -> fidl::Result<()> {
656            encoder.debug_check_bounds::<SocketRecvMsgRequest>(offset);
657            // Zero out padding regions. There's no need to apply masks
658            // because the unmasked parts will be overwritten by fields.
659            unsafe {
660                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
661                (ptr as *mut u32).write_unaligned(0);
662            }
663            unsafe {
664                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
665                (ptr as *mut u32).write_unaligned(0);
666            }
667            // Write the fields.
668            self.0.encode(encoder, offset + 0, depth)?;
669            self.1.encode(encoder, offset + 4, depth)?;
670            self.2.encode(encoder, offset + 8, depth)?;
671            self.3.encode(encoder, offset + 10, depth)?;
672            Ok(())
673        }
674    }
675
676    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketRecvMsgRequest {
677        #[inline(always)]
678        fn new_empty() -> Self {
679            Self {
680                want_addr: fidl::new_empty!(bool, D),
681                data_len: fidl::new_empty!(u32, D),
682                want_control: fidl::new_empty!(bool, D),
683                flags: fidl::new_empty!(fidl_fuchsia_posix_socket::RecvMsgFlags, D),
684            }
685        }
686
687        #[inline]
688        unsafe fn decode(
689            &mut self,
690            decoder: &mut fidl::encoding::Decoder<'_, D>,
691            offset: usize,
692            _depth: fidl::encoding::Depth,
693        ) -> fidl::Result<()> {
694            decoder.debug_check_bounds::<Self>(offset);
695            // Verify that padding bytes are zero.
696            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
697            let padval = unsafe { (ptr as *const u32).read_unaligned() };
698            let mask = 0xffffff00u32;
699            let maskedval = padval & mask;
700            if maskedval != 0 {
701                return Err(fidl::Error::NonZeroPadding {
702                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
703                });
704            }
705            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
706            let padval = unsafe { (ptr as *const u32).read_unaligned() };
707            let mask = 0xff00u32;
708            let maskedval = padval & mask;
709            if maskedval != 0 {
710                return Err(fidl::Error::NonZeroPadding {
711                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
712                });
713            }
714            fidl::decode!(bool, D, &mut self.want_addr, decoder, offset + 0, _depth)?;
715            fidl::decode!(u32, D, &mut self.data_len, decoder, offset + 4, _depth)?;
716            fidl::decode!(bool, D, &mut self.want_control, decoder, offset + 8, _depth)?;
717            fidl::decode!(
718                fidl_fuchsia_posix_socket::RecvMsgFlags,
719                D,
720                &mut self.flags,
721                decoder,
722                offset + 10,
723                _depth
724            )?;
725            Ok(())
726        }
727    }
728
729    impl fidl::encoding::ValueTypeMarker for SocketSendMsgRequest {
730        type Borrowed<'a> = &'a Self;
731        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
732            value
733        }
734    }
735
736    unsafe impl fidl::encoding::TypeMarker for SocketSendMsgRequest {
737        type Owned = Self;
738
739        #[inline(always)]
740        fn inline_align(_context: fidl::encoding::Context) -> usize {
741            8
742        }
743
744        #[inline(always)]
745        fn inline_size(_context: fidl::encoding::Context) -> usize {
746            56
747        }
748    }
749
750    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketSendMsgRequest, D>
751        for &SocketSendMsgRequest
752    {
753        #[inline]
754        unsafe fn encode(
755            self,
756            encoder: &mut fidl::encoding::Encoder<'_, D>,
757            offset: usize,
758            _depth: fidl::encoding::Depth,
759        ) -> fidl::Result<()> {
760            encoder.debug_check_bounds::<SocketSendMsgRequest>(offset);
761            // Delegate to tuple encoding.
762            fidl::encoding::Encode::<SocketSendMsgRequest, D>::encode(
763                (
764                    <fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
765                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
766                    <fidl_fuchsia_posix_socket::NetworkSocketSendControlData as fidl::encoding::ValueTypeMarker>::borrow(&self.control),
767                    <fidl_fuchsia_posix_socket::SendMsgFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
768                ),
769                encoder, offset, _depth
770            )
771        }
772    }
773    unsafe impl<
774            D: fidl::encoding::ResourceDialect,
775            T0: fidl::encoding::Encode<
776                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
777                D,
778            >,
779            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
780            T2: fidl::encoding::Encode<fidl_fuchsia_posix_socket::NetworkSocketSendControlData, D>,
781            T3: fidl::encoding::Encode<fidl_fuchsia_posix_socket::SendMsgFlags, D>,
782        > fidl::encoding::Encode<SocketSendMsgRequest, D> for (T0, T1, T2, T3)
783    {
784        #[inline]
785        unsafe fn encode(
786            self,
787            encoder: &mut fidl::encoding::Encoder<'_, D>,
788            offset: usize,
789            depth: fidl::encoding::Depth,
790        ) -> fidl::Result<()> {
791            encoder.debug_check_bounds::<SocketSendMsgRequest>(offset);
792            // Zero out padding regions. There's no need to apply masks
793            // because the unmasked parts will be overwritten by fields.
794            unsafe {
795                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
796                (ptr as *mut u64).write_unaligned(0);
797            }
798            // Write the fields.
799            self.0.encode(encoder, offset + 0, depth)?;
800            self.1.encode(encoder, offset + 16, depth)?;
801            self.2.encode(encoder, offset + 32, depth)?;
802            self.3.encode(encoder, offset + 48, depth)?;
803            Ok(())
804        }
805    }
806
807    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketSendMsgRequest {
808        #[inline(always)]
809        fn new_empty() -> Self {
810            Self {
811                addr: fidl::new_empty!(
812                    fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
813                    D
814                ),
815                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
816                control: fidl::new_empty!(
817                    fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
818                    D
819                ),
820                flags: fidl::new_empty!(fidl_fuchsia_posix_socket::SendMsgFlags, D),
821            }
822        }
823
824        #[inline]
825        unsafe fn decode(
826            &mut self,
827            decoder: &mut fidl::encoding::Decoder<'_, D>,
828            offset: usize,
829            _depth: fidl::encoding::Depth,
830        ) -> fidl::Result<()> {
831            decoder.debug_check_bounds::<Self>(offset);
832            // Verify that padding bytes are zero.
833            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
834            let padval = unsafe { (ptr as *const u64).read_unaligned() };
835            let mask = 0xffffffffffff0000u64;
836            let maskedval = padval & mask;
837            if maskedval != 0 {
838                return Err(fidl::Error::NonZeroPadding {
839                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
840                });
841            }
842            fidl::decode!(
843                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
844                D,
845                &mut self.addr,
846                decoder,
847                offset + 0,
848                _depth
849            )?;
850            fidl::decode!(
851                fidl::encoding::UnboundedVector<u8>,
852                D,
853                &mut self.data,
854                decoder,
855                offset + 16,
856                _depth
857            )?;
858            fidl::decode!(
859                fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
860                D,
861                &mut self.control,
862                decoder,
863                offset + 32,
864                _depth
865            )?;
866            fidl::decode!(
867                fidl_fuchsia_posix_socket::SendMsgFlags,
868                D,
869                &mut self.flags,
870                decoder,
871                offset + 48,
872                _depth
873            )?;
874            Ok(())
875        }
876    }
877
878    impl fidl::encoding::ValueTypeMarker for SocketSetIcmpv6FilterRequest {
879        type Borrowed<'a> = &'a Self;
880        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
881            value
882        }
883    }
884
885    unsafe impl fidl::encoding::TypeMarker for SocketSetIcmpv6FilterRequest {
886        type Owned = Self;
887
888        #[inline(always)]
889        fn inline_align(_context: fidl::encoding::Context) -> usize {
890            4
891        }
892
893        #[inline(always)]
894        fn inline_size(_context: fidl::encoding::Context) -> usize {
895            32
896        }
897        #[inline(always)]
898        fn encode_is_copy() -> bool {
899            true
900        }
901
902        #[inline(always)]
903        fn decode_is_copy() -> bool {
904            true
905        }
906    }
907
908    unsafe impl<D: fidl::encoding::ResourceDialect>
909        fidl::encoding::Encode<SocketSetIcmpv6FilterRequest, D> for &SocketSetIcmpv6FilterRequest
910    {
911        #[inline]
912        unsafe fn encode(
913            self,
914            encoder: &mut fidl::encoding::Encoder<'_, D>,
915            offset: usize,
916            _depth: fidl::encoding::Depth,
917        ) -> fidl::Result<()> {
918            encoder.debug_check_bounds::<SocketSetIcmpv6FilterRequest>(offset);
919            unsafe {
920                // Copy the object into the buffer.
921                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
922                (buf_ptr as *mut SocketSetIcmpv6FilterRequest)
923                    .write_unaligned((self as *const SocketSetIcmpv6FilterRequest).read());
924                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
925                // done second because the memcpy will write garbage to these bytes.
926            }
927            Ok(())
928        }
929    }
930    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Icmpv6Filter, D>>
931        fidl::encoding::Encode<SocketSetIcmpv6FilterRequest, D> for (T0,)
932    {
933        #[inline]
934        unsafe fn encode(
935            self,
936            encoder: &mut fidl::encoding::Encoder<'_, D>,
937            offset: usize,
938            depth: fidl::encoding::Depth,
939        ) -> fidl::Result<()> {
940            encoder.debug_check_bounds::<SocketSetIcmpv6FilterRequest>(offset);
941            // Zero out padding regions. There's no need to apply masks
942            // because the unmasked parts will be overwritten by fields.
943            // Write the fields.
944            self.0.encode(encoder, offset + 0, depth)?;
945            Ok(())
946        }
947    }
948
949    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
950        for SocketSetIcmpv6FilterRequest
951    {
952        #[inline(always)]
953        fn new_empty() -> Self {
954            Self { filter: fidl::new_empty!(Icmpv6Filter, D) }
955        }
956
957        #[inline]
958        unsafe fn decode(
959            &mut self,
960            decoder: &mut fidl::encoding::Decoder<'_, D>,
961            offset: usize,
962            _depth: fidl::encoding::Depth,
963        ) -> fidl::Result<()> {
964            decoder.debug_check_bounds::<Self>(offset);
965            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
966            // Verify that padding bytes are zero.
967            // Copy from the buffer into the object.
968            unsafe {
969                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
970            }
971            Ok(())
972        }
973    }
974
975    impl fidl::encoding::ValueTypeMarker for SocketSetIpHeaderIncludedRequest {
976        type Borrowed<'a> = &'a Self;
977        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
978            value
979        }
980    }
981
982    unsafe impl fidl::encoding::TypeMarker for SocketSetIpHeaderIncludedRequest {
983        type Owned = Self;
984
985        #[inline(always)]
986        fn inline_align(_context: fidl::encoding::Context) -> usize {
987            1
988        }
989
990        #[inline(always)]
991        fn inline_size(_context: fidl::encoding::Context) -> usize {
992            1
993        }
994    }
995
996    unsafe impl<D: fidl::encoding::ResourceDialect>
997        fidl::encoding::Encode<SocketSetIpHeaderIncludedRequest, D>
998        for &SocketSetIpHeaderIncludedRequest
999    {
1000        #[inline]
1001        unsafe fn encode(
1002            self,
1003            encoder: &mut fidl::encoding::Encoder<'_, D>,
1004            offset: usize,
1005            _depth: fidl::encoding::Depth,
1006        ) -> fidl::Result<()> {
1007            encoder.debug_check_bounds::<SocketSetIpHeaderIncludedRequest>(offset);
1008            // Delegate to tuple encoding.
1009            fidl::encoding::Encode::<SocketSetIpHeaderIncludedRequest, D>::encode(
1010                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1011                encoder,
1012                offset,
1013                _depth,
1014            )
1015        }
1016    }
1017    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1018        fidl::encoding::Encode<SocketSetIpHeaderIncludedRequest, D> for (T0,)
1019    {
1020        #[inline]
1021        unsafe fn encode(
1022            self,
1023            encoder: &mut fidl::encoding::Encoder<'_, D>,
1024            offset: usize,
1025            depth: fidl::encoding::Depth,
1026        ) -> fidl::Result<()> {
1027            encoder.debug_check_bounds::<SocketSetIpHeaderIncludedRequest>(offset);
1028            // Zero out padding regions. There's no need to apply masks
1029            // because the unmasked parts will be overwritten by fields.
1030            // Write the fields.
1031            self.0.encode(encoder, offset + 0, depth)?;
1032            Ok(())
1033        }
1034    }
1035
1036    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1037        for SocketSetIpHeaderIncludedRequest
1038    {
1039        #[inline(always)]
1040        fn new_empty() -> Self {
1041            Self { value: fidl::new_empty!(bool, D) }
1042        }
1043
1044        #[inline]
1045        unsafe fn decode(
1046            &mut self,
1047            decoder: &mut fidl::encoding::Decoder<'_, D>,
1048            offset: usize,
1049            _depth: fidl::encoding::Depth,
1050        ) -> fidl::Result<()> {
1051            decoder.debug_check_bounds::<Self>(offset);
1052            // Verify that padding bytes are zero.
1053            fidl::decode!(bool, D, &mut self.value, decoder, offset + 0, _depth)?;
1054            Ok(())
1055        }
1056    }
1057
1058    impl fidl::encoding::ValueTypeMarker for SocketSetIpv6ChecksumRequest {
1059        type Borrowed<'a> = &'a Self;
1060        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1061            value
1062        }
1063    }
1064
1065    unsafe impl fidl::encoding::TypeMarker for SocketSetIpv6ChecksumRequest {
1066        type Owned = Self;
1067
1068        #[inline(always)]
1069        fn inline_align(_context: fidl::encoding::Context) -> usize {
1070            8
1071        }
1072
1073        #[inline(always)]
1074        fn inline_size(_context: fidl::encoding::Context) -> usize {
1075            16
1076        }
1077    }
1078
1079    unsafe impl<D: fidl::encoding::ResourceDialect>
1080        fidl::encoding::Encode<SocketSetIpv6ChecksumRequest, D> for &SocketSetIpv6ChecksumRequest
1081    {
1082        #[inline]
1083        unsafe fn encode(
1084            self,
1085            encoder: &mut fidl::encoding::Encoder<'_, D>,
1086            offset: usize,
1087            _depth: fidl::encoding::Depth,
1088        ) -> fidl::Result<()> {
1089            encoder.debug_check_bounds::<SocketSetIpv6ChecksumRequest>(offset);
1090            // Delegate to tuple encoding.
1091            fidl::encoding::Encode::<SocketSetIpv6ChecksumRequest, D>::encode(
1092                (<Ipv6ChecksumConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
1093                    &self.config,
1094                ),),
1095                encoder,
1096                offset,
1097                _depth,
1098            )
1099        }
1100    }
1101    unsafe impl<
1102            D: fidl::encoding::ResourceDialect,
1103            T0: fidl::encoding::Encode<Ipv6ChecksumConfiguration, D>,
1104        > fidl::encoding::Encode<SocketSetIpv6ChecksumRequest, D> for (T0,)
1105    {
1106        #[inline]
1107        unsafe fn encode(
1108            self,
1109            encoder: &mut fidl::encoding::Encoder<'_, D>,
1110            offset: usize,
1111            depth: fidl::encoding::Depth,
1112        ) -> fidl::Result<()> {
1113            encoder.debug_check_bounds::<SocketSetIpv6ChecksumRequest>(offset);
1114            // Zero out padding regions. There's no need to apply masks
1115            // because the unmasked parts will be overwritten by fields.
1116            // Write the fields.
1117            self.0.encode(encoder, offset + 0, depth)?;
1118            Ok(())
1119        }
1120    }
1121
1122    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1123        for SocketSetIpv6ChecksumRequest
1124    {
1125        #[inline(always)]
1126        fn new_empty() -> Self {
1127            Self { config: fidl::new_empty!(Ipv6ChecksumConfiguration, D) }
1128        }
1129
1130        #[inline]
1131        unsafe fn decode(
1132            &mut self,
1133            decoder: &mut fidl::encoding::Decoder<'_, D>,
1134            offset: usize,
1135            _depth: fidl::encoding::Depth,
1136        ) -> fidl::Result<()> {
1137            decoder.debug_check_bounds::<Self>(offset);
1138            // Verify that padding bytes are zero.
1139            fidl::decode!(
1140                Ipv6ChecksumConfiguration,
1141                D,
1142                &mut self.config,
1143                decoder,
1144                offset + 0,
1145                _depth
1146            )?;
1147            Ok(())
1148        }
1149    }
1150
1151    impl fidl::encoding::ValueTypeMarker for SocketGetIcmpv6FilterResponse {
1152        type Borrowed<'a> = &'a Self;
1153        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1154            value
1155        }
1156    }
1157
1158    unsafe impl fidl::encoding::TypeMarker for SocketGetIcmpv6FilterResponse {
1159        type Owned = Self;
1160
1161        #[inline(always)]
1162        fn inline_align(_context: fidl::encoding::Context) -> usize {
1163            4
1164        }
1165
1166        #[inline(always)]
1167        fn inline_size(_context: fidl::encoding::Context) -> usize {
1168            32
1169        }
1170        #[inline(always)]
1171        fn encode_is_copy() -> bool {
1172            true
1173        }
1174
1175        #[inline(always)]
1176        fn decode_is_copy() -> bool {
1177            true
1178        }
1179    }
1180
1181    unsafe impl<D: fidl::encoding::ResourceDialect>
1182        fidl::encoding::Encode<SocketGetIcmpv6FilterResponse, D>
1183        for &SocketGetIcmpv6FilterResponse
1184    {
1185        #[inline]
1186        unsafe fn encode(
1187            self,
1188            encoder: &mut fidl::encoding::Encoder<'_, D>,
1189            offset: usize,
1190            _depth: fidl::encoding::Depth,
1191        ) -> fidl::Result<()> {
1192            encoder.debug_check_bounds::<SocketGetIcmpv6FilterResponse>(offset);
1193            unsafe {
1194                // Copy the object into the buffer.
1195                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1196                (buf_ptr as *mut SocketGetIcmpv6FilterResponse)
1197                    .write_unaligned((self as *const SocketGetIcmpv6FilterResponse).read());
1198                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1199                // done second because the memcpy will write garbage to these bytes.
1200            }
1201            Ok(())
1202        }
1203    }
1204    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Icmpv6Filter, D>>
1205        fidl::encoding::Encode<SocketGetIcmpv6FilterResponse, D> for (T0,)
1206    {
1207        #[inline]
1208        unsafe fn encode(
1209            self,
1210            encoder: &mut fidl::encoding::Encoder<'_, D>,
1211            offset: usize,
1212            depth: fidl::encoding::Depth,
1213        ) -> fidl::Result<()> {
1214            encoder.debug_check_bounds::<SocketGetIcmpv6FilterResponse>(offset);
1215            // Zero out padding regions. There's no need to apply masks
1216            // because the unmasked parts will be overwritten by fields.
1217            // Write the fields.
1218            self.0.encode(encoder, offset + 0, depth)?;
1219            Ok(())
1220        }
1221    }
1222
1223    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1224        for SocketGetIcmpv6FilterResponse
1225    {
1226        #[inline(always)]
1227        fn new_empty() -> Self {
1228            Self { filter: fidl::new_empty!(Icmpv6Filter, D) }
1229        }
1230
1231        #[inline]
1232        unsafe fn decode(
1233            &mut self,
1234            decoder: &mut fidl::encoding::Decoder<'_, D>,
1235            offset: usize,
1236            _depth: fidl::encoding::Depth,
1237        ) -> fidl::Result<()> {
1238            decoder.debug_check_bounds::<Self>(offset);
1239            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1240            // Verify that padding bytes are zero.
1241            // Copy from the buffer into the object.
1242            unsafe {
1243                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
1244            }
1245            Ok(())
1246        }
1247    }
1248
1249    impl fidl::encoding::ValueTypeMarker for SocketGetInfoResponse {
1250        type Borrowed<'a> = &'a Self;
1251        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1252            value
1253        }
1254    }
1255
1256    unsafe impl fidl::encoding::TypeMarker for SocketGetInfoResponse {
1257        type Owned = Self;
1258
1259        #[inline(always)]
1260        fn inline_align(_context: fidl::encoding::Context) -> usize {
1261            8
1262        }
1263
1264        #[inline(always)]
1265        fn inline_size(_context: fidl::encoding::Context) -> usize {
1266            24
1267        }
1268    }
1269
1270    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketGetInfoResponse, D>
1271        for &SocketGetInfoResponse
1272    {
1273        #[inline]
1274        unsafe fn encode(
1275            self,
1276            encoder: &mut fidl::encoding::Encoder<'_, D>,
1277            offset: usize,
1278            _depth: fidl::encoding::Depth,
1279        ) -> fidl::Result<()> {
1280            encoder.debug_check_bounds::<SocketGetInfoResponse>(offset);
1281            // Delegate to tuple encoding.
1282            fidl::encoding::Encode::<SocketGetInfoResponse, D>::encode(
1283                (
1284                    <fidl_fuchsia_posix_socket::Domain as fidl::encoding::ValueTypeMarker>::borrow(
1285                        &self.domain,
1286                    ),
1287                    <ProtocolAssociation as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
1288                ),
1289                encoder,
1290                offset,
1291                _depth,
1292            )
1293        }
1294    }
1295    unsafe impl<
1296            D: fidl::encoding::ResourceDialect,
1297            T0: fidl::encoding::Encode<fidl_fuchsia_posix_socket::Domain, D>,
1298            T1: fidl::encoding::Encode<ProtocolAssociation, D>,
1299        > fidl::encoding::Encode<SocketGetInfoResponse, D> for (T0, T1)
1300    {
1301        #[inline]
1302        unsafe fn encode(
1303            self,
1304            encoder: &mut fidl::encoding::Encoder<'_, D>,
1305            offset: usize,
1306            depth: fidl::encoding::Depth,
1307        ) -> fidl::Result<()> {
1308            encoder.debug_check_bounds::<SocketGetInfoResponse>(offset);
1309            // Zero out padding regions. There's no need to apply masks
1310            // because the unmasked parts will be overwritten by fields.
1311            unsafe {
1312                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1313                (ptr as *mut u64).write_unaligned(0);
1314            }
1315            // Write the fields.
1316            self.0.encode(encoder, offset + 0, depth)?;
1317            self.1.encode(encoder, offset + 8, depth)?;
1318            Ok(())
1319        }
1320    }
1321
1322    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketGetInfoResponse {
1323        #[inline(always)]
1324        fn new_empty() -> Self {
1325            Self {
1326                domain: fidl::new_empty!(fidl_fuchsia_posix_socket::Domain, D),
1327                proto: fidl::new_empty!(ProtocolAssociation, D),
1328            }
1329        }
1330
1331        #[inline]
1332        unsafe fn decode(
1333            &mut self,
1334            decoder: &mut fidl::encoding::Decoder<'_, D>,
1335            offset: usize,
1336            _depth: fidl::encoding::Depth,
1337        ) -> fidl::Result<()> {
1338            decoder.debug_check_bounds::<Self>(offset);
1339            // Verify that padding bytes are zero.
1340            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1341            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1342            let mask = 0xffffffffffff0000u64;
1343            let maskedval = padval & mask;
1344            if maskedval != 0 {
1345                return Err(fidl::Error::NonZeroPadding {
1346                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1347                });
1348            }
1349            fidl::decode!(
1350                fidl_fuchsia_posix_socket::Domain,
1351                D,
1352                &mut self.domain,
1353                decoder,
1354                offset + 0,
1355                _depth
1356            )?;
1357            fidl::decode!(ProtocolAssociation, D, &mut self.proto, decoder, offset + 8, _depth)?;
1358            Ok(())
1359        }
1360    }
1361
1362    impl fidl::encoding::ValueTypeMarker for SocketGetIpHeaderIncludedResponse {
1363        type Borrowed<'a> = &'a Self;
1364        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1365            value
1366        }
1367    }
1368
1369    unsafe impl fidl::encoding::TypeMarker for SocketGetIpHeaderIncludedResponse {
1370        type Owned = Self;
1371
1372        #[inline(always)]
1373        fn inline_align(_context: fidl::encoding::Context) -> usize {
1374            1
1375        }
1376
1377        #[inline(always)]
1378        fn inline_size(_context: fidl::encoding::Context) -> usize {
1379            1
1380        }
1381    }
1382
1383    unsafe impl<D: fidl::encoding::ResourceDialect>
1384        fidl::encoding::Encode<SocketGetIpHeaderIncludedResponse, D>
1385        for &SocketGetIpHeaderIncludedResponse
1386    {
1387        #[inline]
1388        unsafe fn encode(
1389            self,
1390            encoder: &mut fidl::encoding::Encoder<'_, D>,
1391            offset: usize,
1392            _depth: fidl::encoding::Depth,
1393        ) -> fidl::Result<()> {
1394            encoder.debug_check_bounds::<SocketGetIpHeaderIncludedResponse>(offset);
1395            // Delegate to tuple encoding.
1396            fidl::encoding::Encode::<SocketGetIpHeaderIncludedResponse, D>::encode(
1397                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1398                encoder,
1399                offset,
1400                _depth,
1401            )
1402        }
1403    }
1404    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1405        fidl::encoding::Encode<SocketGetIpHeaderIncludedResponse, D> for (T0,)
1406    {
1407        #[inline]
1408        unsafe fn encode(
1409            self,
1410            encoder: &mut fidl::encoding::Encoder<'_, D>,
1411            offset: usize,
1412            depth: fidl::encoding::Depth,
1413        ) -> fidl::Result<()> {
1414            encoder.debug_check_bounds::<SocketGetIpHeaderIncludedResponse>(offset);
1415            // Zero out padding regions. There's no need to apply masks
1416            // because the unmasked parts will be overwritten by fields.
1417            // Write the fields.
1418            self.0.encode(encoder, offset + 0, depth)?;
1419            Ok(())
1420        }
1421    }
1422
1423    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1424        for SocketGetIpHeaderIncludedResponse
1425    {
1426        #[inline(always)]
1427        fn new_empty() -> Self {
1428            Self { value: fidl::new_empty!(bool, D) }
1429        }
1430
1431        #[inline]
1432        unsafe fn decode(
1433            &mut self,
1434            decoder: &mut fidl::encoding::Decoder<'_, D>,
1435            offset: usize,
1436            _depth: fidl::encoding::Depth,
1437        ) -> fidl::Result<()> {
1438            decoder.debug_check_bounds::<Self>(offset);
1439            // Verify that padding bytes are zero.
1440            fidl::decode!(bool, D, &mut self.value, decoder, offset + 0, _depth)?;
1441            Ok(())
1442        }
1443    }
1444
1445    impl fidl::encoding::ValueTypeMarker for SocketGetIpv6ChecksumResponse {
1446        type Borrowed<'a> = &'a Self;
1447        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1448            value
1449        }
1450    }
1451
1452    unsafe impl fidl::encoding::TypeMarker for SocketGetIpv6ChecksumResponse {
1453        type Owned = Self;
1454
1455        #[inline(always)]
1456        fn inline_align(_context: fidl::encoding::Context) -> usize {
1457            8
1458        }
1459
1460        #[inline(always)]
1461        fn inline_size(_context: fidl::encoding::Context) -> usize {
1462            16
1463        }
1464    }
1465
1466    unsafe impl<D: fidl::encoding::ResourceDialect>
1467        fidl::encoding::Encode<SocketGetIpv6ChecksumResponse, D>
1468        for &SocketGetIpv6ChecksumResponse
1469    {
1470        #[inline]
1471        unsafe fn encode(
1472            self,
1473            encoder: &mut fidl::encoding::Encoder<'_, D>,
1474            offset: usize,
1475            _depth: fidl::encoding::Depth,
1476        ) -> fidl::Result<()> {
1477            encoder.debug_check_bounds::<SocketGetIpv6ChecksumResponse>(offset);
1478            // Delegate to tuple encoding.
1479            fidl::encoding::Encode::<SocketGetIpv6ChecksumResponse, D>::encode(
1480                (<Ipv6ChecksumConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
1481                    &self.config,
1482                ),),
1483                encoder,
1484                offset,
1485                _depth,
1486            )
1487        }
1488    }
1489    unsafe impl<
1490            D: fidl::encoding::ResourceDialect,
1491            T0: fidl::encoding::Encode<Ipv6ChecksumConfiguration, D>,
1492        > fidl::encoding::Encode<SocketGetIpv6ChecksumResponse, D> for (T0,)
1493    {
1494        #[inline]
1495        unsafe fn encode(
1496            self,
1497            encoder: &mut fidl::encoding::Encoder<'_, D>,
1498            offset: usize,
1499            depth: fidl::encoding::Depth,
1500        ) -> fidl::Result<()> {
1501            encoder.debug_check_bounds::<SocketGetIpv6ChecksumResponse>(offset);
1502            // Zero out padding regions. There's no need to apply masks
1503            // because the unmasked parts will be overwritten by fields.
1504            // Write the fields.
1505            self.0.encode(encoder, offset + 0, depth)?;
1506            Ok(())
1507        }
1508    }
1509
1510    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1511        for SocketGetIpv6ChecksumResponse
1512    {
1513        #[inline(always)]
1514        fn new_empty() -> Self {
1515            Self { config: fidl::new_empty!(Ipv6ChecksumConfiguration, D) }
1516        }
1517
1518        #[inline]
1519        unsafe fn decode(
1520            &mut self,
1521            decoder: &mut fidl::encoding::Decoder<'_, D>,
1522            offset: usize,
1523            _depth: fidl::encoding::Depth,
1524        ) -> fidl::Result<()> {
1525            decoder.debug_check_bounds::<Self>(offset);
1526            // Verify that padding bytes are zero.
1527            fidl::decode!(
1528                Ipv6ChecksumConfiguration,
1529                D,
1530                &mut self.config,
1531                decoder,
1532                offset + 0,
1533                _depth
1534            )?;
1535            Ok(())
1536        }
1537    }
1538
1539    impl fidl::encoding::ValueTypeMarker for SocketRecvMsgResponse {
1540        type Borrowed<'a> = &'a Self;
1541        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1542            value
1543        }
1544    }
1545
1546    unsafe impl fidl::encoding::TypeMarker for SocketRecvMsgResponse {
1547        type Owned = Self;
1548
1549        #[inline(always)]
1550        fn inline_align(_context: fidl::encoding::Context) -> usize {
1551            8
1552        }
1553
1554        #[inline(always)]
1555        fn inline_size(_context: fidl::encoding::Context) -> usize {
1556            56
1557        }
1558    }
1559
1560    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketRecvMsgResponse, D>
1561        for &SocketRecvMsgResponse
1562    {
1563        #[inline]
1564        unsafe fn encode(
1565            self,
1566            encoder: &mut fidl::encoding::Encoder<'_, D>,
1567            offset: usize,
1568            _depth: fidl::encoding::Depth,
1569        ) -> fidl::Result<()> {
1570            encoder.debug_check_bounds::<SocketRecvMsgResponse>(offset);
1571            // Delegate to tuple encoding.
1572            fidl::encoding::Encode::<SocketRecvMsgResponse, D>::encode(
1573                (
1574                    <fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
1575                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
1576                    <fidl_fuchsia_posix_socket::NetworkSocketRecvControlData as fidl::encoding::ValueTypeMarker>::borrow(&self.control),
1577                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.truncated),
1578                ),
1579                encoder, offset, _depth
1580            )
1581        }
1582    }
1583    unsafe impl<
1584            D: fidl::encoding::ResourceDialect,
1585            T0: fidl::encoding::Encode<
1586                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
1587                D,
1588            >,
1589            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
1590            T2: fidl::encoding::Encode<fidl_fuchsia_posix_socket::NetworkSocketRecvControlData, D>,
1591            T3: fidl::encoding::Encode<u32, D>,
1592        > fidl::encoding::Encode<SocketRecvMsgResponse, D> for (T0, T1, T2, T3)
1593    {
1594        #[inline]
1595        unsafe fn encode(
1596            self,
1597            encoder: &mut fidl::encoding::Encoder<'_, D>,
1598            offset: usize,
1599            depth: fidl::encoding::Depth,
1600        ) -> fidl::Result<()> {
1601            encoder.debug_check_bounds::<SocketRecvMsgResponse>(offset);
1602            // Zero out padding regions. There's no need to apply masks
1603            // because the unmasked parts will be overwritten by fields.
1604            unsafe {
1605                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
1606                (ptr as *mut u64).write_unaligned(0);
1607            }
1608            // Write the fields.
1609            self.0.encode(encoder, offset + 0, depth)?;
1610            self.1.encode(encoder, offset + 16, depth)?;
1611            self.2.encode(encoder, offset + 32, depth)?;
1612            self.3.encode(encoder, offset + 48, depth)?;
1613            Ok(())
1614        }
1615    }
1616
1617    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketRecvMsgResponse {
1618        #[inline(always)]
1619        fn new_empty() -> Self {
1620            Self {
1621                addr: fidl::new_empty!(
1622                    fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
1623                    D
1624                ),
1625                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
1626                control: fidl::new_empty!(
1627                    fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
1628                    D
1629                ),
1630                truncated: fidl::new_empty!(u32, D),
1631            }
1632        }
1633
1634        #[inline]
1635        unsafe fn decode(
1636            &mut self,
1637            decoder: &mut fidl::encoding::Decoder<'_, D>,
1638            offset: usize,
1639            _depth: fidl::encoding::Depth,
1640        ) -> fidl::Result<()> {
1641            decoder.debug_check_bounds::<Self>(offset);
1642            // Verify that padding bytes are zero.
1643            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
1644            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1645            let mask = 0xffffffff00000000u64;
1646            let maskedval = padval & mask;
1647            if maskedval != 0 {
1648                return Err(fidl::Error::NonZeroPadding {
1649                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
1650                });
1651            }
1652            fidl::decode!(
1653                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
1654                D,
1655                &mut self.addr,
1656                decoder,
1657                offset + 0,
1658                _depth
1659            )?;
1660            fidl::decode!(
1661                fidl::encoding::UnboundedVector<u8>,
1662                D,
1663                &mut self.data,
1664                decoder,
1665                offset + 16,
1666                _depth
1667            )?;
1668            fidl::decode!(
1669                fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
1670                D,
1671                &mut self.control,
1672                decoder,
1673                offset + 32,
1674                _depth
1675            )?;
1676            fidl::decode!(u32, D, &mut self.truncated, decoder, offset + 48, _depth)?;
1677            Ok(())
1678        }
1679    }
1680
1681    impl fidl::encoding::ValueTypeMarker for Ipv6ChecksumConfiguration {
1682        type Borrowed<'a> = &'a Self;
1683        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1684            value
1685        }
1686    }
1687
1688    unsafe impl fidl::encoding::TypeMarker for Ipv6ChecksumConfiguration {
1689        type Owned = Self;
1690
1691        #[inline(always)]
1692        fn inline_align(_context: fidl::encoding::Context) -> usize {
1693            8
1694        }
1695
1696        #[inline(always)]
1697        fn inline_size(_context: fidl::encoding::Context) -> usize {
1698            16
1699        }
1700    }
1701
1702    unsafe impl<D: fidl::encoding::ResourceDialect>
1703        fidl::encoding::Encode<Ipv6ChecksumConfiguration, D> for &Ipv6ChecksumConfiguration
1704    {
1705        #[inline]
1706        unsafe fn encode(
1707            self,
1708            encoder: &mut fidl::encoding::Encoder<'_, D>,
1709            offset: usize,
1710            _depth: fidl::encoding::Depth,
1711        ) -> fidl::Result<()> {
1712            encoder.debug_check_bounds::<Ipv6ChecksumConfiguration>(offset);
1713            encoder.write_num::<u64>(self.ordinal(), offset);
1714            match self {
1715                Ipv6ChecksumConfiguration::Disabled(ref val) => {
1716                    fidl::encoding::encode_in_envelope::<Empty, D>(
1717                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
1718                        encoder,
1719                        offset + 8,
1720                        _depth,
1721                    )
1722                }
1723                Ipv6ChecksumConfiguration::Offset(ref val) => {
1724                    fidl::encoding::encode_in_envelope::<i32, D>(
1725                        <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
1726                        encoder,
1727                        offset + 8,
1728                        _depth,
1729                    )
1730                }
1731            }
1732        }
1733    }
1734
1735    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1736        for Ipv6ChecksumConfiguration
1737    {
1738        #[inline(always)]
1739        fn new_empty() -> Self {
1740            Self::Disabled(fidl::new_empty!(Empty, D))
1741        }
1742
1743        #[inline]
1744        unsafe fn decode(
1745            &mut self,
1746            decoder: &mut fidl::encoding::Decoder<'_, D>,
1747            offset: usize,
1748            mut depth: fidl::encoding::Depth,
1749        ) -> fidl::Result<()> {
1750            decoder.debug_check_bounds::<Self>(offset);
1751            #[allow(unused_variables)]
1752            let next_out_of_line = decoder.next_out_of_line();
1753            let handles_before = decoder.remaining_handles();
1754            let (ordinal, inlined, num_bytes, num_handles) =
1755                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1756
1757            let member_inline_size = match ordinal {
1758                1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1759                2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1760                _ => return Err(fidl::Error::UnknownUnionTag),
1761            };
1762
1763            if inlined != (member_inline_size <= 4) {
1764                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1765            }
1766            let _inner_offset;
1767            if inlined {
1768                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1769                _inner_offset = offset + 8;
1770            } else {
1771                depth.increment()?;
1772                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1773            }
1774            match ordinal {
1775                1 => {
1776                    #[allow(irrefutable_let_patterns)]
1777                    if let Ipv6ChecksumConfiguration::Disabled(_) = self {
1778                        // Do nothing, read the value into the object
1779                    } else {
1780                        // Initialize `self` to the right variant
1781                        *self = Ipv6ChecksumConfiguration::Disabled(fidl::new_empty!(Empty, D));
1782                    }
1783                    #[allow(irrefutable_let_patterns)]
1784                    if let Ipv6ChecksumConfiguration::Disabled(ref mut val) = self {
1785                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
1786                    } else {
1787                        unreachable!()
1788                    }
1789                }
1790                2 => {
1791                    #[allow(irrefutable_let_patterns)]
1792                    if let Ipv6ChecksumConfiguration::Offset(_) = self {
1793                        // Do nothing, read the value into the object
1794                    } else {
1795                        // Initialize `self` to the right variant
1796                        *self = Ipv6ChecksumConfiguration::Offset(fidl::new_empty!(i32, D));
1797                    }
1798                    #[allow(irrefutable_let_patterns)]
1799                    if let Ipv6ChecksumConfiguration::Offset(ref mut val) = self {
1800                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
1801                    } else {
1802                        unreachable!()
1803                    }
1804                }
1805                ordinal => panic!("unexpected ordinal {:?}", ordinal),
1806            }
1807            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1808                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1809            }
1810            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1811                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1812            }
1813            Ok(())
1814        }
1815    }
1816
1817    impl fidl::encoding::ValueTypeMarker for ProtocolAssociation {
1818        type Borrowed<'a> = &'a Self;
1819        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1820            value
1821        }
1822    }
1823
1824    unsafe impl fidl::encoding::TypeMarker for ProtocolAssociation {
1825        type Owned = Self;
1826
1827        #[inline(always)]
1828        fn inline_align(_context: fidl::encoding::Context) -> usize {
1829            8
1830        }
1831
1832        #[inline(always)]
1833        fn inline_size(_context: fidl::encoding::Context) -> usize {
1834            16
1835        }
1836    }
1837
1838    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProtocolAssociation, D>
1839        for &ProtocolAssociation
1840    {
1841        #[inline]
1842        unsafe fn encode(
1843            self,
1844            encoder: &mut fidl::encoding::Encoder<'_, D>,
1845            offset: usize,
1846            _depth: fidl::encoding::Depth,
1847        ) -> fidl::Result<()> {
1848            encoder.debug_check_bounds::<ProtocolAssociation>(offset);
1849            encoder.write_num::<u64>(self.ordinal(), offset);
1850            match self {
1851                ProtocolAssociation::Unassociated(ref val) => {
1852                    fidl::encoding::encode_in_envelope::<Empty, D>(
1853                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
1854                        encoder,
1855                        offset + 8,
1856                        _depth,
1857                    )
1858                }
1859                ProtocolAssociation::Associated(ref val) => {
1860                    fidl::encoding::encode_in_envelope::<u8, D>(
1861                        <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
1862                        encoder,
1863                        offset + 8,
1864                        _depth,
1865                    )
1866                }
1867            }
1868        }
1869    }
1870
1871    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProtocolAssociation {
1872        #[inline(always)]
1873        fn new_empty() -> Self {
1874            Self::Unassociated(fidl::new_empty!(Empty, D))
1875        }
1876
1877        #[inline]
1878        unsafe fn decode(
1879            &mut self,
1880            decoder: &mut fidl::encoding::Decoder<'_, D>,
1881            offset: usize,
1882            mut depth: fidl::encoding::Depth,
1883        ) -> fidl::Result<()> {
1884            decoder.debug_check_bounds::<Self>(offset);
1885            #[allow(unused_variables)]
1886            let next_out_of_line = decoder.next_out_of_line();
1887            let handles_before = decoder.remaining_handles();
1888            let (ordinal, inlined, num_bytes, num_handles) =
1889                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1890
1891            let member_inline_size = match ordinal {
1892                1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1893                2 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1894                _ => return Err(fidl::Error::UnknownUnionTag),
1895            };
1896
1897            if inlined != (member_inline_size <= 4) {
1898                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1899            }
1900            let _inner_offset;
1901            if inlined {
1902                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1903                _inner_offset = offset + 8;
1904            } else {
1905                depth.increment()?;
1906                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1907            }
1908            match ordinal {
1909                1 => {
1910                    #[allow(irrefutable_let_patterns)]
1911                    if let ProtocolAssociation::Unassociated(_) = self {
1912                        // Do nothing, read the value into the object
1913                    } else {
1914                        // Initialize `self` to the right variant
1915                        *self = ProtocolAssociation::Unassociated(fidl::new_empty!(Empty, D));
1916                    }
1917                    #[allow(irrefutable_let_patterns)]
1918                    if let ProtocolAssociation::Unassociated(ref mut val) = self {
1919                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
1920                    } else {
1921                        unreachable!()
1922                    }
1923                }
1924                2 => {
1925                    #[allow(irrefutable_let_patterns)]
1926                    if let ProtocolAssociation::Associated(_) = self {
1927                        // Do nothing, read the value into the object
1928                    } else {
1929                        // Initialize `self` to the right variant
1930                        *self = ProtocolAssociation::Associated(fidl::new_empty!(u8, D));
1931                    }
1932                    #[allow(irrefutable_let_patterns)]
1933                    if let ProtocolAssociation::Associated(ref mut val) = self {
1934                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
1935                    } else {
1936                        unreachable!()
1937                    }
1938                }
1939                ordinal => panic!("unexpected ordinal {:?}", ordinal),
1940            }
1941            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1942                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1943            }
1944            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1945                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1946            }
1947            Ok(())
1948        }
1949    }
1950}
fidl_fuchsia_posix_socket_raw_common/fidl_fuchsia_posix_socket_raw_common.rs

fidl_fuchsia_posix_socket_raw_common/
fidl_fuchsia_posix_socket_raw_common.rs
