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::<
723                fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty2, 64>,
724                D,
725            >(
726                self.properties.as_ref().map(
727                    <fidl::encoding::Vector<
728                        fidl_fuchsia_driver_framework__common::NodeProperty2,
729                        64,
730                    > as fidl::encoding::ValueTypeMarker>::borrow,
731                ),
732                encoder,
733                offset + cur_offset,
734                depth,
735            )?;
736
737            _prev_end_offset = cur_offset + envelope_size;
738            if 2 > max_ordinal {
739                return Ok(());
740            }
741
742            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
743            // are envelope_size bytes.
744            let cur_offset: usize = (2 - 1) * envelope_size;
745
746            // Zero reserved fields.
747            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
748
749            // Safety:
750            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
751            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
752            //   envelope_size bytes, there is always sufficient room.
753            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
754                self.name.as_ref().map(
755                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
756                ),
757                encoder,
758                offset + cur_offset,
759                depth,
760            )?;
761
762            _prev_end_offset = cur_offset + envelope_size;
763            if 3 > max_ordinal {
764                return Ok(());
765            }
766
767            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
768            // are envelope_size bytes.
769            let cur_offset: usize = (3 - 1) * envelope_size;
770
771            // Zero reserved fields.
772            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
773
774            // Safety:
775            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
776            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
777            //   envelope_size bytes, there is always sufficient room.
778            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
779                self.driver_url_suffix.as_ref().map(
780                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
781                ),
782                encoder,
783                offset + cur_offset,
784                depth,
785            )?;
786
787            _prev_end_offset = cur_offset + envelope_size;
788
789            Ok(())
790        }
791    }
792
793    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MatchDriverArgs {
794        #[inline(always)]
795        fn new_empty() -> Self {
796            Self::default()
797        }
798
799        unsafe fn decode(
800            &mut self,
801            decoder: &mut fidl::encoding::Decoder<'_, D>,
802            offset: usize,
803            mut depth: fidl::encoding::Depth,
804        ) -> fidl::Result<()> {
805            decoder.debug_check_bounds::<Self>(offset);
806            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
807                None => return Err(fidl::Error::NotNullable),
808                Some(len) => len,
809            };
810            // Calling decoder.out_of_line_offset(0) is not allowed.
811            if len == 0 {
812                return Ok(());
813            };
814            depth.increment()?;
815            let envelope_size = 8;
816            let bytes_len = len * envelope_size;
817            let offset = decoder.out_of_line_offset(bytes_len)?;
818            // Decode the envelope for each type.
819            let mut _next_ordinal_to_read = 0;
820            let mut next_offset = offset;
821            let end_offset = offset + bytes_len;
822            _next_ordinal_to_read += 1;
823            if next_offset >= end_offset {
824                return Ok(());
825            }
826
827            // Decode unknown envelopes for gaps in ordinals.
828            while _next_ordinal_to_read < 1 {
829                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
830                _next_ordinal_to_read += 1;
831                next_offset += envelope_size;
832            }
833
834            let next_out_of_line = decoder.next_out_of_line();
835            let handles_before = decoder.remaining_handles();
836            if let Some((inlined, num_bytes, num_handles)) =
837                fidl::encoding::decode_envelope_header(decoder, next_offset)?
838            {
839                let member_inline_size = <fidl::encoding::Vector<
840                    fidl_fuchsia_driver_framework__common::NodeProperty2,
841                    64,
842                > as fidl::encoding::TypeMarker>::inline_size(
843                    decoder.context
844                );
845                if inlined != (member_inline_size <= 4) {
846                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
847                }
848                let inner_offset;
849                let mut inner_depth = depth.clone();
850                if inlined {
851                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
852                    inner_offset = next_offset;
853                } else {
854                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
855                    inner_depth.increment()?;
856                }
857                let val_ref =
858                self.properties.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty2, 64>, D));
859                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_driver_framework__common::NodeProperty2, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
860                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
861                {
862                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
863                }
864                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
865                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
866                }
867            }
868
869            next_offset += envelope_size;
870            _next_ordinal_to_read += 1;
871            if next_offset >= end_offset {
872                return Ok(());
873            }
874
875            // Decode unknown envelopes for gaps in ordinals.
876            while _next_ordinal_to_read < 2 {
877                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
878                _next_ordinal_to_read += 1;
879                next_offset += envelope_size;
880            }
881
882            let next_out_of_line = decoder.next_out_of_line();
883            let handles_before = decoder.remaining_handles();
884            if let Some((inlined, num_bytes, num_handles)) =
885                fidl::encoding::decode_envelope_header(decoder, next_offset)?
886            {
887                let member_inline_size =
888                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
889                        decoder.context,
890                    );
891                if inlined != (member_inline_size <= 4) {
892                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
893                }
894                let inner_offset;
895                let mut inner_depth = depth.clone();
896                if inlined {
897                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
898                    inner_offset = next_offset;
899                } else {
900                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
901                    inner_depth.increment()?;
902                }
903                let val_ref = self
904                    .name
905                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
906                fidl::decode!(
907                    fidl::encoding::BoundedString<128>,
908                    D,
909                    val_ref,
910                    decoder,
911                    inner_offset,
912                    inner_depth
913                )?;
914                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
915                {
916                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
917                }
918                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
919                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
920                }
921            }
922
923            next_offset += envelope_size;
924            _next_ordinal_to_read += 1;
925            if next_offset >= end_offset {
926                return Ok(());
927            }
928
929            // Decode unknown envelopes for gaps in ordinals.
930            while _next_ordinal_to_read < 3 {
931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
932                _next_ordinal_to_read += 1;
933                next_offset += envelope_size;
934            }
935
936            let next_out_of_line = decoder.next_out_of_line();
937            let handles_before = decoder.remaining_handles();
938            if let Some((inlined, num_bytes, num_handles)) =
939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
940            {
941                let member_inline_size =
942                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
943                        decoder.context,
944                    );
945                if inlined != (member_inline_size <= 4) {
946                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
947                }
948                let inner_offset;
949                let mut inner_depth = depth.clone();
950                if inlined {
951                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
952                    inner_offset = next_offset;
953                } else {
954                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
955                    inner_depth.increment()?;
956                }
957                let val_ref = self
958                    .driver_url_suffix
959                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
960                fidl::decode!(
961                    fidl::encoding::UnboundedString,
962                    D,
963                    val_ref,
964                    decoder,
965                    inner_offset,
966                    inner_depth
967                )?;
968                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
969                {
970                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
971                }
972                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
973                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
974                }
975            }
976
977            next_offset += envelope_size;
978
979            // Decode the remaining unknown envelopes.
980            while next_offset < end_offset {
981                _next_ordinal_to_read += 1;
982                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
983                next_offset += envelope_size;
984            }
985
986            Ok(())
987        }
988    }
989
990    impl fidl::encoding::ValueTypeMarker for MatchDriverResult {
991        type Borrowed<'a> = &'a Self;
992        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
993            value
994        }
995    }
996
997    unsafe impl fidl::encoding::TypeMarker for MatchDriverResult {
998        type Owned = Self;
999
1000        #[inline(always)]
1001        fn inline_align(_context: fidl::encoding::Context) -> usize {
1002            8
1003        }
1004
1005        #[inline(always)]
1006        fn inline_size(_context: fidl::encoding::Context) -> usize {
1007            16
1008        }
1009    }
1010
1011    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MatchDriverResult, D>
1012        for &MatchDriverResult
1013    {
1014        #[inline]
1015        unsafe fn encode(
1016            self,
1017            encoder: &mut fidl::encoding::Encoder<'_, D>,
1018            offset: usize,
1019            _depth: fidl::encoding::Depth,
1020        ) -> fidl::Result<()> {
1021            encoder.debug_check_bounds::<MatchDriverResult>(offset);
1022            encoder.write_num::<u64>(self.ordinal(), offset);
1023            match self {
1024            MatchDriverResult::Driver(ref val) => {
1025                fidl::encoding::encode_in_envelope::<fidl_fuchsia_driver_framework__common::DriverInfo, D>(
1026                    <fidl_fuchsia_driver_framework__common::DriverInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
1027                    encoder, offset + 8, _depth
1028                )
1029            }
1030            MatchDriverResult::CompositeParents(ref val) => {
1031                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework__common::CompositeParent>, D>(
1032                    <fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework__common::CompositeParent> as fidl::encoding::ValueTypeMarker>::borrow(val),
1033                    encoder, offset + 8, _depth
1034                )
1035            }
1036            MatchDriverResult::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
1037        }
1038        }
1039    }
1040
1041    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MatchDriverResult {
1042        #[inline(always)]
1043        fn new_empty() -> Self {
1044            Self::__SourceBreaking { unknown_ordinal: 0 }
1045        }
1046
1047        #[inline]
1048        unsafe fn decode(
1049            &mut self,
1050            decoder: &mut fidl::encoding::Decoder<'_, D>,
1051            offset: usize,
1052            mut depth: fidl::encoding::Depth,
1053        ) -> fidl::Result<()> {
1054            decoder.debug_check_bounds::<Self>(offset);
1055            #[allow(unused_variables)]
1056            let next_out_of_line = decoder.next_out_of_line();
1057            let handles_before = decoder.remaining_handles();
1058            let (ordinal, inlined, num_bytes, num_handles) =
1059                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
1060
1061            let member_inline_size = match ordinal {
1062            1 => <fidl_fuchsia_driver_framework__common::DriverInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1063            2 => <fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework__common::CompositeParent> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
1064            0 => return Err(fidl::Error::UnknownUnionTag),
1065            _ => num_bytes as usize,
1066        };
1067
1068            if inlined != (member_inline_size <= 4) {
1069                return Err(fidl::Error::InvalidInlineBitInEnvelope);
1070            }
1071            let _inner_offset;
1072            if inlined {
1073                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
1074                _inner_offset = offset + 8;
1075            } else {
1076                depth.increment()?;
1077                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1078            }
1079            match ordinal {
1080                1 => {
1081                    #[allow(irrefutable_let_patterns)]
1082                    if let MatchDriverResult::Driver(_) = self {
1083                        // Do nothing, read the value into the object
1084                    } else {
1085                        // Initialize `self` to the right variant
1086                        *self = MatchDriverResult::Driver(fidl::new_empty!(
1087                            fidl_fuchsia_driver_framework__common::DriverInfo,
1088                            D
1089                        ));
1090                    }
1091                    #[allow(irrefutable_let_patterns)]
1092                    if let MatchDriverResult::Driver(ref mut val) = self {
1093                        fidl::decode!(
1094                            fidl_fuchsia_driver_framework__common::DriverInfo,
1095                            D,
1096                            val,
1097                            decoder,
1098                            _inner_offset,
1099                            depth
1100                        )?;
1101                    } else {
1102                        unreachable!()
1103                    }
1104                }
1105                2 => {
1106                    #[allow(irrefutable_let_patterns)]
1107                    if let MatchDriverResult::CompositeParents(_) = self {
1108                        // Do nothing, read the value into the object
1109                    } else {
1110                        // Initialize `self` to the right variant
1111                        *self = MatchDriverResult::CompositeParents(fidl::new_empty!(
1112                            fidl::encoding::UnboundedVector<
1113                                fidl_fuchsia_driver_framework__common::CompositeParent,
1114                            >,
1115                            D
1116                        ));
1117                    }
1118                    #[allow(irrefutable_let_patterns)]
1119                    if let MatchDriverResult::CompositeParents(ref mut val) = self {
1120                        fidl::decode!(
1121                            fidl::encoding::UnboundedVector<
1122                                fidl_fuchsia_driver_framework__common::CompositeParent,
1123                            >,
1124                            D,
1125                            val,
1126                            decoder,
1127                            _inner_offset,
1128                            depth
1129                        )?;
1130                    } else {
1131                        unreachable!()
1132                    }
1133                }
1134                #[allow(deprecated)]
1135                ordinal => {
1136                    for _ in 0..num_handles {
1137                        decoder.drop_next_handle()?;
1138                    }
1139                    *self = MatchDriverResult::__SourceBreaking { unknown_ordinal: ordinal };
1140                }
1141            }
1142            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
1143                return Err(fidl::Error::InvalidNumBytesInEnvelope);
1144            }
1145            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1146                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1147            }
1148            Ok(())
1149        }
1150    }
1151}
fidl_fuchsia_driver_index__common/fidl_fuchsia_driver_index__common.rs

fidl_fuchsia_driver_index__common/
fidl_fuchsia_driver_index__common.rs
