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

fidl_fuchsia_driver_index__common/
fidl_fuchsia_driver_index__common.rs
