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

fidl_fuchsia_driver_index_common/
fidl_fuchsia_driver_index_common.rs
