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