fidl_fuchsia_starnix_binder__common/
fidl_fuchsia_starnix_binder__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 type Fd = i32;
12
13pub const MAX_HANDLE_COUNT: u64 = 8;
14
15pub const MAX_PATH_LENGTH: u64 = 4095;
16
17pub const MAX_REQUEST_COUNT: u64 = 16;
18
19pub const MAX_WRITE_BYTES: u64 = 32768;
20
21pub const UNIX_DOMAIN_SOCKET_PROTOCOL_NAME: &str = "fuchsia.starnix.binder/UnixDomainSocket";
22
23bitflags! {
24    /// The flags associated with an opened file.
25    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
26    pub struct FileFlags: u64 {
27        /// The owner can read the file.
28        const RIGHT_READABLE = 1;
29        /// The owner can write to fhe file.
30        const RIGHT_WRITABLE = 2;
31        /// The file is a directory.
32        const DIRECTORY = 4096;
33    }
34}
35
36impl FileFlags {
37    #[inline(always)]
38    pub fn from_bits_allow_unknown(bits: u64) -> Self {
39        Self::from_bits_retain(bits)
40    }
41
42    #[inline(always)]
43    pub fn has_unknown_bits(&self) -> bool {
44        self.get_unknown_bits() != 0
45    }
46
47    #[inline(always)]
48    pub fn get_unknown_bits(&self) -> u64 {
49        self.bits() & !Self::all().bits()
50    }
51}
52
53bitflags! {
54    /// The flags when reading from an unix domain socket
55    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
56    pub struct ReadFlags: u64 {
57        /// When set, the data must not be removed from the queue and the next read
58        /// must resend the same data.
59        const PEEK = 1;
60    }
61}
62
63impl ReadFlags {
64    #[inline(always)]
65    pub fn from_bits_allow_unknown(bits: u64) -> Self {
66        Self::from_bits_retain(bits)
67    }
68
69    #[inline(always)]
70    pub fn has_unknown_bits(&self) -> bool {
71        self.get_unknown_bits() != 0
72    }
73
74    #[inline(always)]
75    pub fn get_unknown_bits(&self) -> u64 {
76        self.bits() & !Self::all().bits()
77    }
78}
79
80#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
81#[repr(C)]
82pub struct BinderIoctlRequest {
83    pub tid: u64,
84    pub request: u32,
85    pub parameter: u64,
86}
87
88impl fidl::Persistable for BinderIoctlRequest {}
89
90#[derive(Clone, Debug, Default, PartialEq)]
91pub struct UnixDomainSocketGetEventRequest {
92    #[doc(hidden)]
93    pub __source_breaking: fidl::marker::SourceBreaking,
94}
95
96impl fidl::Persistable for UnixDomainSocketGetEventRequest {}
97
98#[derive(Clone, Debug, Default, PartialEq)]
99pub struct UnixDomainSocketReadRequest {
100    pub count: Option<u64>,
101    pub flags: Option<ReadFlags>,
102    #[doc(hidden)]
103    pub __source_breaking: fidl::marker::SourceBreaking,
104}
105
106impl fidl::Persistable for UnixDomainSocketReadRequest {}
107
108#[derive(Clone, Debug, Default, PartialEq)]
109pub struct UnixDomainSocketWriteResponse {
110    pub actual_count: Option<u64>,
111    #[doc(hidden)]
112    pub __source_breaking: fidl::marker::SourceBreaking,
113}
114
115impl fidl::Persistable for UnixDomainSocketWriteResponse {}
116
117mod internal {
118    use super::*;
119    unsafe impl fidl::encoding::TypeMarker for FileFlags {
120        type Owned = Self;
121
122        #[inline(always)]
123        fn inline_align(_context: fidl::encoding::Context) -> usize {
124            8
125        }
126
127        #[inline(always)]
128        fn inline_size(_context: fidl::encoding::Context) -> usize {
129            8
130        }
131    }
132
133    impl fidl::encoding::ValueTypeMarker for FileFlags {
134        type Borrowed<'a> = Self;
135        #[inline(always)]
136        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
137            *value
138        }
139    }
140
141    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FileFlags {
142        #[inline]
143        unsafe fn encode(
144            self,
145            encoder: &mut fidl::encoding::Encoder<'_, D>,
146            offset: usize,
147            _depth: fidl::encoding::Depth,
148        ) -> fidl::Result<()> {
149            encoder.debug_check_bounds::<Self>(offset);
150            encoder.write_num(self.bits(), offset);
151            Ok(())
152        }
153    }
154
155    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileFlags {
156        #[inline(always)]
157        fn new_empty() -> Self {
158            Self::empty()
159        }
160
161        #[inline]
162        unsafe fn decode(
163            &mut self,
164            decoder: &mut fidl::encoding::Decoder<'_, D>,
165            offset: usize,
166            _depth: fidl::encoding::Depth,
167        ) -> fidl::Result<()> {
168            decoder.debug_check_bounds::<Self>(offset);
169            let prim = decoder.read_num::<u64>(offset);
170            *self = Self::from_bits_allow_unknown(prim);
171            Ok(())
172        }
173    }
174    unsafe impl fidl::encoding::TypeMarker for ReadFlags {
175        type Owned = Self;
176
177        #[inline(always)]
178        fn inline_align(_context: fidl::encoding::Context) -> usize {
179            8
180        }
181
182        #[inline(always)]
183        fn inline_size(_context: fidl::encoding::Context) -> usize {
184            8
185        }
186    }
187
188    impl fidl::encoding::ValueTypeMarker for ReadFlags {
189        type Borrowed<'a> = Self;
190        #[inline(always)]
191        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
192            *value
193        }
194    }
195
196    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReadFlags {
197        #[inline]
198        unsafe fn encode(
199            self,
200            encoder: &mut fidl::encoding::Encoder<'_, D>,
201            offset: usize,
202            _depth: fidl::encoding::Depth,
203        ) -> fidl::Result<()> {
204            encoder.debug_check_bounds::<Self>(offset);
205            encoder.write_num(self.bits(), offset);
206            Ok(())
207        }
208    }
209
210    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReadFlags {
211        #[inline(always)]
212        fn new_empty() -> Self {
213            Self::empty()
214        }
215
216        #[inline]
217        unsafe fn decode(
218            &mut self,
219            decoder: &mut fidl::encoding::Decoder<'_, D>,
220            offset: usize,
221            _depth: fidl::encoding::Depth,
222        ) -> fidl::Result<()> {
223            decoder.debug_check_bounds::<Self>(offset);
224            let prim = decoder.read_num::<u64>(offset);
225            *self = Self::from_bits_allow_unknown(prim);
226            Ok(())
227        }
228    }
229
230    impl fidl::encoding::ValueTypeMarker for BinderIoctlRequest {
231        type Borrowed<'a> = &'a Self;
232        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
233            value
234        }
235    }
236
237    unsafe impl fidl::encoding::TypeMarker for BinderIoctlRequest {
238        type Owned = Self;
239
240        #[inline(always)]
241        fn inline_align(_context: fidl::encoding::Context) -> usize {
242            8
243        }
244
245        #[inline(always)]
246        fn inline_size(_context: fidl::encoding::Context) -> usize {
247            24
248        }
249    }
250
251    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BinderIoctlRequest, D>
252        for &BinderIoctlRequest
253    {
254        #[inline]
255        unsafe fn encode(
256            self,
257            encoder: &mut fidl::encoding::Encoder<'_, D>,
258            offset: usize,
259            _depth: fidl::encoding::Depth,
260        ) -> fidl::Result<()> {
261            encoder.debug_check_bounds::<BinderIoctlRequest>(offset);
262            unsafe {
263                // Copy the object into the buffer.
264                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
265                (buf_ptr as *mut BinderIoctlRequest)
266                    .write_unaligned((self as *const BinderIoctlRequest).read());
267                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
268                // done second because the memcpy will write garbage to these bytes.
269                let padding_ptr = buf_ptr.offset(8) as *mut u64;
270                let padding_mask = 0xffffffff00000000u64;
271                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
272            }
273            Ok(())
274        }
275    }
276    unsafe impl<
277            D: fidl::encoding::ResourceDialect,
278            T0: fidl::encoding::Encode<u64, D>,
279            T1: fidl::encoding::Encode<u32, D>,
280            T2: fidl::encoding::Encode<u64, D>,
281        > fidl::encoding::Encode<BinderIoctlRequest, D> for (T0, T1, T2)
282    {
283        #[inline]
284        unsafe fn encode(
285            self,
286            encoder: &mut fidl::encoding::Encoder<'_, D>,
287            offset: usize,
288            depth: fidl::encoding::Depth,
289        ) -> fidl::Result<()> {
290            encoder.debug_check_bounds::<BinderIoctlRequest>(offset);
291            // Zero out padding regions. There's no need to apply masks
292            // because the unmasked parts will be overwritten by fields.
293            unsafe {
294                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
295                (ptr as *mut u64).write_unaligned(0);
296            }
297            // Write the fields.
298            self.0.encode(encoder, offset + 0, depth)?;
299            self.1.encode(encoder, offset + 8, depth)?;
300            self.2.encode(encoder, offset + 16, depth)?;
301            Ok(())
302        }
303    }
304
305    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BinderIoctlRequest {
306        #[inline(always)]
307        fn new_empty() -> Self {
308            Self {
309                tid: fidl::new_empty!(u64, D),
310                request: fidl::new_empty!(u32, D),
311                parameter: fidl::new_empty!(u64, D),
312            }
313        }
314
315        #[inline]
316        unsafe fn decode(
317            &mut self,
318            decoder: &mut fidl::encoding::Decoder<'_, D>,
319            offset: usize,
320            _depth: fidl::encoding::Depth,
321        ) -> fidl::Result<()> {
322            decoder.debug_check_bounds::<Self>(offset);
323            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
324            // Verify that padding bytes are zero.
325            let ptr = unsafe { buf_ptr.offset(8) };
326            let padval = unsafe { (ptr as *const u64).read_unaligned() };
327            let mask = 0xffffffff00000000u64;
328            let maskedval = padval & mask;
329            if maskedval != 0 {
330                return Err(fidl::Error::NonZeroPadding {
331                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
332                });
333            }
334            // Copy from the buffer into the object.
335            unsafe {
336                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
337            }
338            Ok(())
339        }
340    }
341
342    impl UnixDomainSocketGetEventRequest {
343        #[inline(always)]
344        fn max_ordinal_present(&self) -> u64 {
345            0
346        }
347    }
348
349    impl fidl::encoding::ValueTypeMarker for UnixDomainSocketGetEventRequest {
350        type Borrowed<'a> = &'a Self;
351        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
352            value
353        }
354    }
355
356    unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketGetEventRequest {
357        type Owned = Self;
358
359        #[inline(always)]
360        fn inline_align(_context: fidl::encoding::Context) -> usize {
361            8
362        }
363
364        #[inline(always)]
365        fn inline_size(_context: fidl::encoding::Context) -> usize {
366            16
367        }
368    }
369
370    unsafe impl<D: fidl::encoding::ResourceDialect>
371        fidl::encoding::Encode<UnixDomainSocketGetEventRequest, D>
372        for &UnixDomainSocketGetEventRequest
373    {
374        unsafe fn encode(
375            self,
376            encoder: &mut fidl::encoding::Encoder<'_, D>,
377            offset: usize,
378            mut depth: fidl::encoding::Depth,
379        ) -> fidl::Result<()> {
380            encoder.debug_check_bounds::<UnixDomainSocketGetEventRequest>(offset);
381            // Vector header
382            let max_ordinal: u64 = self.max_ordinal_present();
383            encoder.write_num(max_ordinal, offset);
384            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
385            // Calling encoder.out_of_line_offset(0) is not allowed.
386            if max_ordinal == 0 {
387                return Ok(());
388            }
389            depth.increment()?;
390            let envelope_size = 8;
391            let bytes_len = max_ordinal as usize * envelope_size;
392            #[allow(unused_variables)]
393            let offset = encoder.out_of_line_offset(bytes_len);
394            let mut _prev_end_offset: usize = 0;
395
396            Ok(())
397        }
398    }
399
400    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
401        for UnixDomainSocketGetEventRequest
402    {
403        #[inline(always)]
404        fn new_empty() -> Self {
405            Self::default()
406        }
407
408        unsafe fn decode(
409            &mut self,
410            decoder: &mut fidl::encoding::Decoder<'_, D>,
411            offset: usize,
412            mut depth: fidl::encoding::Depth,
413        ) -> fidl::Result<()> {
414            decoder.debug_check_bounds::<Self>(offset);
415            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
416                None => return Err(fidl::Error::NotNullable),
417                Some(len) => len,
418            };
419            // Calling decoder.out_of_line_offset(0) is not allowed.
420            if len == 0 {
421                return Ok(());
422            };
423            depth.increment()?;
424            let envelope_size = 8;
425            let bytes_len = len * envelope_size;
426            let offset = decoder.out_of_line_offset(bytes_len)?;
427            // Decode the envelope for each type.
428            let mut _next_ordinal_to_read = 0;
429            let mut next_offset = offset;
430            let end_offset = offset + bytes_len;
431
432            // Decode the remaining unknown envelopes.
433            while next_offset < end_offset {
434                _next_ordinal_to_read += 1;
435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
436                next_offset += envelope_size;
437            }
438
439            Ok(())
440        }
441    }
442
443    impl UnixDomainSocketReadRequest {
444        #[inline(always)]
445        fn max_ordinal_present(&self) -> u64 {
446            if let Some(_) = self.flags {
447                return 2;
448            }
449            if let Some(_) = self.count {
450                return 1;
451            }
452            0
453        }
454    }
455
456    impl fidl::encoding::ValueTypeMarker for UnixDomainSocketReadRequest {
457        type Borrowed<'a> = &'a Self;
458        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
459            value
460        }
461    }
462
463    unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketReadRequest {
464        type Owned = Self;
465
466        #[inline(always)]
467        fn inline_align(_context: fidl::encoding::Context) -> usize {
468            8
469        }
470
471        #[inline(always)]
472        fn inline_size(_context: fidl::encoding::Context) -> usize {
473            16
474        }
475    }
476
477    unsafe impl<D: fidl::encoding::ResourceDialect>
478        fidl::encoding::Encode<UnixDomainSocketReadRequest, D> for &UnixDomainSocketReadRequest
479    {
480        unsafe fn encode(
481            self,
482            encoder: &mut fidl::encoding::Encoder<'_, D>,
483            offset: usize,
484            mut depth: fidl::encoding::Depth,
485        ) -> fidl::Result<()> {
486            encoder.debug_check_bounds::<UnixDomainSocketReadRequest>(offset);
487            // Vector header
488            let max_ordinal: u64 = self.max_ordinal_present();
489            encoder.write_num(max_ordinal, offset);
490            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
491            // Calling encoder.out_of_line_offset(0) is not allowed.
492            if max_ordinal == 0 {
493                return Ok(());
494            }
495            depth.increment()?;
496            let envelope_size = 8;
497            let bytes_len = max_ordinal as usize * envelope_size;
498            #[allow(unused_variables)]
499            let offset = encoder.out_of_line_offset(bytes_len);
500            let mut _prev_end_offset: usize = 0;
501            if 1 > max_ordinal {
502                return Ok(());
503            }
504
505            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
506            // are envelope_size bytes.
507            let cur_offset: usize = (1 - 1) * envelope_size;
508
509            // Zero reserved fields.
510            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
511
512            // Safety:
513            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
514            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
515            //   envelope_size bytes, there is always sufficient room.
516            fidl::encoding::encode_in_envelope_optional::<u64, D>(
517                self.count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
518                encoder,
519                offset + cur_offset,
520                depth,
521            )?;
522
523            _prev_end_offset = cur_offset + envelope_size;
524            if 2 > max_ordinal {
525                return Ok(());
526            }
527
528            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
529            // are envelope_size bytes.
530            let cur_offset: usize = (2 - 1) * envelope_size;
531
532            // Zero reserved fields.
533            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
534
535            // Safety:
536            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
537            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
538            //   envelope_size bytes, there is always sufficient room.
539            fidl::encoding::encode_in_envelope_optional::<ReadFlags, D>(
540                self.flags.as_ref().map(<ReadFlags as fidl::encoding::ValueTypeMarker>::borrow),
541                encoder,
542                offset + cur_offset,
543                depth,
544            )?;
545
546            _prev_end_offset = cur_offset + envelope_size;
547
548            Ok(())
549        }
550    }
551
552    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
553        for UnixDomainSocketReadRequest
554    {
555        #[inline(always)]
556        fn new_empty() -> Self {
557            Self::default()
558        }
559
560        unsafe fn decode(
561            &mut self,
562            decoder: &mut fidl::encoding::Decoder<'_, D>,
563            offset: usize,
564            mut depth: fidl::encoding::Depth,
565        ) -> fidl::Result<()> {
566            decoder.debug_check_bounds::<Self>(offset);
567            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
568                None => return Err(fidl::Error::NotNullable),
569                Some(len) => len,
570            };
571            // Calling decoder.out_of_line_offset(0) is not allowed.
572            if len == 0 {
573                return Ok(());
574            };
575            depth.increment()?;
576            let envelope_size = 8;
577            let bytes_len = len * envelope_size;
578            let offset = decoder.out_of_line_offset(bytes_len)?;
579            // Decode the envelope for each type.
580            let mut _next_ordinal_to_read = 0;
581            let mut next_offset = offset;
582            let end_offset = offset + bytes_len;
583            _next_ordinal_to_read += 1;
584            if next_offset >= end_offset {
585                return Ok(());
586            }
587
588            // Decode unknown envelopes for gaps in ordinals.
589            while _next_ordinal_to_read < 1 {
590                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591                _next_ordinal_to_read += 1;
592                next_offset += envelope_size;
593            }
594
595            let next_out_of_line = decoder.next_out_of_line();
596            let handles_before = decoder.remaining_handles();
597            if let Some((inlined, num_bytes, num_handles)) =
598                fidl::encoding::decode_envelope_header(decoder, next_offset)?
599            {
600                let member_inline_size =
601                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
602                if inlined != (member_inline_size <= 4) {
603                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
604                }
605                let inner_offset;
606                let mut inner_depth = depth.clone();
607                if inlined {
608                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
609                    inner_offset = next_offset;
610                } else {
611                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
612                    inner_depth.increment()?;
613                }
614                let val_ref = self.count.get_or_insert_with(|| fidl::new_empty!(u64, D));
615                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
617                {
618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
619                }
620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
622                }
623            }
624
625            next_offset += envelope_size;
626            _next_ordinal_to_read += 1;
627            if next_offset >= end_offset {
628                return Ok(());
629            }
630
631            // Decode unknown envelopes for gaps in ordinals.
632            while _next_ordinal_to_read < 2 {
633                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
634                _next_ordinal_to_read += 1;
635                next_offset += envelope_size;
636            }
637
638            let next_out_of_line = decoder.next_out_of_line();
639            let handles_before = decoder.remaining_handles();
640            if let Some((inlined, num_bytes, num_handles)) =
641                fidl::encoding::decode_envelope_header(decoder, next_offset)?
642            {
643                let member_inline_size =
644                    <ReadFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
645                if inlined != (member_inline_size <= 4) {
646                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
647                }
648                let inner_offset;
649                let mut inner_depth = depth.clone();
650                if inlined {
651                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
652                    inner_offset = next_offset;
653                } else {
654                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
655                    inner_depth.increment()?;
656                }
657                let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(ReadFlags, D));
658                fidl::decode!(ReadFlags, D, val_ref, decoder, inner_offset, inner_depth)?;
659                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
660                {
661                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
662                }
663                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
664                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
665                }
666            }
667
668            next_offset += envelope_size;
669
670            // Decode the remaining unknown envelopes.
671            while next_offset < end_offset {
672                _next_ordinal_to_read += 1;
673                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
674                next_offset += envelope_size;
675            }
676
677            Ok(())
678        }
679    }
680
681    impl UnixDomainSocketWriteResponse {
682        #[inline(always)]
683        fn max_ordinal_present(&self) -> u64 {
684            if let Some(_) = self.actual_count {
685                return 1;
686            }
687            0
688        }
689    }
690
691    impl fidl::encoding::ValueTypeMarker for UnixDomainSocketWriteResponse {
692        type Borrowed<'a> = &'a Self;
693        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
694            value
695        }
696    }
697
698    unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketWriteResponse {
699        type Owned = Self;
700
701        #[inline(always)]
702        fn inline_align(_context: fidl::encoding::Context) -> usize {
703            8
704        }
705
706        #[inline(always)]
707        fn inline_size(_context: fidl::encoding::Context) -> usize {
708            16
709        }
710    }
711
712    unsafe impl<D: fidl::encoding::ResourceDialect>
713        fidl::encoding::Encode<UnixDomainSocketWriteResponse, D>
714        for &UnixDomainSocketWriteResponse
715    {
716        unsafe fn encode(
717            self,
718            encoder: &mut fidl::encoding::Encoder<'_, D>,
719            offset: usize,
720            mut depth: fidl::encoding::Depth,
721        ) -> fidl::Result<()> {
722            encoder.debug_check_bounds::<UnixDomainSocketWriteResponse>(offset);
723            // Vector header
724            let max_ordinal: u64 = self.max_ordinal_present();
725            encoder.write_num(max_ordinal, offset);
726            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
727            // Calling encoder.out_of_line_offset(0) is not allowed.
728            if max_ordinal == 0 {
729                return Ok(());
730            }
731            depth.increment()?;
732            let envelope_size = 8;
733            let bytes_len = max_ordinal as usize * envelope_size;
734            #[allow(unused_variables)]
735            let offset = encoder.out_of_line_offset(bytes_len);
736            let mut _prev_end_offset: usize = 0;
737            if 1 > max_ordinal {
738                return Ok(());
739            }
740
741            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
742            // are envelope_size bytes.
743            let cur_offset: usize = (1 - 1) * envelope_size;
744
745            // Zero reserved fields.
746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
747
748            // Safety:
749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
751            //   envelope_size bytes, there is always sufficient room.
752            fidl::encoding::encode_in_envelope_optional::<u64, D>(
753                self.actual_count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
754                encoder,
755                offset + cur_offset,
756                depth,
757            )?;
758
759            _prev_end_offset = cur_offset + envelope_size;
760
761            Ok(())
762        }
763    }
764
765    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
766        for UnixDomainSocketWriteResponse
767    {
768        #[inline(always)]
769        fn new_empty() -> Self {
770            Self::default()
771        }
772
773        unsafe fn decode(
774            &mut self,
775            decoder: &mut fidl::encoding::Decoder<'_, D>,
776            offset: usize,
777            mut depth: fidl::encoding::Depth,
778        ) -> fidl::Result<()> {
779            decoder.debug_check_bounds::<Self>(offset);
780            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
781                None => return Err(fidl::Error::NotNullable),
782                Some(len) => len,
783            };
784            // Calling decoder.out_of_line_offset(0) is not allowed.
785            if len == 0 {
786                return Ok(());
787            };
788            depth.increment()?;
789            let envelope_size = 8;
790            let bytes_len = len * envelope_size;
791            let offset = decoder.out_of_line_offset(bytes_len)?;
792            // Decode the envelope for each type.
793            let mut _next_ordinal_to_read = 0;
794            let mut next_offset = offset;
795            let end_offset = offset + bytes_len;
796            _next_ordinal_to_read += 1;
797            if next_offset >= end_offset {
798                return Ok(());
799            }
800
801            // Decode unknown envelopes for gaps in ordinals.
802            while _next_ordinal_to_read < 1 {
803                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
804                _next_ordinal_to_read += 1;
805                next_offset += envelope_size;
806            }
807
808            let next_out_of_line = decoder.next_out_of_line();
809            let handles_before = decoder.remaining_handles();
810            if let Some((inlined, num_bytes, num_handles)) =
811                fidl::encoding::decode_envelope_header(decoder, next_offset)?
812            {
813                let member_inline_size =
814                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
815                if inlined != (member_inline_size <= 4) {
816                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
817                }
818                let inner_offset;
819                let mut inner_depth = depth.clone();
820                if inlined {
821                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
822                    inner_offset = next_offset;
823                } else {
824                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
825                    inner_depth.increment()?;
826                }
827                let val_ref = self.actual_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
828                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
829                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
830                {
831                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
832                }
833                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
834                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
835                }
836            }
837
838            next_offset += envelope_size;
839
840            // Decode the remaining unknown envelopes.
841            while next_offset < end_offset {
842                _next_ordinal_to_read += 1;
843                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
844                next_offset += envelope_size;
845            }
846
847            Ok(())
848        }
849    }
850}