fidl_fuchsia_fonts_experimental__common/
fidl_fuchsia_fonts_experimental__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// The maximum number of font families that can be returned in a
12/// `TypefaceInfoResponse`.
13pub 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        /// Match families whose name or alias exactly contains the requested
19        /// `FamilyName`. If not set, match families whose name or alias exactly
20        /// matches `FamilyName`.
21        ///
22        /// Note: Matching will always ignore case.
23        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/// Represents a range of acceptable `Slant`s. Both bounds are inclusive.
82#[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/// Represents a range of acceptable `Weight`s. Both bounds are inclusive.
91#[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/// Represents a range of acceptable `Width`s. Both bounds are inclusive.
101#[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/// Query parameters for `ListTypefaces`. Results must match all included
110/// fields. All fields are optional; omitted fields will match any font.
111#[derive(Clone, Debug, Default, PartialEq)]
112pub struct ListTypefacesRequest {
113    /// Optional flags to modify matching behavior. Ignored if no other fields
114    /// are set.
115    pub flags: Option<ListTypefacesFlags>,
116    /// The name or alias of a font family. By default, families whose name
117    /// exactly matches `family`. For substring matching, set the request's
118    /// `MATCH_FAMILY_NAME_SUBSTRING` flag.
119    pub family: Option<fidl_fuchsia_fonts__common::FamilyName>,
120    /// Results must have a slant within this inclusive range.
121    pub slant: Option<SlantRange>,
122    /// Results must have a weight within this inclusive range.
123    pub weight: Option<WeightRange>,
124    /// Results must have a width within this inclusive range.
125    pub width: Option<WidthRange>,
126    /// Languages that results must support.
127    /// Each result must support all requested languages.
128    pub languages: Option<Vec<fidl_fuchsia_intl__common::LocaleId>>,
129    /// Code points that results must include.
130    /// Each result must include all requested code points.
131    pub code_points: Option<Vec<u32>>,
132    /// Generic font family which results must belong to. If a font's generic
133    /// family is not set, it will only be matched if this field is also not
134    /// set. However, omitting this field will still cause it to match any font.
135    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/// Collection of typeface metadata that should be sufficient for clients to
143/// perform some kind of selection (likely via human) and request an exact font.
144#[derive(Clone, Debug, Default, PartialEq)]
145pub struct TypefaceInfo {
146    /// Identifier for the font asset. This ID is valid for the lifetime of the
147    /// font service. May be used in conjunction with `font_index` to directly
148    /// request this font.
149    pub asset_id: Option<u32>,
150    /// Index of the font within its parent asset. May be used in conjunction
151    /// with `asset_id` to directly request this font.
152    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            // Delegate to tuple encoding.
335            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            // Zero out padding regions. There's no need to apply masks
357            // because the unmasked parts will be overwritten by fields.
358            // Write the fields.
359            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            // Verify that padding bytes are zero.
381            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                // Copy the object into the buffer.
437                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
441                // done second because the memcpy will write garbage to these bytes.
442            }
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            // Zero out padding regions. There's no need to apply masks
458            // because the unmasked parts will be overwritten by fields.
459            // Write the fields.
460            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            // Verify that padding bytes are zero.
483            // Copy from the buffer into the object.
484            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            // Delegate to tuple encoding.
525            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            // Zero out padding regions. There's no need to apply masks
547            // because the unmasked parts will be overwritten by fields.
548            // Write the fields.
549            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            // Verify that padding bytes are zero.
571            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            // Delegate to tuple encoding.
617            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            // Zero out padding regions. There's no need to apply masks
639            // because the unmasked parts will be overwritten by fields.
640            // Write the fields.
641            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            // Verify that padding bytes are zero.
663            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            // Delegate to tuple encoding.
708            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            // Zero out padding regions. There's no need to apply masks
738            // because the unmasked parts will be overwritten by fields.
739            // Write the fields.
740            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            // Verify that padding bytes are zero.
764            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                // Copy the object into the buffer.
827                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
828                (buf_ptr as *mut WeightRange).write_unaligned((self as *const WeightRange).read());
829                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
830                // done second because the memcpy will write garbage to these bytes.
831            }
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            // Zero out padding regions. There's no need to apply masks
850            // because the unmasked parts will be overwritten by fields.
851            // Write the fields.
852            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            // Verify that padding bytes are zero.
874            // Copy from the buffer into the object.
875            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            // Delegate to tuple encoding.
915            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            // Zero out padding regions. There's no need to apply masks
945            // because the unmasked parts will be overwritten by fields.
946            // Write the fields.
947            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            // Verify that padding bytes are zero.
971            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            // Vector header
1054            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1058            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1072            // are envelope_size bytes.
1073            let cur_offset: usize = (1 - 1) * envelope_size;
1074
1075            // Zero reserved fields.
1076            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1077
1078            // Safety:
1079            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1080            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1081            //   envelope_size bytes, there is always sufficient room.
1082            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1097            // are envelope_size bytes.
1098            let cur_offset: usize = (2 - 1) * envelope_size;
1099
1100            // Zero reserved fields.
1101            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1102
1103            // Safety:
1104            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1105            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1106            //   envelope_size bytes, there is always sufficient room.
1107            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1118            // are envelope_size bytes.
1119            let cur_offset: usize = (3 - 1) * envelope_size;
1120
1121            // Zero reserved fields.
1122            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1123
1124            // Safety:
1125            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1126            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1127            //   envelope_size bytes, there is always sufficient room.
1128            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1141            // are envelope_size bytes.
1142            let cur_offset: usize = (4 - 1) * envelope_size;
1143
1144            // Zero reserved fields.
1145            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1146
1147            // Safety:
1148            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1149            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1150            //   envelope_size bytes, there is always sufficient room.
1151            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1164            // are envelope_size bytes.
1165            let cur_offset: usize = (5 - 1) * envelope_size;
1166
1167            // Zero reserved fields.
1168            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1169
1170            // Safety:
1171            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1172            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1173            //   envelope_size bytes, there is always sufficient room.
1174            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1187            // are envelope_size bytes.
1188            let cur_offset: usize = (6 - 1) * envelope_size;
1189
1190            // Zero reserved fields.
1191            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1192
1193            // Safety:
1194            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1195            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1196            //   envelope_size bytes, there is always sufficient room.
1197            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1208            // are envelope_size bytes.
1209            let cur_offset: usize = (7 - 1) * envelope_size;
1210
1211            // Zero reserved fields.
1212            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1213
1214            // Safety:
1215            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1216            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1217            //   envelope_size bytes, there is always sufficient room.
1218            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1229            // are envelope_size bytes.
1230            let cur_offset: usize = (8 - 1) * envelope_size;
1231
1232            // Zero reserved fields.
1233            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1234
1235            // Safety:
1236            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1237            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1238            //   envelope_size bytes, there is always sufficient room.
1239            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1268            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            // Decode the envelope for each type.
1276            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            // Decode unknown envelopes for gaps in ordinals.
1285            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            // Decode unknown envelopes for gaps in ordinals.
1331            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            // Decode unknown envelopes for gaps in ordinals.
1382            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            // Decode unknown envelopes for gaps in ordinals.
1425            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            // Decode unknown envelopes for gaps in ordinals.
1468            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            // Decode unknown envelopes for gaps in ordinals.
1511            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            // Decode unknown envelopes for gaps in ordinals.
1559            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            // Decode unknown envelopes for gaps in ordinals.
1610            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            // Decode the remaining unknown envelopes.
1657            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            // Vector header
1724            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1728            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1742            // are envelope_size bytes.
1743            let cur_offset: usize = (1 - 1) * envelope_size;
1744
1745            // Zero reserved fields.
1746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1747
1748            // Safety:
1749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1751            //   envelope_size bytes, there is always sufficient room.
1752            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1765            // are envelope_size bytes.
1766            let cur_offset: usize = (2 - 1) * envelope_size;
1767
1768            // Zero reserved fields.
1769            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1770
1771            // Safety:
1772            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1773            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1774            //   envelope_size bytes, there is always sufficient room.
1775            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1788            // are envelope_size bytes.
1789            let cur_offset: usize = (3 - 1) * envelope_size;
1790
1791            // Zero reserved fields.
1792            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1793
1794            // Safety:
1795            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1796            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1797            //   envelope_size bytes, there is always sufficient room.
1798            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1809            // are envelope_size bytes.
1810            let cur_offset: usize = (4 - 1) * envelope_size;
1811
1812            // Zero reserved fields.
1813            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1814
1815            // Safety:
1816            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1817            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1818            //   envelope_size bytes, there is always sufficient room.
1819            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1834            // are envelope_size bytes.
1835            let cur_offset: usize = (5 - 1) * envelope_size;
1836
1837            // Zero reserved fields.
1838            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1839
1840            // Safety:
1841            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1842            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1843            //   envelope_size bytes, there is always sufficient room.
1844            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1855            // are envelope_size bytes.
1856            let cur_offset: usize = (6 - 1) * envelope_size;
1857
1858            // Zero reserved fields.
1859            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1860
1861            // Safety:
1862            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1863            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1864            //   envelope_size bytes, there is always sufficient room.
1865            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1894            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            // Decode the envelope for each type.
1902            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            // Decode unknown envelopes for gaps in ordinals.
1911            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            // Decode unknown envelopes for gaps in ordinals.
1954            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            // Decode unknown envelopes for gaps in ordinals.
1997            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            // Decode unknown envelopes for gaps in ordinals.
2048            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            // Decode unknown envelopes for gaps in ordinals.
2102            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            // Decode unknown envelopes for gaps in ordinals.
2160            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            // Decode the remaining unknown envelopes.
2207            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            // Vector header
2259            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            // Calling encoder.out_of_line_offset(0) is not allowed.
2263            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2277            // are envelope_size bytes.
2278            let cur_offset: usize = (1 - 1) * envelope_size;
2279
2280            // Zero reserved fields.
2281            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2282
2283            // Safety:
2284            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2285            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2286            //   envelope_size bytes, there is always sufficient room.
2287            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2316            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            // Decode the envelope for each type.
2324            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            // Decode unknown envelopes for gaps in ordinals.
2333            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            // Decode the remaining unknown envelopes.
2373            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}