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