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