1#![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
11pub const MAX_STRING_LENGTH: u64 = 100;
12
13#[derive(Clone, Debug, PartialEq)]
14pub struct ProviderGetBuildInfoResponse {
15 pub build_info: BuildInfo,
16}
17
18impl fidl::Persistable for ProviderGetBuildInfoResponse {}
19
20#[derive(Clone, Debug, Default, PartialEq)]
21pub struct BuildInfo {
22 pub product_config: Option<String>,
26 pub board_config: Option<String>,
30 pub version: Option<String>,
33 pub latest_commit_date: Option<String>,
37 pub platform_version: Option<String>,
40 pub product_version: Option<String>,
44 #[doc(hidden)]
45 pub __source_breaking: fidl::marker::SourceBreaking,
46}
47
48impl fidl::Persistable for BuildInfo {}
49
50pub mod provider_ordinals {
51 pub const GET_BUILD_INFO: u64 = 0x2cf46f6b8e681b93;
52}
53
54mod internal {
55 use super::*;
56
57 impl fidl::encoding::ValueTypeMarker for ProviderGetBuildInfoResponse {
58 type Borrowed<'a> = &'a Self;
59 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
60 value
61 }
62 }
63
64 unsafe impl fidl::encoding::TypeMarker for ProviderGetBuildInfoResponse {
65 type Owned = Self;
66
67 #[inline(always)]
68 fn inline_align(_context: fidl::encoding::Context) -> usize {
69 8
70 }
71
72 #[inline(always)]
73 fn inline_size(_context: fidl::encoding::Context) -> usize {
74 16
75 }
76 }
77
78 unsafe impl<D: fidl::encoding::ResourceDialect>
79 fidl::encoding::Encode<ProviderGetBuildInfoResponse, D> for &ProviderGetBuildInfoResponse
80 {
81 #[inline]
82 unsafe fn encode(
83 self,
84 encoder: &mut fidl::encoding::Encoder<'_, D>,
85 offset: usize,
86 _depth: fidl::encoding::Depth,
87 ) -> fidl::Result<()> {
88 encoder.debug_check_bounds::<ProviderGetBuildInfoResponse>(offset);
89 fidl::encoding::Encode::<ProviderGetBuildInfoResponse, D>::encode(
91 (<BuildInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.build_info),),
92 encoder,
93 offset,
94 _depth,
95 )
96 }
97 }
98 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BuildInfo, D>>
99 fidl::encoding::Encode<ProviderGetBuildInfoResponse, D> for (T0,)
100 {
101 #[inline]
102 unsafe fn encode(
103 self,
104 encoder: &mut fidl::encoding::Encoder<'_, D>,
105 offset: usize,
106 depth: fidl::encoding::Depth,
107 ) -> fidl::Result<()> {
108 encoder.debug_check_bounds::<ProviderGetBuildInfoResponse>(offset);
109 self.0.encode(encoder, offset + 0, depth)?;
113 Ok(())
114 }
115 }
116
117 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
118 for ProviderGetBuildInfoResponse
119 {
120 #[inline(always)]
121 fn new_empty() -> Self {
122 Self { build_info: fidl::new_empty!(BuildInfo, D) }
123 }
124
125 #[inline]
126 unsafe fn decode(
127 &mut self,
128 decoder: &mut fidl::encoding::Decoder<'_, D>,
129 offset: usize,
130 _depth: fidl::encoding::Depth,
131 ) -> fidl::Result<()> {
132 decoder.debug_check_bounds::<Self>(offset);
133 fidl::decode!(BuildInfo, D, &mut self.build_info, decoder, offset + 0, _depth)?;
135 Ok(())
136 }
137 }
138
139 impl BuildInfo {
140 #[inline(always)]
141 fn max_ordinal_present(&self) -> u64 {
142 if let Some(_) = self.product_version {
143 return 6;
144 }
145 if let Some(_) = self.platform_version {
146 return 5;
147 }
148 if let Some(_) = self.latest_commit_date {
149 return 4;
150 }
151 if let Some(_) = self.version {
152 return 3;
153 }
154 if let Some(_) = self.board_config {
155 return 2;
156 }
157 if let Some(_) = self.product_config {
158 return 1;
159 }
160 0
161 }
162 }
163
164 impl fidl::encoding::ValueTypeMarker for BuildInfo {
165 type Borrowed<'a> = &'a Self;
166 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
167 value
168 }
169 }
170
171 unsafe impl fidl::encoding::TypeMarker for BuildInfo {
172 type Owned = Self;
173
174 #[inline(always)]
175 fn inline_align(_context: fidl::encoding::Context) -> usize {
176 8
177 }
178
179 #[inline(always)]
180 fn inline_size(_context: fidl::encoding::Context) -> usize {
181 16
182 }
183 }
184
185 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BuildInfo, D>
186 for &BuildInfo
187 {
188 unsafe fn encode(
189 self,
190 encoder: &mut fidl::encoding::Encoder<'_, D>,
191 offset: usize,
192 mut depth: fidl::encoding::Depth,
193 ) -> fidl::Result<()> {
194 encoder.debug_check_bounds::<BuildInfo>(offset);
195 let max_ordinal: u64 = self.max_ordinal_present();
197 encoder.write_num(max_ordinal, offset);
198 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
199 if max_ordinal == 0 {
201 return Ok(());
202 }
203 depth.increment()?;
204 let envelope_size = 8;
205 let bytes_len = max_ordinal as usize * envelope_size;
206 #[allow(unused_variables)]
207 let offset = encoder.out_of_line_offset(bytes_len);
208 let mut _prev_end_offset: usize = 0;
209 if 1 > max_ordinal {
210 return Ok(());
211 }
212
213 let cur_offset: usize = (1 - 1) * envelope_size;
216
217 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
219
220 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
225 self.product_config.as_ref().map(
226 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
227 ),
228 encoder,
229 offset + cur_offset,
230 depth,
231 )?;
232
233 _prev_end_offset = cur_offset + envelope_size;
234 if 2 > max_ordinal {
235 return Ok(());
236 }
237
238 let cur_offset: usize = (2 - 1) * envelope_size;
241
242 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
244
245 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
250 self.board_config.as_ref().map(
251 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
252 ),
253 encoder,
254 offset + cur_offset,
255 depth,
256 )?;
257
258 _prev_end_offset = cur_offset + envelope_size;
259 if 3 > max_ordinal {
260 return Ok(());
261 }
262
263 let cur_offset: usize = (3 - 1) * envelope_size;
266
267 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
269
270 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
275 self.version.as_ref().map(
276 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
277 ),
278 encoder,
279 offset + cur_offset,
280 depth,
281 )?;
282
283 _prev_end_offset = cur_offset + envelope_size;
284 if 4 > max_ordinal {
285 return Ok(());
286 }
287
288 let cur_offset: usize = (4 - 1) * envelope_size;
291
292 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
294
295 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
300 self.latest_commit_date.as_ref().map(
301 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
302 ),
303 encoder,
304 offset + cur_offset,
305 depth,
306 )?;
307
308 _prev_end_offset = cur_offset + envelope_size;
309 if 5 > max_ordinal {
310 return Ok(());
311 }
312
313 let cur_offset: usize = (5 - 1) * envelope_size;
316
317 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
319
320 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
325 self.platform_version.as_ref().map(
326 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
327 ),
328 encoder,
329 offset + cur_offset,
330 depth,
331 )?;
332
333 _prev_end_offset = cur_offset + envelope_size;
334 if 6 > max_ordinal {
335 return Ok(());
336 }
337
338 let cur_offset: usize = (6 - 1) * envelope_size;
341
342 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
344
345 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
350 self.product_version.as_ref().map(
351 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
352 ),
353 encoder,
354 offset + cur_offset,
355 depth,
356 )?;
357
358 _prev_end_offset = cur_offset + envelope_size;
359
360 Ok(())
361 }
362 }
363
364 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuildInfo {
365 #[inline(always)]
366 fn new_empty() -> Self {
367 Self::default()
368 }
369
370 unsafe fn decode(
371 &mut self,
372 decoder: &mut fidl::encoding::Decoder<'_, D>,
373 offset: usize,
374 mut depth: fidl::encoding::Depth,
375 ) -> fidl::Result<()> {
376 decoder.debug_check_bounds::<Self>(offset);
377 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
378 None => return Err(fidl::Error::NotNullable),
379 Some(len) => len,
380 };
381 if len == 0 {
383 return Ok(());
384 };
385 depth.increment()?;
386 let envelope_size = 8;
387 let bytes_len = len * envelope_size;
388 let offset = decoder.out_of_line_offset(bytes_len)?;
389 let mut _next_ordinal_to_read = 0;
391 let mut next_offset = offset;
392 let end_offset = offset + bytes_len;
393 _next_ordinal_to_read += 1;
394 if next_offset >= end_offset {
395 return Ok(());
396 }
397
398 while _next_ordinal_to_read < 1 {
400 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
401 _next_ordinal_to_read += 1;
402 next_offset += envelope_size;
403 }
404
405 let next_out_of_line = decoder.next_out_of_line();
406 let handles_before = decoder.remaining_handles();
407 if let Some((inlined, num_bytes, num_handles)) =
408 fidl::encoding::decode_envelope_header(decoder, next_offset)?
409 {
410 let member_inline_size =
411 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
412 decoder.context,
413 );
414 if inlined != (member_inline_size <= 4) {
415 return Err(fidl::Error::InvalidInlineBitInEnvelope);
416 }
417 let inner_offset;
418 let mut inner_depth = depth.clone();
419 if inlined {
420 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
421 inner_offset = next_offset;
422 } else {
423 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
424 inner_depth.increment()?;
425 }
426 let val_ref = self
427 .product_config
428 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
429 fidl::decode!(
430 fidl::encoding::BoundedString<100>,
431 D,
432 val_ref,
433 decoder,
434 inner_offset,
435 inner_depth
436 )?;
437 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
438 {
439 return Err(fidl::Error::InvalidNumBytesInEnvelope);
440 }
441 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
442 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
443 }
444 }
445
446 next_offset += envelope_size;
447 _next_ordinal_to_read += 1;
448 if next_offset >= end_offset {
449 return Ok(());
450 }
451
452 while _next_ordinal_to_read < 2 {
454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
455 _next_ordinal_to_read += 1;
456 next_offset += envelope_size;
457 }
458
459 let next_out_of_line = decoder.next_out_of_line();
460 let handles_before = decoder.remaining_handles();
461 if let Some((inlined, num_bytes, num_handles)) =
462 fidl::encoding::decode_envelope_header(decoder, next_offset)?
463 {
464 let member_inline_size =
465 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
466 decoder.context,
467 );
468 if inlined != (member_inline_size <= 4) {
469 return Err(fidl::Error::InvalidInlineBitInEnvelope);
470 }
471 let inner_offset;
472 let mut inner_depth = depth.clone();
473 if inlined {
474 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
475 inner_offset = next_offset;
476 } else {
477 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
478 inner_depth.increment()?;
479 }
480 let val_ref = self
481 .board_config
482 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
483 fidl::decode!(
484 fidl::encoding::BoundedString<100>,
485 D,
486 val_ref,
487 decoder,
488 inner_offset,
489 inner_depth
490 )?;
491 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
492 {
493 return Err(fidl::Error::InvalidNumBytesInEnvelope);
494 }
495 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
496 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
497 }
498 }
499
500 next_offset += envelope_size;
501 _next_ordinal_to_read += 1;
502 if next_offset >= end_offset {
503 return Ok(());
504 }
505
506 while _next_ordinal_to_read < 3 {
508 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
509 _next_ordinal_to_read += 1;
510 next_offset += envelope_size;
511 }
512
513 let next_out_of_line = decoder.next_out_of_line();
514 let handles_before = decoder.remaining_handles();
515 if let Some((inlined, num_bytes, num_handles)) =
516 fidl::encoding::decode_envelope_header(decoder, next_offset)?
517 {
518 let member_inline_size =
519 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
520 decoder.context,
521 );
522 if inlined != (member_inline_size <= 4) {
523 return Err(fidl::Error::InvalidInlineBitInEnvelope);
524 }
525 let inner_offset;
526 let mut inner_depth = depth.clone();
527 if inlined {
528 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
529 inner_offset = next_offset;
530 } else {
531 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
532 inner_depth.increment()?;
533 }
534 let val_ref = self
535 .version
536 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
537 fidl::decode!(
538 fidl::encoding::BoundedString<100>,
539 D,
540 val_ref,
541 decoder,
542 inner_offset,
543 inner_depth
544 )?;
545 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
546 {
547 return Err(fidl::Error::InvalidNumBytesInEnvelope);
548 }
549 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
550 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
551 }
552 }
553
554 next_offset += envelope_size;
555 _next_ordinal_to_read += 1;
556 if next_offset >= end_offset {
557 return Ok(());
558 }
559
560 while _next_ordinal_to_read < 4 {
562 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
563 _next_ordinal_to_read += 1;
564 next_offset += envelope_size;
565 }
566
567 let next_out_of_line = decoder.next_out_of_line();
568 let handles_before = decoder.remaining_handles();
569 if let Some((inlined, num_bytes, num_handles)) =
570 fidl::encoding::decode_envelope_header(decoder, next_offset)?
571 {
572 let member_inline_size =
573 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
574 decoder.context,
575 );
576 if inlined != (member_inline_size <= 4) {
577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
578 }
579 let inner_offset;
580 let mut inner_depth = depth.clone();
581 if inlined {
582 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
583 inner_offset = next_offset;
584 } else {
585 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
586 inner_depth.increment()?;
587 }
588 let val_ref = self
589 .latest_commit_date
590 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
591 fidl::decode!(
592 fidl::encoding::BoundedString<100>,
593 D,
594 val_ref,
595 decoder,
596 inner_offset,
597 inner_depth
598 )?;
599 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
600 {
601 return Err(fidl::Error::InvalidNumBytesInEnvelope);
602 }
603 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
604 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
605 }
606 }
607
608 next_offset += envelope_size;
609 _next_ordinal_to_read += 1;
610 if next_offset >= end_offset {
611 return Ok(());
612 }
613
614 while _next_ordinal_to_read < 5 {
616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
617 _next_ordinal_to_read += 1;
618 next_offset += envelope_size;
619 }
620
621 let next_out_of_line = decoder.next_out_of_line();
622 let handles_before = decoder.remaining_handles();
623 if let Some((inlined, num_bytes, num_handles)) =
624 fidl::encoding::decode_envelope_header(decoder, next_offset)?
625 {
626 let member_inline_size =
627 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
628 decoder.context,
629 );
630 if inlined != (member_inline_size <= 4) {
631 return Err(fidl::Error::InvalidInlineBitInEnvelope);
632 }
633 let inner_offset;
634 let mut inner_depth = depth.clone();
635 if inlined {
636 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
637 inner_offset = next_offset;
638 } else {
639 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
640 inner_depth.increment()?;
641 }
642 let val_ref = self
643 .platform_version
644 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
645 fidl::decode!(
646 fidl::encoding::BoundedString<100>,
647 D,
648 val_ref,
649 decoder,
650 inner_offset,
651 inner_depth
652 )?;
653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
654 {
655 return Err(fidl::Error::InvalidNumBytesInEnvelope);
656 }
657 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
658 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
659 }
660 }
661
662 next_offset += envelope_size;
663 _next_ordinal_to_read += 1;
664 if next_offset >= end_offset {
665 return Ok(());
666 }
667
668 while _next_ordinal_to_read < 6 {
670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
671 _next_ordinal_to_read += 1;
672 next_offset += envelope_size;
673 }
674
675 let next_out_of_line = decoder.next_out_of_line();
676 let handles_before = decoder.remaining_handles();
677 if let Some((inlined, num_bytes, num_handles)) =
678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
679 {
680 let member_inline_size =
681 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
682 decoder.context,
683 );
684 if inlined != (member_inline_size <= 4) {
685 return Err(fidl::Error::InvalidInlineBitInEnvelope);
686 }
687 let inner_offset;
688 let mut inner_depth = depth.clone();
689 if inlined {
690 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
691 inner_offset = next_offset;
692 } else {
693 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
694 inner_depth.increment()?;
695 }
696 let val_ref = self
697 .product_version
698 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
699 fidl::decode!(
700 fidl::encoding::BoundedString<100>,
701 D,
702 val_ref,
703 decoder,
704 inner_offset,
705 inner_depth
706 )?;
707 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
708 {
709 return Err(fidl::Error::InvalidNumBytesInEnvelope);
710 }
711 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
712 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
713 }
714 }
715
716 next_offset += envelope_size;
717
718 while next_offset < end_offset {
720 _next_ordinal_to_read += 1;
721 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
722 next_offset += envelope_size;
723 }
724
725 Ok(())
726 }
727 }
728}