fidl_fuchsia_hardware_usb_request/
fidl_fuchsia_hardware_usb_request.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::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_hardware_usb_request_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14/// Buffer region containing data.
15#[derive(Debug, Default, PartialEq)]
16pub struct BufferRegion {
17    /// Buffer for data
18    pub buffer: Option<Buffer>,
19    /// Offset into the VMO to start reading or writing. This is relative to the offset passed to
20    /// RegisterVmos if using vmo_id.
21    pub offset: Option<u64>,
22    /// Number of bytes to read/write from/to this buffer region.
23    pub size: Option<u64>,
24    #[doc(hidden)]
25    pub __source_breaking: fidl::marker::SourceBreaking,
26}
27
28impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for BufferRegion {}
29
30/// Requests passed over fuchsia.hardware.usb.endpoint.Endpoint.
31/// See fuchsia.hardware.usb.endpoint.Endpoint::QueueRequests for more details.
32#[derive(Debug, Default, PartialEq)]
33pub struct Request {
34    /// Data. This array is consumed in-order, and allows for scatter/gather semantics across
35    /// physically non-contiguous regions of a large buffer.
36    pub data: Option<Vec<BufferRegion>>,
37    /// Indicates not to complete this Request when done unless it failed.
38    /// All Requests up to the next defer_completion == false are responded to as one unit.
39    pub defer_completion: Option<bool>,
40    /// Extra information needed for Request.
41    pub information: Option<RequestInfo>,
42    /// True if this is a short transfer sending less than what the receiver is
43    /// expecting. Controllers ensure this transfer is terminated by a short
44    /// packet.
45    ///
46    /// Interpreted as false if absent.
47    pub short: Option<bool>,
48    #[doc(hidden)]
49    pub __source_breaking: fidl::marker::SourceBreaking,
50}
51
52impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Request {}
53
54/// Data buffer. There are two supported ways data may be conveyed, corresponding to the two
55/// members of the Buffer union:
56///  1) vmo_id: Pre-registered VMO. A driver may preregister VMOs using the
57///             fuchsia.hardware.usb.endpoint.Endpoint::RegisterVmos method. These VMOs are saved by
58///             the underlying USB driver in correspondence to the given vmo_id. Future Requests may
59///             refer to this by the unique vmo_id.
60///             Because VMOs are reused across Requests and saved by the underlying driver, each VMO
61///             only needs to be pinned/unpinned once.
62/// 2) data: A data buffer for data that is not associated with a VMO. The underlying USB driver
63///          should allocate its own VMO, copy the data from the buffer, and pin the VMO. This
64///          should not be used often and not for large amounts of data.
65#[derive(Debug)]
66pub enum Buffer {
67    /// The ID of a VMO that was previously registered.
68    VmoId(u64),
69    /// Embedded data buffer to copy data to/from.
70    Data(Vec<u8>),
71    #[doc(hidden)]
72    __SourceBreaking { unknown_ordinal: u64 },
73}
74
75/// Pattern that matches an unknown `Buffer` member.
76#[macro_export]
77macro_rules! BufferUnknown {
78    () => {
79        _
80    };
81}
82
83// Custom PartialEq so that unknown variants are not equal to themselves.
84impl PartialEq for Buffer {
85    fn eq(&self, other: &Self) -> bool {
86        match (self, other) {
87            (Self::VmoId(x), Self::VmoId(y)) => *x == *y,
88            (Self::Data(x), Self::Data(y)) => *x == *y,
89            _ => false,
90        }
91    }
92}
93
94impl Buffer {
95    #[inline]
96    pub fn ordinal(&self) -> u64 {
97        match *self {
98            Self::VmoId(_) => 1,
99            Self::Data(_) => 2,
100            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
101        }
102    }
103
104    #[inline]
105    pub fn unknown_variant_for_testing() -> Self {
106        Self::__SourceBreaking { unknown_ordinal: 0 }
107    }
108
109    #[inline]
110    pub fn is_unknown(&self) -> bool {
111        match self {
112            Self::__SourceBreaking { .. } => true,
113            _ => false,
114        }
115    }
116}
117
118impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Buffer {}
119
120mod internal {
121    use super::*;
122
123    impl BufferRegion {
124        #[inline(always)]
125        fn max_ordinal_present(&self) -> u64 {
126            if let Some(_) = self.size {
127                return 3;
128            }
129            if let Some(_) = self.offset {
130                return 2;
131            }
132            if let Some(_) = self.buffer {
133                return 1;
134            }
135            0
136        }
137    }
138
139    impl fidl::encoding::ResourceTypeMarker for BufferRegion {
140        type Borrowed<'a> = &'a mut Self;
141        fn take_or_borrow<'a>(
142            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
143        ) -> Self::Borrowed<'a> {
144            value
145        }
146    }
147
148    unsafe impl fidl::encoding::TypeMarker for BufferRegion {
149        type Owned = Self;
150
151        #[inline(always)]
152        fn inline_align(_context: fidl::encoding::Context) -> usize {
153            8
154        }
155
156        #[inline(always)]
157        fn inline_size(_context: fidl::encoding::Context) -> usize {
158            16
159        }
160    }
161
162    unsafe impl fidl::encoding::Encode<BufferRegion, fidl::encoding::DefaultFuchsiaResourceDialect>
163        for &mut BufferRegion
164    {
165        unsafe fn encode(
166            self,
167            encoder: &mut fidl::encoding::Encoder<
168                '_,
169                fidl::encoding::DefaultFuchsiaResourceDialect,
170            >,
171            offset: usize,
172            mut depth: fidl::encoding::Depth,
173        ) -> fidl::Result<()> {
174            encoder.debug_check_bounds::<BufferRegion>(offset);
175            // Vector header
176            let max_ordinal: u64 = self.max_ordinal_present();
177            encoder.write_num(max_ordinal, offset);
178            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
179            // Calling encoder.out_of_line_offset(0) is not allowed.
180            if max_ordinal == 0 {
181                return Ok(());
182            }
183            depth.increment()?;
184            let envelope_size = 8;
185            let bytes_len = max_ordinal as usize * envelope_size;
186            #[allow(unused_variables)]
187            let offset = encoder.out_of_line_offset(bytes_len);
188            let mut _prev_end_offset: usize = 0;
189            if 1 > max_ordinal {
190                return Ok(());
191            }
192
193            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
194            // are envelope_size bytes.
195            let cur_offset: usize = (1 - 1) * envelope_size;
196
197            // Zero reserved fields.
198            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
199
200            // Safety:
201            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
202            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
203            //   envelope_size bytes, there is always sufficient room.
204            fidl::encoding::encode_in_envelope_optional::<
205                Buffer,
206                fidl::encoding::DefaultFuchsiaResourceDialect,
207            >(
208                self.buffer
209                    .as_mut()
210                    .map(<Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
211                encoder,
212                offset + cur_offset,
213                depth,
214            )?;
215
216            _prev_end_offset = cur_offset + envelope_size;
217            if 2 > max_ordinal {
218                return Ok(());
219            }
220
221            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
222            // are envelope_size bytes.
223            let cur_offset: usize = (2 - 1) * envelope_size;
224
225            // Zero reserved fields.
226            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
227
228            // Safety:
229            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
230            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
231            //   envelope_size bytes, there is always sufficient room.
232            fidl::encoding::encode_in_envelope_optional::<
233                u64,
234                fidl::encoding::DefaultFuchsiaResourceDialect,
235            >(
236                self.offset.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
237                encoder,
238                offset + cur_offset,
239                depth,
240            )?;
241
242            _prev_end_offset = cur_offset + envelope_size;
243            if 3 > max_ordinal {
244                return Ok(());
245            }
246
247            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
248            // are envelope_size bytes.
249            let cur_offset: usize = (3 - 1) * envelope_size;
250
251            // Zero reserved fields.
252            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
253
254            // Safety:
255            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
256            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
257            //   envelope_size bytes, there is always sufficient room.
258            fidl::encoding::encode_in_envelope_optional::<
259                u64,
260                fidl::encoding::DefaultFuchsiaResourceDialect,
261            >(
262                self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
263                encoder,
264                offset + cur_offset,
265                depth,
266            )?;
267
268            _prev_end_offset = cur_offset + envelope_size;
269
270            Ok(())
271        }
272    }
273
274    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for BufferRegion {
275        #[inline(always)]
276        fn new_empty() -> Self {
277            Self::default()
278        }
279
280        unsafe fn decode(
281            &mut self,
282            decoder: &mut fidl::encoding::Decoder<
283                '_,
284                fidl::encoding::DefaultFuchsiaResourceDialect,
285            >,
286            offset: usize,
287            mut depth: fidl::encoding::Depth,
288        ) -> fidl::Result<()> {
289            decoder.debug_check_bounds::<Self>(offset);
290            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
291                None => return Err(fidl::Error::NotNullable),
292                Some(len) => len,
293            };
294            // Calling decoder.out_of_line_offset(0) is not allowed.
295            if len == 0 {
296                return Ok(());
297            };
298            depth.increment()?;
299            let envelope_size = 8;
300            let bytes_len = len * envelope_size;
301            let offset = decoder.out_of_line_offset(bytes_len)?;
302            // Decode the envelope for each type.
303            let mut _next_ordinal_to_read = 0;
304            let mut next_offset = offset;
305            let end_offset = offset + bytes_len;
306            _next_ordinal_to_read += 1;
307            if next_offset >= end_offset {
308                return Ok(());
309            }
310
311            // Decode unknown envelopes for gaps in ordinals.
312            while _next_ordinal_to_read < 1 {
313                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
314                _next_ordinal_to_read += 1;
315                next_offset += envelope_size;
316            }
317
318            let next_out_of_line = decoder.next_out_of_line();
319            let handles_before = decoder.remaining_handles();
320            if let Some((inlined, num_bytes, num_handles)) =
321                fidl::encoding::decode_envelope_header(decoder, next_offset)?
322            {
323                let member_inline_size =
324                    <Buffer as fidl::encoding::TypeMarker>::inline_size(decoder.context);
325                if inlined != (member_inline_size <= 4) {
326                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
327                }
328                let inner_offset;
329                let mut inner_depth = depth.clone();
330                if inlined {
331                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
332                    inner_offset = next_offset;
333                } else {
334                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
335                    inner_depth.increment()?;
336                }
337                let val_ref = self.buffer.get_or_insert_with(|| {
338                    fidl::new_empty!(Buffer, fidl::encoding::DefaultFuchsiaResourceDialect)
339                });
340                fidl::decode!(
341                    Buffer,
342                    fidl::encoding::DefaultFuchsiaResourceDialect,
343                    val_ref,
344                    decoder,
345                    inner_offset,
346                    inner_depth
347                )?;
348                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
349                {
350                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
351                }
352                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
353                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
354                }
355            }
356
357            next_offset += envelope_size;
358            _next_ordinal_to_read += 1;
359            if next_offset >= end_offset {
360                return Ok(());
361            }
362
363            // Decode unknown envelopes for gaps in ordinals.
364            while _next_ordinal_to_read < 2 {
365                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
366                _next_ordinal_to_read += 1;
367                next_offset += envelope_size;
368            }
369
370            let next_out_of_line = decoder.next_out_of_line();
371            let handles_before = decoder.remaining_handles();
372            if let Some((inlined, num_bytes, num_handles)) =
373                fidl::encoding::decode_envelope_header(decoder, next_offset)?
374            {
375                let member_inline_size =
376                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
377                if inlined != (member_inline_size <= 4) {
378                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
379                }
380                let inner_offset;
381                let mut inner_depth = depth.clone();
382                if inlined {
383                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
384                    inner_offset = next_offset;
385                } else {
386                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
387                    inner_depth.increment()?;
388                }
389                let val_ref = self.offset.get_or_insert_with(|| {
390                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
391                });
392                fidl::decode!(
393                    u64,
394                    fidl::encoding::DefaultFuchsiaResourceDialect,
395                    val_ref,
396                    decoder,
397                    inner_offset,
398                    inner_depth
399                )?;
400                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
401                {
402                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
403                }
404                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
405                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
406                }
407            }
408
409            next_offset += envelope_size;
410            _next_ordinal_to_read += 1;
411            if next_offset >= end_offset {
412                return Ok(());
413            }
414
415            // Decode unknown envelopes for gaps in ordinals.
416            while _next_ordinal_to_read < 3 {
417                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
418                _next_ordinal_to_read += 1;
419                next_offset += envelope_size;
420            }
421
422            let next_out_of_line = decoder.next_out_of_line();
423            let handles_before = decoder.remaining_handles();
424            if let Some((inlined, num_bytes, num_handles)) =
425                fidl::encoding::decode_envelope_header(decoder, next_offset)?
426            {
427                let member_inline_size =
428                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
429                if inlined != (member_inline_size <= 4) {
430                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
431                }
432                let inner_offset;
433                let mut inner_depth = depth.clone();
434                if inlined {
435                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
436                    inner_offset = next_offset;
437                } else {
438                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
439                    inner_depth.increment()?;
440                }
441                let val_ref = self.size.get_or_insert_with(|| {
442                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
443                });
444                fidl::decode!(
445                    u64,
446                    fidl::encoding::DefaultFuchsiaResourceDialect,
447                    val_ref,
448                    decoder,
449                    inner_offset,
450                    inner_depth
451                )?;
452                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
453                {
454                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
455                }
456                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
457                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
458                }
459            }
460
461            next_offset += envelope_size;
462
463            // Decode the remaining unknown envelopes.
464            while next_offset < end_offset {
465                _next_ordinal_to_read += 1;
466                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
467                next_offset += envelope_size;
468            }
469
470            Ok(())
471        }
472    }
473
474    impl Request {
475        #[inline(always)]
476        fn max_ordinal_present(&self) -> u64 {
477            if let Some(_) = self.short {
478                return 4;
479            }
480            if let Some(_) = self.information {
481                return 3;
482            }
483            if let Some(_) = self.defer_completion {
484                return 2;
485            }
486            if let Some(_) = self.data {
487                return 1;
488            }
489            0
490        }
491    }
492
493    impl fidl::encoding::ResourceTypeMarker for Request {
494        type Borrowed<'a> = &'a mut Self;
495        fn take_or_borrow<'a>(
496            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
497        ) -> Self::Borrowed<'a> {
498            value
499        }
500    }
501
502    unsafe impl fidl::encoding::TypeMarker for Request {
503        type Owned = Self;
504
505        #[inline(always)]
506        fn inline_align(_context: fidl::encoding::Context) -> usize {
507            8
508        }
509
510        #[inline(always)]
511        fn inline_size(_context: fidl::encoding::Context) -> usize {
512            16
513        }
514    }
515
516    unsafe impl fidl::encoding::Encode<Request, fidl::encoding::DefaultFuchsiaResourceDialect>
517        for &mut Request
518    {
519        unsafe fn encode(
520            self,
521            encoder: &mut fidl::encoding::Encoder<
522                '_,
523                fidl::encoding::DefaultFuchsiaResourceDialect,
524            >,
525            offset: usize,
526            mut depth: fidl::encoding::Depth,
527        ) -> fidl::Result<()> {
528            encoder.debug_check_bounds::<Request>(offset);
529            // Vector header
530            let max_ordinal: u64 = self.max_ordinal_present();
531            encoder.write_num(max_ordinal, offset);
532            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
533            // Calling encoder.out_of_line_offset(0) is not allowed.
534            if max_ordinal == 0 {
535                return Ok(());
536            }
537            depth.increment()?;
538            let envelope_size = 8;
539            let bytes_len = max_ordinal as usize * envelope_size;
540            #[allow(unused_variables)]
541            let offset = encoder.out_of_line_offset(bytes_len);
542            let mut _prev_end_offset: usize = 0;
543            if 1 > max_ordinal {
544                return Ok(());
545            }
546
547            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
548            // are envelope_size bytes.
549            let cur_offset: usize = (1 - 1) * envelope_size;
550
551            // Zero reserved fields.
552            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
553
554            // Safety:
555            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
556            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
557            //   envelope_size bytes, there is always sufficient room.
558            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<BufferRegion>, fidl::encoding::DefaultFuchsiaResourceDialect>(
559            self.data.as_mut().map(<fidl::encoding::UnboundedVector<BufferRegion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
560            encoder, offset + cur_offset, depth
561        )?;
562
563            _prev_end_offset = cur_offset + envelope_size;
564            if 2 > max_ordinal {
565                return Ok(());
566            }
567
568            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
569            // are envelope_size bytes.
570            let cur_offset: usize = (2 - 1) * envelope_size;
571
572            // Zero reserved fields.
573            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
574
575            // Safety:
576            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
577            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
578            //   envelope_size bytes, there is always sufficient room.
579            fidl::encoding::encode_in_envelope_optional::<
580                bool,
581                fidl::encoding::DefaultFuchsiaResourceDialect,
582            >(
583                self.defer_completion
584                    .as_ref()
585                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
586                encoder,
587                offset + cur_offset,
588                depth,
589            )?;
590
591            _prev_end_offset = cur_offset + envelope_size;
592            if 3 > max_ordinal {
593                return Ok(());
594            }
595
596            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
597            // are envelope_size bytes.
598            let cur_offset: usize = (3 - 1) * envelope_size;
599
600            // Zero reserved fields.
601            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
602
603            // Safety:
604            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
605            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
606            //   envelope_size bytes, there is always sufficient room.
607            fidl::encoding::encode_in_envelope_optional::<
608                RequestInfo,
609                fidl::encoding::DefaultFuchsiaResourceDialect,
610            >(
611                self.information
612                    .as_ref()
613                    .map(<RequestInfo as fidl::encoding::ValueTypeMarker>::borrow),
614                encoder,
615                offset + cur_offset,
616                depth,
617            )?;
618
619            _prev_end_offset = cur_offset + envelope_size;
620            if 4 > max_ordinal {
621                return Ok(());
622            }
623
624            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
625            // are envelope_size bytes.
626            let cur_offset: usize = (4 - 1) * envelope_size;
627
628            // Zero reserved fields.
629            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
630
631            // Safety:
632            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
633            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
634            //   envelope_size bytes, there is always sufficient room.
635            fidl::encoding::encode_in_envelope_optional::<
636                bool,
637                fidl::encoding::DefaultFuchsiaResourceDialect,
638            >(
639                self.short.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
640                encoder,
641                offset + cur_offset,
642                depth,
643            )?;
644
645            _prev_end_offset = cur_offset + envelope_size;
646
647            Ok(())
648        }
649    }
650
651    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Request {
652        #[inline(always)]
653        fn new_empty() -> Self {
654            Self::default()
655        }
656
657        unsafe fn decode(
658            &mut self,
659            decoder: &mut fidl::encoding::Decoder<
660                '_,
661                fidl::encoding::DefaultFuchsiaResourceDialect,
662            >,
663            offset: usize,
664            mut depth: fidl::encoding::Depth,
665        ) -> fidl::Result<()> {
666            decoder.debug_check_bounds::<Self>(offset);
667            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
668                None => return Err(fidl::Error::NotNullable),
669                Some(len) => len,
670            };
671            // Calling decoder.out_of_line_offset(0) is not allowed.
672            if len == 0 {
673                return Ok(());
674            };
675            depth.increment()?;
676            let envelope_size = 8;
677            let bytes_len = len * envelope_size;
678            let offset = decoder.out_of_line_offset(bytes_len)?;
679            // Decode the envelope for each type.
680            let mut _next_ordinal_to_read = 0;
681            let mut next_offset = offset;
682            let end_offset = offset + bytes_len;
683            _next_ordinal_to_read += 1;
684            if next_offset >= end_offset {
685                return Ok(());
686            }
687
688            // Decode unknown envelopes for gaps in ordinals.
689            while _next_ordinal_to_read < 1 {
690                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
691                _next_ordinal_to_read += 1;
692                next_offset += envelope_size;
693            }
694
695            let next_out_of_line = decoder.next_out_of_line();
696            let handles_before = decoder.remaining_handles();
697            if let Some((inlined, num_bytes, num_handles)) =
698                fidl::encoding::decode_envelope_header(decoder, next_offset)?
699            {
700                let member_inline_size = <fidl::encoding::UnboundedVector<BufferRegion> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
701                if inlined != (member_inline_size <= 4) {
702                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
703                }
704                let inner_offset;
705                let mut inner_depth = depth.clone();
706                if inlined {
707                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
708                    inner_offset = next_offset;
709                } else {
710                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
711                    inner_depth.increment()?;
712                }
713                let val_ref = self.data.get_or_insert_with(|| {
714                    fidl::new_empty!(
715                        fidl::encoding::UnboundedVector<BufferRegion>,
716                        fidl::encoding::DefaultFuchsiaResourceDialect
717                    )
718                });
719                fidl::decode!(
720                    fidl::encoding::UnboundedVector<BufferRegion>,
721                    fidl::encoding::DefaultFuchsiaResourceDialect,
722                    val_ref,
723                    decoder,
724                    inner_offset,
725                    inner_depth
726                )?;
727                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
728                {
729                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
730                }
731                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
732                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
733                }
734            }
735
736            next_offset += envelope_size;
737            _next_ordinal_to_read += 1;
738            if next_offset >= end_offset {
739                return Ok(());
740            }
741
742            // Decode unknown envelopes for gaps in ordinals.
743            while _next_ordinal_to_read < 2 {
744                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
745                _next_ordinal_to_read += 1;
746                next_offset += envelope_size;
747            }
748
749            let next_out_of_line = decoder.next_out_of_line();
750            let handles_before = decoder.remaining_handles();
751            if let Some((inlined, num_bytes, num_handles)) =
752                fidl::encoding::decode_envelope_header(decoder, next_offset)?
753            {
754                let member_inline_size =
755                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
756                if inlined != (member_inline_size <= 4) {
757                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
758                }
759                let inner_offset;
760                let mut inner_depth = depth.clone();
761                if inlined {
762                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
763                    inner_offset = next_offset;
764                } else {
765                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
766                    inner_depth.increment()?;
767                }
768                let val_ref = self.defer_completion.get_or_insert_with(|| {
769                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
770                });
771                fidl::decode!(
772                    bool,
773                    fidl::encoding::DefaultFuchsiaResourceDialect,
774                    val_ref,
775                    decoder,
776                    inner_offset,
777                    inner_depth
778                )?;
779                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
780                {
781                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
782                }
783                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
784                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
785                }
786            }
787
788            next_offset += envelope_size;
789            _next_ordinal_to_read += 1;
790            if next_offset >= end_offset {
791                return Ok(());
792            }
793
794            // Decode unknown envelopes for gaps in ordinals.
795            while _next_ordinal_to_read < 3 {
796                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
797                _next_ordinal_to_read += 1;
798                next_offset += envelope_size;
799            }
800
801            let next_out_of_line = decoder.next_out_of_line();
802            let handles_before = decoder.remaining_handles();
803            if let Some((inlined, num_bytes, num_handles)) =
804                fidl::encoding::decode_envelope_header(decoder, next_offset)?
805            {
806                let member_inline_size =
807                    <RequestInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
808                if inlined != (member_inline_size <= 4) {
809                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
810                }
811                let inner_offset;
812                let mut inner_depth = depth.clone();
813                if inlined {
814                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
815                    inner_offset = next_offset;
816                } else {
817                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
818                    inner_depth.increment()?;
819                }
820                let val_ref = self.information.get_or_insert_with(|| {
821                    fidl::new_empty!(RequestInfo, fidl::encoding::DefaultFuchsiaResourceDialect)
822                });
823                fidl::decode!(
824                    RequestInfo,
825                    fidl::encoding::DefaultFuchsiaResourceDialect,
826                    val_ref,
827                    decoder,
828                    inner_offset,
829                    inner_depth
830                )?;
831                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
832                {
833                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
834                }
835                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
836                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
837                }
838            }
839
840            next_offset += envelope_size;
841            _next_ordinal_to_read += 1;
842            if next_offset >= end_offset {
843                return Ok(());
844            }
845
846            // Decode unknown envelopes for gaps in ordinals.
847            while _next_ordinal_to_read < 4 {
848                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
849                _next_ordinal_to_read += 1;
850                next_offset += envelope_size;
851            }
852
853            let next_out_of_line = decoder.next_out_of_line();
854            let handles_before = decoder.remaining_handles();
855            if let Some((inlined, num_bytes, num_handles)) =
856                fidl::encoding::decode_envelope_header(decoder, next_offset)?
857            {
858                let member_inline_size =
859                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
860                if inlined != (member_inline_size <= 4) {
861                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
862                }
863                let inner_offset;
864                let mut inner_depth = depth.clone();
865                if inlined {
866                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
867                    inner_offset = next_offset;
868                } else {
869                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
870                    inner_depth.increment()?;
871                }
872                let val_ref = self.short.get_or_insert_with(|| {
873                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
874                });
875                fidl::decode!(
876                    bool,
877                    fidl::encoding::DefaultFuchsiaResourceDialect,
878                    val_ref,
879                    decoder,
880                    inner_offset,
881                    inner_depth
882                )?;
883                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
884                {
885                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
886                }
887                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
888                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
889                }
890            }
891
892            next_offset += envelope_size;
893
894            // Decode the remaining unknown envelopes.
895            while next_offset < end_offset {
896                _next_ordinal_to_read += 1;
897                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
898                next_offset += envelope_size;
899            }
900
901            Ok(())
902        }
903    }
904
905    impl fidl::encoding::ResourceTypeMarker for Buffer {
906        type Borrowed<'a> = &'a mut Self;
907        fn take_or_borrow<'a>(
908            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
909        ) -> Self::Borrowed<'a> {
910            value
911        }
912    }
913
914    unsafe impl fidl::encoding::TypeMarker for Buffer {
915        type Owned = Self;
916
917        #[inline(always)]
918        fn inline_align(_context: fidl::encoding::Context) -> usize {
919            8
920        }
921
922        #[inline(always)]
923        fn inline_size(_context: fidl::encoding::Context) -> usize {
924            16
925        }
926    }
927
928    unsafe impl fidl::encoding::Encode<Buffer, fidl::encoding::DefaultFuchsiaResourceDialect>
929        for &mut Buffer
930    {
931        #[inline]
932        unsafe fn encode(
933            self,
934            encoder: &mut fidl::encoding::Encoder<
935                '_,
936                fidl::encoding::DefaultFuchsiaResourceDialect,
937            >,
938            offset: usize,
939            _depth: fidl::encoding::Depth,
940        ) -> fidl::Result<()> {
941            encoder.debug_check_bounds::<Buffer>(offset);
942            encoder.write_num::<u64>(self.ordinal(), offset);
943            match self {
944                Buffer::VmoId(ref val) => fidl::encoding::encode_in_envelope::<
945                    u64,
946                    fidl::encoding::DefaultFuchsiaResourceDialect,
947                >(
948                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
949                    encoder,
950                    offset + 8,
951                    _depth,
952                ),
953                Buffer::Data(ref val) => fidl::encoding::encode_in_envelope::<
954                    fidl::encoding::Vector<u8, 1024>,
955                    fidl::encoding::DefaultFuchsiaResourceDialect,
956                >(
957                    <fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(
958                        val,
959                    ),
960                    encoder,
961                    offset + 8,
962                    _depth,
963                ),
964                Buffer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
965            }
966        }
967    }
968
969    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Buffer {
970        #[inline(always)]
971        fn new_empty() -> Self {
972            Self::__SourceBreaking { unknown_ordinal: 0 }
973        }
974
975        #[inline]
976        unsafe fn decode(
977            &mut self,
978            decoder: &mut fidl::encoding::Decoder<
979                '_,
980                fidl::encoding::DefaultFuchsiaResourceDialect,
981            >,
982            offset: usize,
983            mut depth: fidl::encoding::Depth,
984        ) -> fidl::Result<()> {
985            decoder.debug_check_bounds::<Self>(offset);
986            #[allow(unused_variables)]
987            let next_out_of_line = decoder.next_out_of_line();
988            let handles_before = decoder.remaining_handles();
989            let (ordinal, inlined, num_bytes, num_handles) =
990                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
991
992            let member_inline_size = match ordinal {
993                1 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
994                2 => <fidl::encoding::Vector<u8, 1024> as fidl::encoding::TypeMarker>::inline_size(
995                    decoder.context,
996                ),
997                0 => return Err(fidl::Error::UnknownUnionTag),
998                _ => num_bytes as usize,
999            };
1000
1001            if inlined != (member_inline_size <= 4) {
1002                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1003            }
1004            let _inner_offset;
1005            if inlined {
1006                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1007                _inner_offset = offset + 8;
1008            } else {
1009                depth.increment()?;
1010                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1011            }
1012            match ordinal {
1013                1 => {
1014                    #[allow(irrefutable_let_patterns)]
1015                    if let Buffer::VmoId(_) = self {
1016                        // Do nothing, read the value into the object
1017                    } else {
1018                        // Initialize `self` to the right variant
1019                        *self = Buffer::VmoId(fidl::new_empty!(
1020                            u64,
1021                            fidl::encoding::DefaultFuchsiaResourceDialect
1022                        ));
1023                    }
1024                    #[allow(irrefutable_let_patterns)]
1025                    if let Buffer::VmoId(ref mut val) = self {
1026                        fidl::decode!(
1027                            u64,
1028                            fidl::encoding::DefaultFuchsiaResourceDialect,
1029                            val,
1030                            decoder,
1031                            _inner_offset,
1032                            depth
1033                        )?;
1034                    } else {
1035                        unreachable!()
1036                    }
1037                }
1038                2 => {
1039                    #[allow(irrefutable_let_patterns)]
1040                    if let Buffer::Data(_) = self {
1041                        // Do nothing, read the value into the object
1042                    } else {
1043                        // Initialize `self` to the right variant
1044                        *self = Buffer::Data(
1045                            fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect),
1046                        );
1047                    }
1048                    #[allow(irrefutable_let_patterns)]
1049                    if let Buffer::Data(ref mut val) = self {
1050                        fidl::decode!(fidl::encoding::Vector<u8, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
1051                    } else {
1052                        unreachable!()
1053                    }
1054                }
1055                #[allow(deprecated)]
1056                ordinal => {
1057                    for _ in 0..num_handles {
1058                        decoder.drop_next_handle()?;
1059                    }
1060                    *self = Buffer::__SourceBreaking { unknown_ordinal: ordinal };
1061                }
1062            }
1063            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1064                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1065            }
1066            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1067                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1068            }
1069            Ok(())
1070        }
1071    }
1072}
fidl_fuchsia_hardware_usb_request/fidl_fuchsia_hardware_usb_request.rs

fidl_fuchsia_hardware_usb_request/
fidl_fuchsia_hardware_usb_request.rs
