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_TYPEFACE_RESULTS: u32 = 16;
14
15bitflags! {
16 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
17 pub struct ListTypefacesFlags: u32 {
18 const MATCH_FAMILY_NAME_SUBSTRING = 1;
24 }
25}
26
27impl ListTypefacesFlags {}
28
29#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
30#[repr(u32)]
31pub enum Error {
32 NotFound = 1,
33 Internal = 2,
34}
35
36impl Error {
37 #[inline]
38 pub fn from_primitive(prim: u32) -> Option<Self> {
39 match prim {
40 1 => Some(Self::NotFound),
41 2 => Some(Self::Internal),
42 _ => None,
43 }
44 }
45
46 #[inline]
47 pub const fn into_primitive(self) -> u32 {
48 self as u32
49 }
50}
51
52#[derive(Clone, Debug, PartialEq)]
53pub struct ListTypefacesIteratorGetNextResponse {
54 pub response: TypefaceInfoResponse,
55}
56
57impl fidl::Persistable for ListTypefacesIteratorGetNextResponse {}
58
59#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
60#[repr(C)]
61pub struct ProviderGetTypefaceByIdRequest {
62 pub id: u32,
63}
64
65impl fidl::Persistable for ProviderGetTypefaceByIdRequest {}
66
67#[derive(Clone, Debug, PartialEq)]
68pub struct ProviderGetTypefacesByFamilyRequest {
69 pub family: fidl_fuchsia_fonts__common::FamilyName,
70}
71
72impl fidl::Persistable for ProviderGetTypefacesByFamilyRequest {}
73
74#[derive(Clone, Debug, PartialEq)]
75pub struct ProviderGetTypefacesByFamilyResponse {
76 pub response: TypefaceInfoResponse,
77}
78
79impl fidl::Persistable for ProviderGetTypefacesByFamilyResponse {}
80
81#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
83pub struct SlantRange {
84 pub lower: fidl_fuchsia_fonts__common::Slant,
85 pub upper: fidl_fuchsia_fonts__common::Slant,
86}
87
88impl fidl::Persistable for SlantRange {}
89
90#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
92#[repr(C)]
93pub struct WeightRange {
94 pub lower: u16,
95 pub upper: u16,
96}
97
98impl fidl::Persistable for WeightRange {}
99
100#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
102pub struct WidthRange {
103 pub lower: fidl_fuchsia_fonts__common::Width,
104 pub upper: fidl_fuchsia_fonts__common::Width,
105}
106
107impl fidl::Persistable for WidthRange {}
108
109#[derive(Clone, Debug, Default, PartialEq)]
112pub struct ListTypefacesRequest {
113 pub flags: Option<ListTypefacesFlags>,
116 pub family: Option<fidl_fuchsia_fonts__common::FamilyName>,
120 pub slant: Option<SlantRange>,
122 pub weight: Option<WeightRange>,
124 pub width: Option<WidthRange>,
126 pub languages: Option<Vec<fidl_fuchsia_intl__common::LocaleId>>,
129 pub code_points: Option<Vec<u32>>,
132 pub generic_family: Option<fidl_fuchsia_fonts__common::GenericFontFamily>,
136 #[doc(hidden)]
137 pub __source_breaking: fidl::marker::SourceBreaking,
138}
139
140impl fidl::Persistable for ListTypefacesRequest {}
141
142#[derive(Clone, Debug, Default, PartialEq)]
145pub struct TypefaceInfo {
146 pub asset_id: Option<u32>,
150 pub font_index: Option<u32>,
153 pub family: Option<fidl_fuchsia_fonts__common::FamilyName>,
154 pub style: Option<fidl_fuchsia_fonts__common::Style2>,
155 pub languages: Option<Vec<fidl_fuchsia_intl__common::LocaleId>>,
156 pub generic_family: Option<fidl_fuchsia_fonts__common::GenericFontFamily>,
157 #[doc(hidden)]
158 pub __source_breaking: fidl::marker::SourceBreaking,
159}
160
161impl fidl::Persistable for TypefaceInfo {}
162
163#[derive(Clone, Debug, Default, PartialEq)]
164pub struct TypefaceInfoResponse {
165 pub results: Option<Vec<TypefaceInfo>>,
166 #[doc(hidden)]
167 pub __source_breaking: fidl::marker::SourceBreaking,
168}
169
170impl fidl::Persistable for TypefaceInfoResponse {}
171
172mod internal {
173 use super::*;
174 unsafe impl fidl::encoding::TypeMarker for ListTypefacesFlags {
175 type Owned = Self;
176
177 #[inline(always)]
178 fn inline_align(_context: fidl::encoding::Context) -> usize {
179 4
180 }
181
182 #[inline(always)]
183 fn inline_size(_context: fidl::encoding::Context) -> usize {
184 4
185 }
186 }
187
188 impl fidl::encoding::ValueTypeMarker for ListTypefacesFlags {
189 type Borrowed<'a> = Self;
190 #[inline(always)]
191 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
192 *value
193 }
194 }
195
196 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
197 for ListTypefacesFlags
198 {
199 #[inline]
200 unsafe fn encode(
201 self,
202 encoder: &mut fidl::encoding::Encoder<'_, D>,
203 offset: usize,
204 _depth: fidl::encoding::Depth,
205 ) -> fidl::Result<()> {
206 encoder.debug_check_bounds::<Self>(offset);
207 if self.bits() & Self::all().bits() != self.bits() {
208 return Err(fidl::Error::InvalidBitsValue);
209 }
210 encoder.write_num(self.bits(), offset);
211 Ok(())
212 }
213 }
214
215 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ListTypefacesFlags {
216 #[inline(always)]
217 fn new_empty() -> Self {
218 Self::empty()
219 }
220
221 #[inline]
222 unsafe fn decode(
223 &mut self,
224 decoder: &mut fidl::encoding::Decoder<'_, D>,
225 offset: usize,
226 _depth: fidl::encoding::Depth,
227 ) -> fidl::Result<()> {
228 decoder.debug_check_bounds::<Self>(offset);
229 let prim = decoder.read_num::<u32>(offset);
230 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
231 Ok(())
232 }
233 }
234 unsafe impl fidl::encoding::TypeMarker for Error {
235 type Owned = Self;
236
237 #[inline(always)]
238 fn inline_align(_context: fidl::encoding::Context) -> usize {
239 std::mem::align_of::<u32>()
240 }
241
242 #[inline(always)]
243 fn inline_size(_context: fidl::encoding::Context) -> usize {
244 std::mem::size_of::<u32>()
245 }
246
247 #[inline(always)]
248 fn encode_is_copy() -> bool {
249 true
250 }
251
252 #[inline(always)]
253 fn decode_is_copy() -> bool {
254 false
255 }
256 }
257
258 impl fidl::encoding::ValueTypeMarker for Error {
259 type Borrowed<'a> = Self;
260 #[inline(always)]
261 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
262 *value
263 }
264 }
265
266 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
267 #[inline]
268 unsafe fn encode(
269 self,
270 encoder: &mut fidl::encoding::Encoder<'_, D>,
271 offset: usize,
272 _depth: fidl::encoding::Depth,
273 ) -> fidl::Result<()> {
274 encoder.debug_check_bounds::<Self>(offset);
275 encoder.write_num(self.into_primitive(), offset);
276 Ok(())
277 }
278 }
279
280 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
281 #[inline(always)]
282 fn new_empty() -> Self {
283 Self::NotFound
284 }
285
286 #[inline]
287 unsafe fn decode(
288 &mut self,
289 decoder: &mut fidl::encoding::Decoder<'_, D>,
290 offset: usize,
291 _depth: fidl::encoding::Depth,
292 ) -> fidl::Result<()> {
293 decoder.debug_check_bounds::<Self>(offset);
294 let prim = decoder.read_num::<u32>(offset);
295
296 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
297 Ok(())
298 }
299 }
300
301 impl fidl::encoding::ValueTypeMarker for ListTypefacesIteratorGetNextResponse {
302 type Borrowed<'a> = &'a Self;
303 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
304 value
305 }
306 }
307
308 unsafe impl fidl::encoding::TypeMarker for ListTypefacesIteratorGetNextResponse {
309 type Owned = Self;
310
311 #[inline(always)]
312 fn inline_align(_context: fidl::encoding::Context) -> usize {
313 8
314 }
315
316 #[inline(always)]
317 fn inline_size(_context: fidl::encoding::Context) -> usize {
318 16
319 }
320 }
321
322 unsafe impl<D: fidl::encoding::ResourceDialect>
323 fidl::encoding::Encode<ListTypefacesIteratorGetNextResponse, D>
324 for &ListTypefacesIteratorGetNextResponse
325 {
326 #[inline]
327 unsafe fn encode(
328 self,
329 encoder: &mut fidl::encoding::Encoder<'_, D>,
330 offset: usize,
331 _depth: fidl::encoding::Depth,
332 ) -> fidl::Result<()> {
333 encoder.debug_check_bounds::<ListTypefacesIteratorGetNextResponse>(offset);
334 fidl::encoding::Encode::<ListTypefacesIteratorGetNextResponse, D>::encode(
336 (<TypefaceInfoResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.response),),
337 encoder,
338 offset,
339 _depth,
340 )
341 }
342 }
343 unsafe impl<
344 D: fidl::encoding::ResourceDialect,
345 T0: fidl::encoding::Encode<TypefaceInfoResponse, D>,
346 > fidl::encoding::Encode<ListTypefacesIteratorGetNextResponse, D> for (T0,)
347 {
348 #[inline]
349 unsafe fn encode(
350 self,
351 encoder: &mut fidl::encoding::Encoder<'_, D>,
352 offset: usize,
353 depth: fidl::encoding::Depth,
354 ) -> fidl::Result<()> {
355 encoder.debug_check_bounds::<ListTypefacesIteratorGetNextResponse>(offset);
356 self.0.encode(encoder, offset + 0, depth)?;
360 Ok(())
361 }
362 }
363
364 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
365 for ListTypefacesIteratorGetNextResponse
366 {
367 #[inline(always)]
368 fn new_empty() -> Self {
369 Self { response: fidl::new_empty!(TypefaceInfoResponse, D) }
370 }
371
372 #[inline]
373 unsafe fn decode(
374 &mut self,
375 decoder: &mut fidl::encoding::Decoder<'_, D>,
376 offset: usize,
377 _depth: fidl::encoding::Depth,
378 ) -> fidl::Result<()> {
379 decoder.debug_check_bounds::<Self>(offset);
380 fidl::decode!(
382 TypefaceInfoResponse,
383 D,
384 &mut self.response,
385 decoder,
386 offset + 0,
387 _depth
388 )?;
389 Ok(())
390 }
391 }
392
393 impl fidl::encoding::ValueTypeMarker for ProviderGetTypefaceByIdRequest {
394 type Borrowed<'a> = &'a Self;
395 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
396 value
397 }
398 }
399
400 unsafe impl fidl::encoding::TypeMarker for ProviderGetTypefaceByIdRequest {
401 type Owned = Self;
402
403 #[inline(always)]
404 fn inline_align(_context: fidl::encoding::Context) -> usize {
405 4
406 }
407
408 #[inline(always)]
409 fn inline_size(_context: fidl::encoding::Context) -> usize {
410 4
411 }
412 #[inline(always)]
413 fn encode_is_copy() -> bool {
414 true
415 }
416
417 #[inline(always)]
418 fn decode_is_copy() -> bool {
419 true
420 }
421 }
422
423 unsafe impl<D: fidl::encoding::ResourceDialect>
424 fidl::encoding::Encode<ProviderGetTypefaceByIdRequest, D>
425 for &ProviderGetTypefaceByIdRequest
426 {
427 #[inline]
428 unsafe fn encode(
429 self,
430 encoder: &mut fidl::encoding::Encoder<'_, D>,
431 offset: usize,
432 _depth: fidl::encoding::Depth,
433 ) -> fidl::Result<()> {
434 encoder.debug_check_bounds::<ProviderGetTypefaceByIdRequest>(offset);
435 unsafe {
436 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
438 (buf_ptr as *mut ProviderGetTypefaceByIdRequest)
439 .write_unaligned((self as *const ProviderGetTypefaceByIdRequest).read());
440 }
443 Ok(())
444 }
445 }
446 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
447 fidl::encoding::Encode<ProviderGetTypefaceByIdRequest, D> for (T0,)
448 {
449 #[inline]
450 unsafe fn encode(
451 self,
452 encoder: &mut fidl::encoding::Encoder<'_, D>,
453 offset: usize,
454 depth: fidl::encoding::Depth,
455 ) -> fidl::Result<()> {
456 encoder.debug_check_bounds::<ProviderGetTypefaceByIdRequest>(offset);
457 self.0.encode(encoder, offset + 0, depth)?;
461 Ok(())
462 }
463 }
464
465 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
466 for ProviderGetTypefaceByIdRequest
467 {
468 #[inline(always)]
469 fn new_empty() -> Self {
470 Self { id: fidl::new_empty!(u32, D) }
471 }
472
473 #[inline]
474 unsafe fn decode(
475 &mut self,
476 decoder: &mut fidl::encoding::Decoder<'_, D>,
477 offset: usize,
478 _depth: fidl::encoding::Depth,
479 ) -> fidl::Result<()> {
480 decoder.debug_check_bounds::<Self>(offset);
481 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
482 unsafe {
485 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
486 }
487 Ok(())
488 }
489 }
490
491 impl fidl::encoding::ValueTypeMarker for ProviderGetTypefacesByFamilyRequest {
492 type Borrowed<'a> = &'a Self;
493 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
494 value
495 }
496 }
497
498 unsafe impl fidl::encoding::TypeMarker for ProviderGetTypefacesByFamilyRequest {
499 type Owned = Self;
500
501 #[inline(always)]
502 fn inline_align(_context: fidl::encoding::Context) -> usize {
503 8
504 }
505
506 #[inline(always)]
507 fn inline_size(_context: fidl::encoding::Context) -> usize {
508 16
509 }
510 }
511
512 unsafe impl<D: fidl::encoding::ResourceDialect>
513 fidl::encoding::Encode<ProviderGetTypefacesByFamilyRequest, D>
514 for &ProviderGetTypefacesByFamilyRequest
515 {
516 #[inline]
517 unsafe fn encode(
518 self,
519 encoder: &mut fidl::encoding::Encoder<'_, D>,
520 offset: usize,
521 _depth: fidl::encoding::Depth,
522 ) -> fidl::Result<()> {
523 encoder.debug_check_bounds::<ProviderGetTypefacesByFamilyRequest>(offset);
524 fidl::encoding::Encode::<ProviderGetTypefacesByFamilyRequest, D>::encode(
526 (
527 <fidl_fuchsia_fonts__common::FamilyName as fidl::encoding::ValueTypeMarker>::borrow(&self.family),
528 ),
529 encoder, offset, _depth
530 )
531 }
532 }
533 unsafe impl<
534 D: fidl::encoding::ResourceDialect,
535 T0: fidl::encoding::Encode<fidl_fuchsia_fonts__common::FamilyName, D>,
536 > fidl::encoding::Encode<ProviderGetTypefacesByFamilyRequest, D> for (T0,)
537 {
538 #[inline]
539 unsafe fn encode(
540 self,
541 encoder: &mut fidl::encoding::Encoder<'_, D>,
542 offset: usize,
543 depth: fidl::encoding::Depth,
544 ) -> fidl::Result<()> {
545 encoder.debug_check_bounds::<ProviderGetTypefacesByFamilyRequest>(offset);
546 self.0.encode(encoder, offset + 0, depth)?;
550 Ok(())
551 }
552 }
553
554 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
555 for ProviderGetTypefacesByFamilyRequest
556 {
557 #[inline(always)]
558 fn new_empty() -> Self {
559 Self { family: fidl::new_empty!(fidl_fuchsia_fonts__common::FamilyName, D) }
560 }
561
562 #[inline]
563 unsafe fn decode(
564 &mut self,
565 decoder: &mut fidl::encoding::Decoder<'_, D>,
566 offset: usize,
567 _depth: fidl::encoding::Depth,
568 ) -> fidl::Result<()> {
569 decoder.debug_check_bounds::<Self>(offset);
570 fidl::decode!(
572 fidl_fuchsia_fonts__common::FamilyName,
573 D,
574 &mut self.family,
575 decoder,
576 offset + 0,
577 _depth
578 )?;
579 Ok(())
580 }
581 }
582
583 impl fidl::encoding::ValueTypeMarker for ProviderGetTypefacesByFamilyResponse {
584 type Borrowed<'a> = &'a Self;
585 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
586 value
587 }
588 }
589
590 unsafe impl fidl::encoding::TypeMarker for ProviderGetTypefacesByFamilyResponse {
591 type Owned = Self;
592
593 #[inline(always)]
594 fn inline_align(_context: fidl::encoding::Context) -> usize {
595 8
596 }
597
598 #[inline(always)]
599 fn inline_size(_context: fidl::encoding::Context) -> usize {
600 16
601 }
602 }
603
604 unsafe impl<D: fidl::encoding::ResourceDialect>
605 fidl::encoding::Encode<ProviderGetTypefacesByFamilyResponse, D>
606 for &ProviderGetTypefacesByFamilyResponse
607 {
608 #[inline]
609 unsafe fn encode(
610 self,
611 encoder: &mut fidl::encoding::Encoder<'_, D>,
612 offset: usize,
613 _depth: fidl::encoding::Depth,
614 ) -> fidl::Result<()> {
615 encoder.debug_check_bounds::<ProviderGetTypefacesByFamilyResponse>(offset);
616 fidl::encoding::Encode::<ProviderGetTypefacesByFamilyResponse, D>::encode(
618 (<TypefaceInfoResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.response),),
619 encoder,
620 offset,
621 _depth,
622 )
623 }
624 }
625 unsafe impl<
626 D: fidl::encoding::ResourceDialect,
627 T0: fidl::encoding::Encode<TypefaceInfoResponse, D>,
628 > fidl::encoding::Encode<ProviderGetTypefacesByFamilyResponse, D> for (T0,)
629 {
630 #[inline]
631 unsafe fn encode(
632 self,
633 encoder: &mut fidl::encoding::Encoder<'_, D>,
634 offset: usize,
635 depth: fidl::encoding::Depth,
636 ) -> fidl::Result<()> {
637 encoder.debug_check_bounds::<ProviderGetTypefacesByFamilyResponse>(offset);
638 self.0.encode(encoder, offset + 0, depth)?;
642 Ok(())
643 }
644 }
645
646 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
647 for ProviderGetTypefacesByFamilyResponse
648 {
649 #[inline(always)]
650 fn new_empty() -> Self {
651 Self { response: fidl::new_empty!(TypefaceInfoResponse, D) }
652 }
653
654 #[inline]
655 unsafe fn decode(
656 &mut self,
657 decoder: &mut fidl::encoding::Decoder<'_, D>,
658 offset: usize,
659 _depth: fidl::encoding::Depth,
660 ) -> fidl::Result<()> {
661 decoder.debug_check_bounds::<Self>(offset);
662 fidl::decode!(
664 TypefaceInfoResponse,
665 D,
666 &mut self.response,
667 decoder,
668 offset + 0,
669 _depth
670 )?;
671 Ok(())
672 }
673 }
674
675 impl fidl::encoding::ValueTypeMarker for SlantRange {
676 type Borrowed<'a> = &'a Self;
677 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
678 value
679 }
680 }
681
682 unsafe impl fidl::encoding::TypeMarker for SlantRange {
683 type Owned = Self;
684
685 #[inline(always)]
686 fn inline_align(_context: fidl::encoding::Context) -> usize {
687 4
688 }
689
690 #[inline(always)]
691 fn inline_size(_context: fidl::encoding::Context) -> usize {
692 8
693 }
694 }
695
696 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SlantRange, D>
697 for &SlantRange
698 {
699 #[inline]
700 unsafe fn encode(
701 self,
702 encoder: &mut fidl::encoding::Encoder<'_, D>,
703 offset: usize,
704 _depth: fidl::encoding::Depth,
705 ) -> fidl::Result<()> {
706 encoder.debug_check_bounds::<SlantRange>(offset);
707 fidl::encoding::Encode::<SlantRange, D>::encode(
709 (
710 <fidl_fuchsia_fonts__common::Slant as fidl::encoding::ValueTypeMarker>::borrow(
711 &self.lower,
712 ),
713 <fidl_fuchsia_fonts__common::Slant as fidl::encoding::ValueTypeMarker>::borrow(
714 &self.upper,
715 ),
716 ),
717 encoder,
718 offset,
719 _depth,
720 )
721 }
722 }
723 unsafe impl<
724 D: fidl::encoding::ResourceDialect,
725 T0: fidl::encoding::Encode<fidl_fuchsia_fonts__common::Slant, D>,
726 T1: fidl::encoding::Encode<fidl_fuchsia_fonts__common::Slant, D>,
727 > fidl::encoding::Encode<SlantRange, D> for (T0, T1)
728 {
729 #[inline]
730 unsafe fn encode(
731 self,
732 encoder: &mut fidl::encoding::Encoder<'_, D>,
733 offset: usize,
734 depth: fidl::encoding::Depth,
735 ) -> fidl::Result<()> {
736 encoder.debug_check_bounds::<SlantRange>(offset);
737 self.0.encode(encoder, offset + 0, depth)?;
741 self.1.encode(encoder, offset + 4, depth)?;
742 Ok(())
743 }
744 }
745
746 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SlantRange {
747 #[inline(always)]
748 fn new_empty() -> Self {
749 Self {
750 lower: fidl::new_empty!(fidl_fuchsia_fonts__common::Slant, D),
751 upper: fidl::new_empty!(fidl_fuchsia_fonts__common::Slant, D),
752 }
753 }
754
755 #[inline]
756 unsafe fn decode(
757 &mut self,
758 decoder: &mut fidl::encoding::Decoder<'_, D>,
759 offset: usize,
760 _depth: fidl::encoding::Depth,
761 ) -> fidl::Result<()> {
762 decoder.debug_check_bounds::<Self>(offset);
763 fidl::decode!(
765 fidl_fuchsia_fonts__common::Slant,
766 D,
767 &mut self.lower,
768 decoder,
769 offset + 0,
770 _depth
771 )?;
772 fidl::decode!(
773 fidl_fuchsia_fonts__common::Slant,
774 D,
775 &mut self.upper,
776 decoder,
777 offset + 4,
778 _depth
779 )?;
780 Ok(())
781 }
782 }
783
784 impl fidl::encoding::ValueTypeMarker for WeightRange {
785 type Borrowed<'a> = &'a Self;
786 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
787 value
788 }
789 }
790
791 unsafe impl fidl::encoding::TypeMarker for WeightRange {
792 type Owned = Self;
793
794 #[inline(always)]
795 fn inline_align(_context: fidl::encoding::Context) -> usize {
796 2
797 }
798
799 #[inline(always)]
800 fn inline_size(_context: fidl::encoding::Context) -> usize {
801 4
802 }
803 #[inline(always)]
804 fn encode_is_copy() -> bool {
805 true
806 }
807
808 #[inline(always)]
809 fn decode_is_copy() -> bool {
810 true
811 }
812 }
813
814 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WeightRange, D>
815 for &WeightRange
816 {
817 #[inline]
818 unsafe fn encode(
819 self,
820 encoder: &mut fidl::encoding::Encoder<'_, D>,
821 offset: usize,
822 _depth: fidl::encoding::Depth,
823 ) -> fidl::Result<()> {
824 encoder.debug_check_bounds::<WeightRange>(offset);
825 unsafe {
826 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
828 (buf_ptr as *mut WeightRange).write_unaligned((self as *const WeightRange).read());
829 }
832 Ok(())
833 }
834 }
835 unsafe impl<
836 D: fidl::encoding::ResourceDialect,
837 T0: fidl::encoding::Encode<u16, D>,
838 T1: fidl::encoding::Encode<u16, D>,
839 > fidl::encoding::Encode<WeightRange, D> for (T0, T1)
840 {
841 #[inline]
842 unsafe fn encode(
843 self,
844 encoder: &mut fidl::encoding::Encoder<'_, D>,
845 offset: usize,
846 depth: fidl::encoding::Depth,
847 ) -> fidl::Result<()> {
848 encoder.debug_check_bounds::<WeightRange>(offset);
849 self.0.encode(encoder, offset + 0, depth)?;
853 self.1.encode(encoder, offset + 2, depth)?;
854 Ok(())
855 }
856 }
857
858 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WeightRange {
859 #[inline(always)]
860 fn new_empty() -> Self {
861 Self { lower: fidl::new_empty!(u16, D), upper: fidl::new_empty!(u16, D) }
862 }
863
864 #[inline]
865 unsafe fn decode(
866 &mut self,
867 decoder: &mut fidl::encoding::Decoder<'_, D>,
868 offset: usize,
869 _depth: fidl::encoding::Depth,
870 ) -> fidl::Result<()> {
871 decoder.debug_check_bounds::<Self>(offset);
872 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
873 unsafe {
876 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
877 }
878 Ok(())
879 }
880 }
881
882 impl fidl::encoding::ValueTypeMarker for WidthRange {
883 type Borrowed<'a> = &'a Self;
884 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
885 value
886 }
887 }
888
889 unsafe impl fidl::encoding::TypeMarker for WidthRange {
890 type Owned = Self;
891
892 #[inline(always)]
893 fn inline_align(_context: fidl::encoding::Context) -> usize {
894 4
895 }
896
897 #[inline(always)]
898 fn inline_size(_context: fidl::encoding::Context) -> usize {
899 8
900 }
901 }
902
903 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WidthRange, D>
904 for &WidthRange
905 {
906 #[inline]
907 unsafe fn encode(
908 self,
909 encoder: &mut fidl::encoding::Encoder<'_, D>,
910 offset: usize,
911 _depth: fidl::encoding::Depth,
912 ) -> fidl::Result<()> {
913 encoder.debug_check_bounds::<WidthRange>(offset);
914 fidl::encoding::Encode::<WidthRange, D>::encode(
916 (
917 <fidl_fuchsia_fonts__common::Width as fidl::encoding::ValueTypeMarker>::borrow(
918 &self.lower,
919 ),
920 <fidl_fuchsia_fonts__common::Width as fidl::encoding::ValueTypeMarker>::borrow(
921 &self.upper,
922 ),
923 ),
924 encoder,
925 offset,
926 _depth,
927 )
928 }
929 }
930 unsafe impl<
931 D: fidl::encoding::ResourceDialect,
932 T0: fidl::encoding::Encode<fidl_fuchsia_fonts__common::Width, D>,
933 T1: fidl::encoding::Encode<fidl_fuchsia_fonts__common::Width, D>,
934 > fidl::encoding::Encode<WidthRange, D> for (T0, T1)
935 {
936 #[inline]
937 unsafe fn encode(
938 self,
939 encoder: &mut fidl::encoding::Encoder<'_, D>,
940 offset: usize,
941 depth: fidl::encoding::Depth,
942 ) -> fidl::Result<()> {
943 encoder.debug_check_bounds::<WidthRange>(offset);
944 self.0.encode(encoder, offset + 0, depth)?;
948 self.1.encode(encoder, offset + 4, depth)?;
949 Ok(())
950 }
951 }
952
953 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WidthRange {
954 #[inline(always)]
955 fn new_empty() -> Self {
956 Self {
957 lower: fidl::new_empty!(fidl_fuchsia_fonts__common::Width, D),
958 upper: fidl::new_empty!(fidl_fuchsia_fonts__common::Width, D),
959 }
960 }
961
962 #[inline]
963 unsafe fn decode(
964 &mut self,
965 decoder: &mut fidl::encoding::Decoder<'_, D>,
966 offset: usize,
967 _depth: fidl::encoding::Depth,
968 ) -> fidl::Result<()> {
969 decoder.debug_check_bounds::<Self>(offset);
970 fidl::decode!(
972 fidl_fuchsia_fonts__common::Width,
973 D,
974 &mut self.lower,
975 decoder,
976 offset + 0,
977 _depth
978 )?;
979 fidl::decode!(
980 fidl_fuchsia_fonts__common::Width,
981 D,
982 &mut self.upper,
983 decoder,
984 offset + 4,
985 _depth
986 )?;
987 Ok(())
988 }
989 }
990
991 impl ListTypefacesRequest {
992 #[inline(always)]
993 fn max_ordinal_present(&self) -> u64 {
994 if let Some(_) = self.generic_family {
995 return 8;
996 }
997 if let Some(_) = self.code_points {
998 return 7;
999 }
1000 if let Some(_) = self.languages {
1001 return 6;
1002 }
1003 if let Some(_) = self.width {
1004 return 5;
1005 }
1006 if let Some(_) = self.weight {
1007 return 4;
1008 }
1009 if let Some(_) = self.slant {
1010 return 3;
1011 }
1012 if let Some(_) = self.family {
1013 return 2;
1014 }
1015 if let Some(_) = self.flags {
1016 return 1;
1017 }
1018 0
1019 }
1020 }
1021
1022 impl fidl::encoding::ValueTypeMarker for ListTypefacesRequest {
1023 type Borrowed<'a> = &'a Self;
1024 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1025 value
1026 }
1027 }
1028
1029 unsafe impl fidl::encoding::TypeMarker for ListTypefacesRequest {
1030 type Owned = Self;
1031
1032 #[inline(always)]
1033 fn inline_align(_context: fidl::encoding::Context) -> usize {
1034 8
1035 }
1036
1037 #[inline(always)]
1038 fn inline_size(_context: fidl::encoding::Context) -> usize {
1039 16
1040 }
1041 }
1042
1043 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ListTypefacesRequest, D>
1044 for &ListTypefacesRequest
1045 {
1046 unsafe fn encode(
1047 self,
1048 encoder: &mut fidl::encoding::Encoder<'_, D>,
1049 offset: usize,
1050 mut depth: fidl::encoding::Depth,
1051 ) -> fidl::Result<()> {
1052 encoder.debug_check_bounds::<ListTypefacesRequest>(offset);
1053 let max_ordinal: u64 = self.max_ordinal_present();
1055 encoder.write_num(max_ordinal, offset);
1056 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1057 if max_ordinal == 0 {
1059 return Ok(());
1060 }
1061 depth.increment()?;
1062 let envelope_size = 8;
1063 let bytes_len = max_ordinal as usize * envelope_size;
1064 #[allow(unused_variables)]
1065 let offset = encoder.out_of_line_offset(bytes_len);
1066 let mut _prev_end_offset: usize = 0;
1067 if 1 > max_ordinal {
1068 return Ok(());
1069 }
1070
1071 let cur_offset: usize = (1 - 1) * envelope_size;
1074
1075 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1077
1078 fidl::encoding::encode_in_envelope_optional::<ListTypefacesFlags, D>(
1083 self.flags
1084 .as_ref()
1085 .map(<ListTypefacesFlags as fidl::encoding::ValueTypeMarker>::borrow),
1086 encoder,
1087 offset + cur_offset,
1088 depth,
1089 )?;
1090
1091 _prev_end_offset = cur_offset + envelope_size;
1092 if 2 > max_ordinal {
1093 return Ok(());
1094 }
1095
1096 let cur_offset: usize = (2 - 1) * envelope_size;
1099
1100 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1102
1103 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_fonts__common::FamilyName, D>(
1108 self.family.as_ref().map(<fidl_fuchsia_fonts__common::FamilyName as fidl::encoding::ValueTypeMarker>::borrow),
1109 encoder, offset + cur_offset, depth
1110 )?;
1111
1112 _prev_end_offset = cur_offset + envelope_size;
1113 if 3 > max_ordinal {
1114 return Ok(());
1115 }
1116
1117 let cur_offset: usize = (3 - 1) * envelope_size;
1120
1121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1123
1124 fidl::encoding::encode_in_envelope_optional::<SlantRange, D>(
1129 self.slant.as_ref().map(<SlantRange as fidl::encoding::ValueTypeMarker>::borrow),
1130 encoder,
1131 offset + cur_offset,
1132 depth,
1133 )?;
1134
1135 _prev_end_offset = cur_offset + envelope_size;
1136 if 4 > max_ordinal {
1137 return Ok(());
1138 }
1139
1140 let cur_offset: usize = (4 - 1) * envelope_size;
1143
1144 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1146
1147 fidl::encoding::encode_in_envelope_optional::<WeightRange, D>(
1152 self.weight.as_ref().map(<WeightRange as fidl::encoding::ValueTypeMarker>::borrow),
1153 encoder,
1154 offset + cur_offset,
1155 depth,
1156 )?;
1157
1158 _prev_end_offset = cur_offset + envelope_size;
1159 if 5 > max_ordinal {
1160 return Ok(());
1161 }
1162
1163 let cur_offset: usize = (5 - 1) * envelope_size;
1166
1167 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1169
1170 fidl::encoding::encode_in_envelope_optional::<WidthRange, D>(
1175 self.width.as_ref().map(<WidthRange as fidl::encoding::ValueTypeMarker>::borrow),
1176 encoder,
1177 offset + cur_offset,
1178 depth,
1179 )?;
1180
1181 _prev_end_offset = cur_offset + envelope_size;
1182 if 6 > max_ordinal {
1183 return Ok(());
1184 }
1185
1186 let cur_offset: usize = (6 - 1) * envelope_size;
1189
1190 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1192
1193 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_intl__common::LocaleId, 8>, D>(
1198 self.languages.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_intl__common::LocaleId, 8> as fidl::encoding::ValueTypeMarker>::borrow),
1199 encoder, offset + cur_offset, depth
1200 )?;
1201
1202 _prev_end_offset = cur_offset + envelope_size;
1203 if 7 > max_ordinal {
1204 return Ok(());
1205 }
1206
1207 let cur_offset: usize = (7 - 1) * envelope_size;
1210
1211 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1213
1214 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, D>(
1219 self.code_points.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
1220 encoder, offset + cur_offset, depth
1221 )?;
1222
1223 _prev_end_offset = cur_offset + envelope_size;
1224 if 8 > max_ordinal {
1225 return Ok(());
1226 }
1227
1228 let cur_offset: usize = (8 - 1) * envelope_size;
1231
1232 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1234
1235 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_fonts__common::GenericFontFamily, D>(
1240 self.generic_family.as_ref().map(<fidl_fuchsia_fonts__common::GenericFontFamily as fidl::encoding::ValueTypeMarker>::borrow),
1241 encoder, offset + cur_offset, depth
1242 )?;
1243
1244 _prev_end_offset = cur_offset + envelope_size;
1245
1246 Ok(())
1247 }
1248 }
1249
1250 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ListTypefacesRequest {
1251 #[inline(always)]
1252 fn new_empty() -> Self {
1253 Self::default()
1254 }
1255
1256 unsafe fn decode(
1257 &mut self,
1258 decoder: &mut fidl::encoding::Decoder<'_, D>,
1259 offset: usize,
1260 mut depth: fidl::encoding::Depth,
1261 ) -> fidl::Result<()> {
1262 decoder.debug_check_bounds::<Self>(offset);
1263 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1264 None => return Err(fidl::Error::NotNullable),
1265 Some(len) => len,
1266 };
1267 if len == 0 {
1269 return Ok(());
1270 };
1271 depth.increment()?;
1272 let envelope_size = 8;
1273 let bytes_len = len * envelope_size;
1274 let offset = decoder.out_of_line_offset(bytes_len)?;
1275 let mut _next_ordinal_to_read = 0;
1277 let mut next_offset = offset;
1278 let end_offset = offset + bytes_len;
1279 _next_ordinal_to_read += 1;
1280 if next_offset >= end_offset {
1281 return Ok(());
1282 }
1283
1284 while _next_ordinal_to_read < 1 {
1286 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1287 _next_ordinal_to_read += 1;
1288 next_offset += envelope_size;
1289 }
1290
1291 let next_out_of_line = decoder.next_out_of_line();
1292 let handles_before = decoder.remaining_handles();
1293 if let Some((inlined, num_bytes, num_handles)) =
1294 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1295 {
1296 let member_inline_size =
1297 <ListTypefacesFlags as fidl::encoding::TypeMarker>::inline_size(
1298 decoder.context,
1299 );
1300 if inlined != (member_inline_size <= 4) {
1301 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1302 }
1303 let inner_offset;
1304 let mut inner_depth = depth.clone();
1305 if inlined {
1306 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1307 inner_offset = next_offset;
1308 } else {
1309 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1310 inner_depth.increment()?;
1311 }
1312 let val_ref =
1313 self.flags.get_or_insert_with(|| fidl::new_empty!(ListTypefacesFlags, D));
1314 fidl::decode!(ListTypefacesFlags, D, val_ref, decoder, inner_offset, inner_depth)?;
1315 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1316 {
1317 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1318 }
1319 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1320 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1321 }
1322 }
1323
1324 next_offset += envelope_size;
1325 _next_ordinal_to_read += 1;
1326 if next_offset >= end_offset {
1327 return Ok(());
1328 }
1329
1330 while _next_ordinal_to_read < 2 {
1332 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1333 _next_ordinal_to_read += 1;
1334 next_offset += envelope_size;
1335 }
1336
1337 let next_out_of_line = decoder.next_out_of_line();
1338 let handles_before = decoder.remaining_handles();
1339 if let Some((inlined, num_bytes, num_handles)) =
1340 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1341 {
1342 let member_inline_size = <fidl_fuchsia_fonts__common::FamilyName as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1343 if inlined != (member_inline_size <= 4) {
1344 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1345 }
1346 let inner_offset;
1347 let mut inner_depth = depth.clone();
1348 if inlined {
1349 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1350 inner_offset = next_offset;
1351 } else {
1352 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1353 inner_depth.increment()?;
1354 }
1355 let val_ref = self.family.get_or_insert_with(|| {
1356 fidl::new_empty!(fidl_fuchsia_fonts__common::FamilyName, D)
1357 });
1358 fidl::decode!(
1359 fidl_fuchsia_fonts__common::FamilyName,
1360 D,
1361 val_ref,
1362 decoder,
1363 inner_offset,
1364 inner_depth
1365 )?;
1366 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1367 {
1368 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1369 }
1370 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1371 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1372 }
1373 }
1374
1375 next_offset += envelope_size;
1376 _next_ordinal_to_read += 1;
1377 if next_offset >= end_offset {
1378 return Ok(());
1379 }
1380
1381 while _next_ordinal_to_read < 3 {
1383 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1384 _next_ordinal_to_read += 1;
1385 next_offset += envelope_size;
1386 }
1387
1388 let next_out_of_line = decoder.next_out_of_line();
1389 let handles_before = decoder.remaining_handles();
1390 if let Some((inlined, num_bytes, num_handles)) =
1391 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1392 {
1393 let member_inline_size =
1394 <SlantRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1395 if inlined != (member_inline_size <= 4) {
1396 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1397 }
1398 let inner_offset;
1399 let mut inner_depth = depth.clone();
1400 if inlined {
1401 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1402 inner_offset = next_offset;
1403 } else {
1404 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1405 inner_depth.increment()?;
1406 }
1407 let val_ref = self.slant.get_or_insert_with(|| fidl::new_empty!(SlantRange, D));
1408 fidl::decode!(SlantRange, D, val_ref, decoder, inner_offset, inner_depth)?;
1409 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1410 {
1411 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1412 }
1413 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1414 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1415 }
1416 }
1417
1418 next_offset += envelope_size;
1419 _next_ordinal_to_read += 1;
1420 if next_offset >= end_offset {
1421 return Ok(());
1422 }
1423
1424 while _next_ordinal_to_read < 4 {
1426 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1427 _next_ordinal_to_read += 1;
1428 next_offset += envelope_size;
1429 }
1430
1431 let next_out_of_line = decoder.next_out_of_line();
1432 let handles_before = decoder.remaining_handles();
1433 if let Some((inlined, num_bytes, num_handles)) =
1434 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1435 {
1436 let member_inline_size =
1437 <WeightRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1438 if inlined != (member_inline_size <= 4) {
1439 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1440 }
1441 let inner_offset;
1442 let mut inner_depth = depth.clone();
1443 if inlined {
1444 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1445 inner_offset = next_offset;
1446 } else {
1447 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1448 inner_depth.increment()?;
1449 }
1450 let val_ref = self.weight.get_or_insert_with(|| fidl::new_empty!(WeightRange, D));
1451 fidl::decode!(WeightRange, D, val_ref, decoder, inner_offset, inner_depth)?;
1452 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1453 {
1454 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1455 }
1456 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1457 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1458 }
1459 }
1460
1461 next_offset += envelope_size;
1462 _next_ordinal_to_read += 1;
1463 if next_offset >= end_offset {
1464 return Ok(());
1465 }
1466
1467 while _next_ordinal_to_read < 5 {
1469 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1470 _next_ordinal_to_read += 1;
1471 next_offset += envelope_size;
1472 }
1473
1474 let next_out_of_line = decoder.next_out_of_line();
1475 let handles_before = decoder.remaining_handles();
1476 if let Some((inlined, num_bytes, num_handles)) =
1477 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1478 {
1479 let member_inline_size =
1480 <WidthRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1481 if inlined != (member_inline_size <= 4) {
1482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1483 }
1484 let inner_offset;
1485 let mut inner_depth = depth.clone();
1486 if inlined {
1487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1488 inner_offset = next_offset;
1489 } else {
1490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1491 inner_depth.increment()?;
1492 }
1493 let val_ref = self.width.get_or_insert_with(|| fidl::new_empty!(WidthRange, D));
1494 fidl::decode!(WidthRange, D, val_ref, decoder, inner_offset, inner_depth)?;
1495 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1496 {
1497 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1498 }
1499 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1500 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1501 }
1502 }
1503
1504 next_offset += envelope_size;
1505 _next_ordinal_to_read += 1;
1506 if next_offset >= end_offset {
1507 return Ok(());
1508 }
1509
1510 while _next_ordinal_to_read < 6 {
1512 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1513 _next_ordinal_to_read += 1;
1514 next_offset += envelope_size;
1515 }
1516
1517 let next_out_of_line = decoder.next_out_of_line();
1518 let handles_before = decoder.remaining_handles();
1519 if let Some((inlined, num_bytes, num_handles)) =
1520 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1521 {
1522 let member_inline_size = <fidl::encoding::Vector<
1523 fidl_fuchsia_intl__common::LocaleId,
1524 8,
1525 > as fidl::encoding::TypeMarker>::inline_size(
1526 decoder.context
1527 );
1528 if inlined != (member_inline_size <= 4) {
1529 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1530 }
1531 let inner_offset;
1532 let mut inner_depth = depth.clone();
1533 if inlined {
1534 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1535 inner_offset = next_offset;
1536 } else {
1537 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1538 inner_depth.increment()?;
1539 }
1540 let val_ref =
1541 self.languages.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_intl__common::LocaleId, 8>, D));
1542 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_intl__common::LocaleId, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
1543 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1544 {
1545 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1546 }
1547 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1548 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1549 }
1550 }
1551
1552 next_offset += envelope_size;
1553 _next_ordinal_to_read += 1;
1554 if next_offset >= end_offset {
1555 return Ok(());
1556 }
1557
1558 while _next_ordinal_to_read < 7 {
1560 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1561 _next_ordinal_to_read += 1;
1562 next_offset += envelope_size;
1563 }
1564
1565 let next_out_of_line = decoder.next_out_of_line();
1566 let handles_before = decoder.remaining_handles();
1567 if let Some((inlined, num_bytes, num_handles)) =
1568 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1569 {
1570 let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1571 if inlined != (member_inline_size <= 4) {
1572 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1573 }
1574 let inner_offset;
1575 let mut inner_depth = depth.clone();
1576 if inlined {
1577 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1578 inner_offset = next_offset;
1579 } else {
1580 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1581 inner_depth.increment()?;
1582 }
1583 let val_ref = self.code_points.get_or_insert_with(|| {
1584 fidl::new_empty!(fidl::encoding::UnboundedVector<u32>, D)
1585 });
1586 fidl::decode!(
1587 fidl::encoding::UnboundedVector<u32>,
1588 D,
1589 val_ref,
1590 decoder,
1591 inner_offset,
1592 inner_depth
1593 )?;
1594 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1595 {
1596 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1597 }
1598 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1599 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1600 }
1601 }
1602
1603 next_offset += envelope_size;
1604 _next_ordinal_to_read += 1;
1605 if next_offset >= end_offset {
1606 return Ok(());
1607 }
1608
1609 while _next_ordinal_to_read < 8 {
1611 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1612 _next_ordinal_to_read += 1;
1613 next_offset += envelope_size;
1614 }
1615
1616 let next_out_of_line = decoder.next_out_of_line();
1617 let handles_before = decoder.remaining_handles();
1618 if let Some((inlined, num_bytes, num_handles)) =
1619 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1620 {
1621 let member_inline_size = <fidl_fuchsia_fonts__common::GenericFontFamily as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1622 if inlined != (member_inline_size <= 4) {
1623 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1624 }
1625 let inner_offset;
1626 let mut inner_depth = depth.clone();
1627 if inlined {
1628 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1629 inner_offset = next_offset;
1630 } else {
1631 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1632 inner_depth.increment()?;
1633 }
1634 let val_ref = self.generic_family.get_or_insert_with(|| {
1635 fidl::new_empty!(fidl_fuchsia_fonts__common::GenericFontFamily, D)
1636 });
1637 fidl::decode!(
1638 fidl_fuchsia_fonts__common::GenericFontFamily,
1639 D,
1640 val_ref,
1641 decoder,
1642 inner_offset,
1643 inner_depth
1644 )?;
1645 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1646 {
1647 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1648 }
1649 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1650 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1651 }
1652 }
1653
1654 next_offset += envelope_size;
1655
1656 while next_offset < end_offset {
1658 _next_ordinal_to_read += 1;
1659 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1660 next_offset += envelope_size;
1661 }
1662
1663 Ok(())
1664 }
1665 }
1666
1667 impl TypefaceInfo {
1668 #[inline(always)]
1669 fn max_ordinal_present(&self) -> u64 {
1670 if let Some(_) = self.generic_family {
1671 return 6;
1672 }
1673 if let Some(_) = self.languages {
1674 return 5;
1675 }
1676 if let Some(_) = self.style {
1677 return 4;
1678 }
1679 if let Some(_) = self.family {
1680 return 3;
1681 }
1682 if let Some(_) = self.font_index {
1683 return 2;
1684 }
1685 if let Some(_) = self.asset_id {
1686 return 1;
1687 }
1688 0
1689 }
1690 }
1691
1692 impl fidl::encoding::ValueTypeMarker for TypefaceInfo {
1693 type Borrowed<'a> = &'a Self;
1694 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1695 value
1696 }
1697 }
1698
1699 unsafe impl fidl::encoding::TypeMarker for TypefaceInfo {
1700 type Owned = Self;
1701
1702 #[inline(always)]
1703 fn inline_align(_context: fidl::encoding::Context) -> usize {
1704 8
1705 }
1706
1707 #[inline(always)]
1708 fn inline_size(_context: fidl::encoding::Context) -> usize {
1709 16
1710 }
1711 }
1712
1713 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TypefaceInfo, D>
1714 for &TypefaceInfo
1715 {
1716 unsafe fn encode(
1717 self,
1718 encoder: &mut fidl::encoding::Encoder<'_, D>,
1719 offset: usize,
1720 mut depth: fidl::encoding::Depth,
1721 ) -> fidl::Result<()> {
1722 encoder.debug_check_bounds::<TypefaceInfo>(offset);
1723 let max_ordinal: u64 = self.max_ordinal_present();
1725 encoder.write_num(max_ordinal, offset);
1726 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1727 if max_ordinal == 0 {
1729 return Ok(());
1730 }
1731 depth.increment()?;
1732 let envelope_size = 8;
1733 let bytes_len = max_ordinal as usize * envelope_size;
1734 #[allow(unused_variables)]
1735 let offset = encoder.out_of_line_offset(bytes_len);
1736 let mut _prev_end_offset: usize = 0;
1737 if 1 > max_ordinal {
1738 return Ok(());
1739 }
1740
1741 let cur_offset: usize = (1 - 1) * envelope_size;
1744
1745 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1747
1748 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1753 self.asset_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1754 encoder,
1755 offset + cur_offset,
1756 depth,
1757 )?;
1758
1759 _prev_end_offset = cur_offset + envelope_size;
1760 if 2 > max_ordinal {
1761 return Ok(());
1762 }
1763
1764 let cur_offset: usize = (2 - 1) * envelope_size;
1767
1768 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1770
1771 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1776 self.font_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1777 encoder,
1778 offset + cur_offset,
1779 depth,
1780 )?;
1781
1782 _prev_end_offset = cur_offset + envelope_size;
1783 if 3 > max_ordinal {
1784 return Ok(());
1785 }
1786
1787 let cur_offset: usize = (3 - 1) * envelope_size;
1790
1791 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1793
1794 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_fonts__common::FamilyName, D>(
1799 self.family.as_ref().map(<fidl_fuchsia_fonts__common::FamilyName as fidl::encoding::ValueTypeMarker>::borrow),
1800 encoder, offset + cur_offset, depth
1801 )?;
1802
1803 _prev_end_offset = cur_offset + envelope_size;
1804 if 4 > max_ordinal {
1805 return Ok(());
1806 }
1807
1808 let cur_offset: usize = (4 - 1) * envelope_size;
1811
1812 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1814
1815 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_fonts__common::Style2, D>(
1820 self.style.as_ref().map(
1821 <fidl_fuchsia_fonts__common::Style2 as fidl::encoding::ValueTypeMarker>::borrow,
1822 ),
1823 encoder,
1824 offset + cur_offset,
1825 depth,
1826 )?;
1827
1828 _prev_end_offset = cur_offset + envelope_size;
1829 if 5 > max_ordinal {
1830 return Ok(());
1831 }
1832
1833 let cur_offset: usize = (5 - 1) * envelope_size;
1836
1837 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1839
1840 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>, D>(
1845 self.languages.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId> as fidl::encoding::ValueTypeMarker>::borrow),
1846 encoder, offset + cur_offset, depth
1847 )?;
1848
1849 _prev_end_offset = cur_offset + envelope_size;
1850 if 6 > max_ordinal {
1851 return Ok(());
1852 }
1853
1854 let cur_offset: usize = (6 - 1) * envelope_size;
1857
1858 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1860
1861 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_fonts__common::GenericFontFamily, D>(
1866 self.generic_family.as_ref().map(<fidl_fuchsia_fonts__common::GenericFontFamily as fidl::encoding::ValueTypeMarker>::borrow),
1867 encoder, offset + cur_offset, depth
1868 )?;
1869
1870 _prev_end_offset = cur_offset + envelope_size;
1871
1872 Ok(())
1873 }
1874 }
1875
1876 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TypefaceInfo {
1877 #[inline(always)]
1878 fn new_empty() -> Self {
1879 Self::default()
1880 }
1881
1882 unsafe fn decode(
1883 &mut self,
1884 decoder: &mut fidl::encoding::Decoder<'_, D>,
1885 offset: usize,
1886 mut depth: fidl::encoding::Depth,
1887 ) -> fidl::Result<()> {
1888 decoder.debug_check_bounds::<Self>(offset);
1889 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1890 None => return Err(fidl::Error::NotNullable),
1891 Some(len) => len,
1892 };
1893 if len == 0 {
1895 return Ok(());
1896 };
1897 depth.increment()?;
1898 let envelope_size = 8;
1899 let bytes_len = len * envelope_size;
1900 let offset = decoder.out_of_line_offset(bytes_len)?;
1901 let mut _next_ordinal_to_read = 0;
1903 let mut next_offset = offset;
1904 let end_offset = offset + bytes_len;
1905 _next_ordinal_to_read += 1;
1906 if next_offset >= end_offset {
1907 return Ok(());
1908 }
1909
1910 while _next_ordinal_to_read < 1 {
1912 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1913 _next_ordinal_to_read += 1;
1914 next_offset += envelope_size;
1915 }
1916
1917 let next_out_of_line = decoder.next_out_of_line();
1918 let handles_before = decoder.remaining_handles();
1919 if let Some((inlined, num_bytes, num_handles)) =
1920 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1921 {
1922 let member_inline_size =
1923 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1924 if inlined != (member_inline_size <= 4) {
1925 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1926 }
1927 let inner_offset;
1928 let mut inner_depth = depth.clone();
1929 if inlined {
1930 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1931 inner_offset = next_offset;
1932 } else {
1933 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1934 inner_depth.increment()?;
1935 }
1936 let val_ref = self.asset_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1937 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1938 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1939 {
1940 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1941 }
1942 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1943 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1944 }
1945 }
1946
1947 next_offset += envelope_size;
1948 _next_ordinal_to_read += 1;
1949 if next_offset >= end_offset {
1950 return Ok(());
1951 }
1952
1953 while _next_ordinal_to_read < 2 {
1955 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1956 _next_ordinal_to_read += 1;
1957 next_offset += envelope_size;
1958 }
1959
1960 let next_out_of_line = decoder.next_out_of_line();
1961 let handles_before = decoder.remaining_handles();
1962 if let Some((inlined, num_bytes, num_handles)) =
1963 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1964 {
1965 let member_inline_size =
1966 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1967 if inlined != (member_inline_size <= 4) {
1968 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1969 }
1970 let inner_offset;
1971 let mut inner_depth = depth.clone();
1972 if inlined {
1973 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1974 inner_offset = next_offset;
1975 } else {
1976 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1977 inner_depth.increment()?;
1978 }
1979 let val_ref = self.font_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
1980 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1981 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1982 {
1983 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1984 }
1985 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1986 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1987 }
1988 }
1989
1990 next_offset += envelope_size;
1991 _next_ordinal_to_read += 1;
1992 if next_offset >= end_offset {
1993 return Ok(());
1994 }
1995
1996 while _next_ordinal_to_read < 3 {
1998 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1999 _next_ordinal_to_read += 1;
2000 next_offset += envelope_size;
2001 }
2002
2003 let next_out_of_line = decoder.next_out_of_line();
2004 let handles_before = decoder.remaining_handles();
2005 if let Some((inlined, num_bytes, num_handles)) =
2006 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2007 {
2008 let member_inline_size = <fidl_fuchsia_fonts__common::FamilyName as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2009 if inlined != (member_inline_size <= 4) {
2010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2011 }
2012 let inner_offset;
2013 let mut inner_depth = depth.clone();
2014 if inlined {
2015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2016 inner_offset = next_offset;
2017 } else {
2018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2019 inner_depth.increment()?;
2020 }
2021 let val_ref = self.family.get_or_insert_with(|| {
2022 fidl::new_empty!(fidl_fuchsia_fonts__common::FamilyName, D)
2023 });
2024 fidl::decode!(
2025 fidl_fuchsia_fonts__common::FamilyName,
2026 D,
2027 val_ref,
2028 decoder,
2029 inner_offset,
2030 inner_depth
2031 )?;
2032 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2033 {
2034 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2035 }
2036 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2037 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2038 }
2039 }
2040
2041 next_offset += envelope_size;
2042 _next_ordinal_to_read += 1;
2043 if next_offset >= end_offset {
2044 return Ok(());
2045 }
2046
2047 while _next_ordinal_to_read < 4 {
2049 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2050 _next_ordinal_to_read += 1;
2051 next_offset += envelope_size;
2052 }
2053
2054 let next_out_of_line = decoder.next_out_of_line();
2055 let handles_before = decoder.remaining_handles();
2056 if let Some((inlined, num_bytes, num_handles)) =
2057 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2058 {
2059 let member_inline_size =
2060 <fidl_fuchsia_fonts__common::Style2 as fidl::encoding::TypeMarker>::inline_size(
2061 decoder.context,
2062 );
2063 if inlined != (member_inline_size <= 4) {
2064 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2065 }
2066 let inner_offset;
2067 let mut inner_depth = depth.clone();
2068 if inlined {
2069 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2070 inner_offset = next_offset;
2071 } else {
2072 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2073 inner_depth.increment()?;
2074 }
2075 let val_ref = self
2076 .style
2077 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_fonts__common::Style2, D));
2078 fidl::decode!(
2079 fidl_fuchsia_fonts__common::Style2,
2080 D,
2081 val_ref,
2082 decoder,
2083 inner_offset,
2084 inner_depth
2085 )?;
2086 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2087 {
2088 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2089 }
2090 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2091 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2092 }
2093 }
2094
2095 next_offset += envelope_size;
2096 _next_ordinal_to_read += 1;
2097 if next_offset >= end_offset {
2098 return Ok(());
2099 }
2100
2101 while _next_ordinal_to_read < 5 {
2103 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2104 _next_ordinal_to_read += 1;
2105 next_offset += envelope_size;
2106 }
2107
2108 let next_out_of_line = decoder.next_out_of_line();
2109 let handles_before = decoder.remaining_handles();
2110 if let Some((inlined, num_bytes, num_handles)) =
2111 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2112 {
2113 let member_inline_size = <fidl::encoding::UnboundedVector<
2114 fidl_fuchsia_intl__common::LocaleId,
2115 > as fidl::encoding::TypeMarker>::inline_size(
2116 decoder.context
2117 );
2118 if inlined != (member_inline_size <= 4) {
2119 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2120 }
2121 let inner_offset;
2122 let mut inner_depth = depth.clone();
2123 if inlined {
2124 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2125 inner_offset = next_offset;
2126 } else {
2127 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2128 inner_depth.increment()?;
2129 }
2130 let val_ref = self.languages.get_or_insert_with(|| {
2131 fidl::new_empty!(
2132 fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>,
2133 D
2134 )
2135 });
2136 fidl::decode!(
2137 fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>,
2138 D,
2139 val_ref,
2140 decoder,
2141 inner_offset,
2142 inner_depth
2143 )?;
2144 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2145 {
2146 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2147 }
2148 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2149 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2150 }
2151 }
2152
2153 next_offset += envelope_size;
2154 _next_ordinal_to_read += 1;
2155 if next_offset >= end_offset {
2156 return Ok(());
2157 }
2158
2159 while _next_ordinal_to_read < 6 {
2161 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2162 _next_ordinal_to_read += 1;
2163 next_offset += envelope_size;
2164 }
2165
2166 let next_out_of_line = decoder.next_out_of_line();
2167 let handles_before = decoder.remaining_handles();
2168 if let Some((inlined, num_bytes, num_handles)) =
2169 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2170 {
2171 let member_inline_size = <fidl_fuchsia_fonts__common::GenericFontFamily as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2172 if inlined != (member_inline_size <= 4) {
2173 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2174 }
2175 let inner_offset;
2176 let mut inner_depth = depth.clone();
2177 if inlined {
2178 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2179 inner_offset = next_offset;
2180 } else {
2181 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2182 inner_depth.increment()?;
2183 }
2184 let val_ref = self.generic_family.get_or_insert_with(|| {
2185 fidl::new_empty!(fidl_fuchsia_fonts__common::GenericFontFamily, D)
2186 });
2187 fidl::decode!(
2188 fidl_fuchsia_fonts__common::GenericFontFamily,
2189 D,
2190 val_ref,
2191 decoder,
2192 inner_offset,
2193 inner_depth
2194 )?;
2195 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2196 {
2197 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2198 }
2199 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2200 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2201 }
2202 }
2203
2204 next_offset += envelope_size;
2205
2206 while next_offset < end_offset {
2208 _next_ordinal_to_read += 1;
2209 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2210 next_offset += envelope_size;
2211 }
2212
2213 Ok(())
2214 }
2215 }
2216
2217 impl TypefaceInfoResponse {
2218 #[inline(always)]
2219 fn max_ordinal_present(&self) -> u64 {
2220 if let Some(_) = self.results {
2221 return 1;
2222 }
2223 0
2224 }
2225 }
2226
2227 impl fidl::encoding::ValueTypeMarker for TypefaceInfoResponse {
2228 type Borrowed<'a> = &'a Self;
2229 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2230 value
2231 }
2232 }
2233
2234 unsafe impl fidl::encoding::TypeMarker for TypefaceInfoResponse {
2235 type Owned = Self;
2236
2237 #[inline(always)]
2238 fn inline_align(_context: fidl::encoding::Context) -> usize {
2239 8
2240 }
2241
2242 #[inline(always)]
2243 fn inline_size(_context: fidl::encoding::Context) -> usize {
2244 16
2245 }
2246 }
2247
2248 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TypefaceInfoResponse, D>
2249 for &TypefaceInfoResponse
2250 {
2251 unsafe fn encode(
2252 self,
2253 encoder: &mut fidl::encoding::Encoder<'_, D>,
2254 offset: usize,
2255 mut depth: fidl::encoding::Depth,
2256 ) -> fidl::Result<()> {
2257 encoder.debug_check_bounds::<TypefaceInfoResponse>(offset);
2258 let max_ordinal: u64 = self.max_ordinal_present();
2260 encoder.write_num(max_ordinal, offset);
2261 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2262 if max_ordinal == 0 {
2264 return Ok(());
2265 }
2266 depth.increment()?;
2267 let envelope_size = 8;
2268 let bytes_len = max_ordinal as usize * envelope_size;
2269 #[allow(unused_variables)]
2270 let offset = encoder.out_of_line_offset(bytes_len);
2271 let mut _prev_end_offset: usize = 0;
2272 if 1 > max_ordinal {
2273 return Ok(());
2274 }
2275
2276 let cur_offset: usize = (1 - 1) * envelope_size;
2279
2280 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2282
2283 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<TypefaceInfo, 16>, D>(
2288 self.results.as_ref().map(<fidl::encoding::Vector<TypefaceInfo, 16> as fidl::encoding::ValueTypeMarker>::borrow),
2289 encoder, offset + cur_offset, depth
2290 )?;
2291
2292 _prev_end_offset = cur_offset + envelope_size;
2293
2294 Ok(())
2295 }
2296 }
2297
2298 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TypefaceInfoResponse {
2299 #[inline(always)]
2300 fn new_empty() -> Self {
2301 Self::default()
2302 }
2303
2304 unsafe fn decode(
2305 &mut self,
2306 decoder: &mut fidl::encoding::Decoder<'_, D>,
2307 offset: usize,
2308 mut depth: fidl::encoding::Depth,
2309 ) -> fidl::Result<()> {
2310 decoder.debug_check_bounds::<Self>(offset);
2311 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2312 None => return Err(fidl::Error::NotNullable),
2313 Some(len) => len,
2314 };
2315 if len == 0 {
2317 return Ok(());
2318 };
2319 depth.increment()?;
2320 let envelope_size = 8;
2321 let bytes_len = len * envelope_size;
2322 let offset = decoder.out_of_line_offset(bytes_len)?;
2323 let mut _next_ordinal_to_read = 0;
2325 let mut next_offset = offset;
2326 let end_offset = offset + bytes_len;
2327 _next_ordinal_to_read += 1;
2328 if next_offset >= end_offset {
2329 return Ok(());
2330 }
2331
2332 while _next_ordinal_to_read < 1 {
2334 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2335 _next_ordinal_to_read += 1;
2336 next_offset += envelope_size;
2337 }
2338
2339 let next_out_of_line = decoder.next_out_of_line();
2340 let handles_before = decoder.remaining_handles();
2341 if let Some((inlined, num_bytes, num_handles)) =
2342 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2343 {
2344 let member_inline_size = <fidl::encoding::Vector<TypefaceInfo, 16> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2345 if inlined != (member_inline_size <= 4) {
2346 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2347 }
2348 let inner_offset;
2349 let mut inner_depth = depth.clone();
2350 if inlined {
2351 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2352 inner_offset = next_offset;
2353 } else {
2354 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2355 inner_depth.increment()?;
2356 }
2357 let val_ref = self.results.get_or_insert_with(
2358 || fidl::new_empty!(fidl::encoding::Vector<TypefaceInfo, 16>, D),
2359 );
2360 fidl::decode!(fidl::encoding::Vector<TypefaceInfo, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
2361 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2362 {
2363 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2364 }
2365 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2366 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2367 }
2368 }
2369
2370 next_offset += envelope_size;
2371
2372 while next_offset < end_offset {
2374 _next_ordinal_to_read += 1;
2375 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2376 next_offset += envelope_size;
2377 }
2378
2379 Ok(())
2380 }
2381 }
2382}