1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const MAX_RESOLUTION_CONTEXT_SIZE: u32 = 8192;
18
19#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum BlobWrittenError {
23 NotWritten = 1,
25 UnopenedBlob = 2,
27}
28
29impl BlobWrittenError {
30 #[inline]
31 pub fn from_primitive(prim: u32) -> Option<Self> {
32 match prim {
33 1 => Some(Self::NotWritten),
34 2 => Some(Self::UnopenedBlob),
35 _ => None,
36 }
37 }
38
39 #[inline]
40 pub const fn into_primitive(self) -> u32 {
41 self as u32
42 }
43}
44
45#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
47#[repr(u32)]
48pub enum GcProtection {
49 OpenPackageTracking = 1,
51 Retained = 2,
55}
56
57impl GcProtection {
58 #[inline]
59 pub fn from_primitive(prim: u32) -> Option<Self> {
60 match prim {
61 1 => Some(Self::OpenPackageTracking),
62 2 => Some(Self::Retained),
63 _ => None,
64 }
65 }
66
67 #[inline]
68 pub const fn into_primitive(self) -> u32 {
69 self as u32
70 }
71}
72
73#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
74#[repr(u32)]
75pub enum GetInfoError {
76 UnknownUrl = 1,
78 Verification = 2,
80 NotAvailable = 3,
82}
83
84impl GetInfoError {
85 #[inline]
86 pub fn from_primitive(prim: u32) -> Option<Self> {
87 match prim {
88 1 => Some(Self::UnknownUrl),
89 2 => Some(Self::Verification),
90 3 => Some(Self::NotAvailable),
91 _ => None,
92 }
93 }
94
95 #[inline]
96 pub const fn into_primitive(self) -> u32 {
97 self as u32
98 }
99}
100
101#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
103#[repr(u32)]
104pub enum GetSubpackageError {
105 SuperpackageClosed = 1,
107 DoesNotExist = 2,
109 Internal = 3,
111}
112
113impl GetSubpackageError {
114 #[inline]
115 pub fn from_primitive(prim: u32) -> Option<Self> {
116 match prim {
117 1 => Some(Self::SuperpackageClosed),
118 2 => Some(Self::DoesNotExist),
119 3 => Some(Self::Internal),
120 _ => None,
121 }
122 }
123
124 #[inline]
125 pub const fn into_primitive(self) -> u32 {
126 self as u32
127 }
128}
129
130#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
132#[repr(u32)]
133pub enum OpenBlobError {
134 OutOfSpace = 1,
136 ConcurrentWrite = 2,
138 UnspecifiedIo = 3,
140 Internal = 4,
142}
143
144impl OpenBlobError {
145 #[inline]
146 pub fn from_primitive(prim: u32) -> Option<Self> {
147 match prim {
148 1 => Some(Self::OutOfSpace),
149 2 => Some(Self::ConcurrentWrite),
150 3 => Some(Self::UnspecifiedIo),
151 4 => Some(Self::Internal),
152 _ => None,
153 }
154 }
155
156 #[inline]
157 pub const fn into_primitive(self) -> u32 {
158 self as u32
159 }
160}
161
162#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
164#[repr(u32)]
165pub enum RepositoryStorageType {
166 Ephemeral = 1,
169 Persistent = 2,
172}
173
174impl RepositoryStorageType {
175 #[inline]
176 pub fn from_primitive(prim: u32) -> Option<Self> {
177 match prim {
178 1 => Some(Self::Ephemeral),
179 2 => Some(Self::Persistent),
180 _ => None,
181 }
182 }
183
184 #[inline]
185 pub const fn into_primitive(self) -> u32 {
186 self as u32
187 }
188}
189
190#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
192#[repr(i32)]
193pub enum ResolveError {
194 Internal = 1,
196 AccessDenied = 2,
198 Io = 3,
200 BlobNotFound = 4,
202 PackageNotFound = 5,
204 RepoNotFound = 6,
206 NoSpace = 7,
208 UnavailableBlob = 8,
210 UnavailableRepoMetadata = 9,
212 InvalidUrl = 10,
214 InvalidContext = 11,
216}
217
218impl ResolveError {
219 #[inline]
220 pub fn from_primitive(prim: i32) -> Option<Self> {
221 match prim {
222 1 => Some(Self::Internal),
223 2 => Some(Self::AccessDenied),
224 3 => Some(Self::Io),
225 4 => Some(Self::BlobNotFound),
226 5 => Some(Self::PackageNotFound),
227 6 => Some(Self::RepoNotFound),
228 7 => Some(Self::NoSpace),
229 8 => Some(Self::UnavailableBlob),
230 9 => Some(Self::UnavailableRepoMetadata),
231 10 => Some(Self::InvalidUrl),
232 11 => Some(Self::InvalidContext),
233 _ => None,
234 }
235 }
236
237 #[inline]
238 pub const fn into_primitive(self) -> i32 {
239 self as i32
240 }
241}
242
243#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
245pub enum SetUpgradableUrlsError {
246 PartialSet,
251 Internal,
253 #[doc(hidden)]
254 __SourceBreaking { unknown_ordinal: u32 },
255}
256
257#[macro_export]
259macro_rules! SetUpgradableUrlsErrorUnknown {
260 () => {
261 _
262 };
263}
264
265impl SetUpgradableUrlsError {
266 #[inline]
267 pub fn from_primitive(prim: u32) -> Option<Self> {
268 match prim {
269 1 => Some(Self::PartialSet),
270 2 => Some(Self::Internal),
271 _ => None,
272 }
273 }
274
275 #[inline]
276 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
277 match prim {
278 1 => Self::PartialSet,
279 2 => Self::Internal,
280 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
281 }
282 }
283
284 #[inline]
285 pub fn unknown() -> Self {
286 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
287 }
288
289 #[inline]
290 pub const fn into_primitive(self) -> u32 {
291 match self {
292 Self::PartialSet => 1,
293 Self::Internal => 2,
294 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
295 }
296 }
297
298 #[inline]
299 pub fn is_unknown(&self) -> bool {
300 match self {
301 Self::__SourceBreaking { unknown_ordinal: _ } => true,
302 _ => false,
303 }
304 }
305}
306
307#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
308#[repr(u32)]
309pub enum WriteError {
310 UnknownUrl = 1,
312 Verification = 2,
314 Download = 3,
316 Storage = 4,
318}
319
320impl WriteError {
321 #[inline]
322 pub fn from_primitive(prim: u32) -> Option<Self> {
323 match prim {
324 1 => Some(Self::UnknownUrl),
325 2 => Some(Self::Verification),
326 3 => Some(Self::Download),
327 4 => Some(Self::Storage),
328 _ => None,
329 }
330 }
331
332 #[inline]
333 pub const fn into_primitive(self) -> u32 {
334 self as u32
335 }
336}
337
338#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
341#[repr(C)]
342pub struct BlobId {
343 pub merkle_root: [u8; 32],
344}
345
346impl fidl::Persistable for BlobId {}
347
348#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
349pub struct BlobIdIteratorNextResponse {
350 pub blobs: Vec<BlobId>,
351}
352
353impl fidl::Persistable for BlobIdIteratorNextResponse {}
354
355#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
358#[repr(C)]
359pub struct BlobInfo {
360 pub blob_id: BlobId,
361 pub length: u64,
362}
363
364impl fidl::Persistable for BlobInfo {}
365
366#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
367pub struct BlobInfoIteratorNextResponse {
368 pub blobs: Vec<BlobInfo>,
369}
370
371impl fidl::Persistable for BlobInfoIteratorNextResponse {}
372
373#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
374pub struct CupGetInfoRequest {
375 pub url: PackageUrl,
377}
378
379impl fidl::Persistable for CupGetInfoRequest {}
380
381#[derive(Clone, Debug, PartialEq)]
382pub struct CupWriteRequest {
383 pub url: PackageUrl,
385 pub cup: CupData,
387}
388
389impl fidl::Persistable for CupWriteRequest {}
390
391#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
392pub struct CupGetInfoResponse {
393 pub version: String,
394 pub channel: String,
395}
396
397impl fidl::Persistable for CupGetInfoResponse {}
398
399#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
400#[repr(C)]
401pub struct NeededBlobsBlobWrittenRequest {
402 pub blob_id: BlobId,
403}
404
405impl fidl::Persistable for NeededBlobsBlobWrittenRequest {}
406
407#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
408#[repr(C)]
409pub struct NeededBlobsOpenBlobRequest {
410 pub blob_id: BlobId,
411}
412
413impl fidl::Persistable for NeededBlobsOpenBlobRequest {}
414
415#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
416pub struct PackageCacheSetUpgradableUrlsRequest {
417 pub pinned_urls: Vec<PackageUrl>,
418}
419
420impl fidl::Persistable for PackageCacheSetUpgradableUrlsRequest {}
421
422#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
424pub struct PackageIndexEntry {
425 pub package_url: PackageUrl,
426 pub meta_far_blob_id: BlobId,
427}
428
429impl fidl::Persistable for PackageIndexEntry {}
430
431#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
432pub struct PackageIndexIteratorNextResponse {
433 pub entries: Vec<PackageIndexEntry>,
434}
435
436impl fidl::Persistable for PackageIndexIteratorNextResponse {}
437
438#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
439pub struct PackageResolverGetHashRequest {
440 pub package_url: PackageUrl,
441}
442
443impl fidl::Persistable for PackageResolverGetHashRequest {}
444
445#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
446#[repr(C)]
447pub struct PackageResolverGetHashResponse {
448 pub meta_far_blob_id: BlobId,
449}
450
451impl fidl::Persistable for PackageResolverGetHashResponse {}
452
453#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
454pub struct PackageResolverResolveWithContextResponse {
455 pub resolved_context: ResolutionContext,
456}
457
458impl fidl::Persistable for PackageResolverResolveWithContextResponse {}
459
460#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
461pub struct PackageResolverResolveResponse {
462 pub resolved_context: ResolutionContext,
463}
464
465impl fidl::Persistable for PackageResolverResolveResponse {}
466
467#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
470pub struct PackageUrl {
471 pub url: String,
472}
473
474impl fidl::Persistable for PackageUrl {}
475
476#[derive(Clone, Debug, PartialEq)]
477pub struct RepositoryIteratorNextResponse {
478 pub repos: Vec<RepositoryConfig>,
479}
480
481impl fidl::Persistable for RepositoryIteratorNextResponse {}
482
483#[derive(Clone, Debug, PartialEq)]
484pub struct RepositoryManagerAddMirrorRequest {
485 pub repo_url: String,
486 pub mirror: MirrorConfig,
487}
488
489impl fidl::Persistable for RepositoryManagerAddMirrorRequest {}
490
491#[derive(Clone, Debug, PartialEq)]
492pub struct RepositoryManagerAddRequest {
493 pub repo: RepositoryConfig,
494}
495
496impl fidl::Persistable for RepositoryManagerAddRequest {}
497
498#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
499pub struct RepositoryManagerRemoveMirrorRequest {
500 pub repo_url: String,
501 pub mirror_url: String,
502}
503
504impl fidl::Persistable for RepositoryManagerRemoveMirrorRequest {}
505
506#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
507pub struct RepositoryManagerRemoveRequest {
508 pub repo_url: String,
509}
510
511impl fidl::Persistable for RepositoryManagerRemoveRequest {}
512
513#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
516pub struct RepositoryUrl {
517 pub url: String,
518}
519
520impl fidl::Persistable for RepositoryUrl {}
521
522#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
525pub struct ResolutionContext {
526 pub bytes: Vec<u8>,
527}
528
529impl fidl::Persistable for ResolutionContext {}
530
531#[derive(Clone, Debug, Default, PartialEq)]
532pub struct CupData {
533 pub request: Option<Vec<u8>>,
535 pub key_id: Option<u64>,
537 pub nonce: Option<[u8; 32]>,
539 pub response: Option<Vec<u8>>,
541 pub signature: Option<Vec<u8>>,
543 #[doc(hidden)]
544 pub __source_breaking: fidl::marker::SourceBreaking,
545}
546
547impl fidl::Persistable for CupData {}
548
549#[derive(Clone, Debug, Default, PartialEq)]
551pub struct MirrorConfig {
552 pub mirror_url: Option<String>,
554 pub subscribe: Option<bool>,
556 pub blob_mirror_url: Option<String>,
559 #[doc(hidden)]
560 pub __source_breaking: fidl::marker::SourceBreaking,
561}
562
563impl fidl::Persistable for MirrorConfig {}
564
565#[derive(Clone, Debug, Default, PartialEq)]
567pub struct RepositoryConfig {
568 pub repo_url: Option<String>,
572 pub root_keys: Option<Vec<RepositoryKeyConfig>>,
577 pub mirrors: Option<Vec<MirrorConfig>>,
579 pub root_version: Option<u32>,
592 pub root_threshold: Option<u32>,
596 pub use_local_mirror: Option<bool>,
599 pub storage_type: Option<RepositoryStorageType>,
602 #[doc(hidden)]
603 pub __source_breaking: fidl::marker::SourceBreaking,
604}
605
606impl fidl::Persistable for RepositoryConfig {}
607
608#[derive(Clone, Debug)]
612pub enum RepositoryKeyConfig {
613 Ed25519Key(Vec<u8>),
615 #[doc(hidden)]
616 __SourceBreaking { unknown_ordinal: u64 },
617}
618
619#[macro_export]
621macro_rules! RepositoryKeyConfigUnknown {
622 () => {
623 _
624 };
625}
626
627impl PartialEq for RepositoryKeyConfig {
629 fn eq(&self, other: &Self) -> bool {
630 match (self, other) {
631 (Self::Ed25519Key(x), Self::Ed25519Key(y)) => *x == *y,
632 _ => false,
633 }
634 }
635}
636
637impl RepositoryKeyConfig {
638 #[inline]
639 pub fn ordinal(&self) -> u64 {
640 match *self {
641 Self::Ed25519Key(_) => 1,
642 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
643 }
644 }
645
646 #[inline]
647 pub fn unknown_variant_for_testing() -> Self {
648 Self::__SourceBreaking { unknown_ordinal: 0 }
649 }
650
651 #[inline]
652 pub fn is_unknown(&self) -> bool {
653 match self {
654 Self::__SourceBreaking { .. } => true,
655 _ => false,
656 }
657 }
658}
659
660impl fidl::Persistable for RepositoryKeyConfig {}
661
662mod internal {
663 use super::*;
664 unsafe impl fidl::encoding::TypeMarker for BlobWrittenError {
665 type Owned = Self;
666
667 #[inline(always)]
668 fn inline_align(_context: fidl::encoding::Context) -> usize {
669 std::mem::align_of::<u32>()
670 }
671
672 #[inline(always)]
673 fn inline_size(_context: fidl::encoding::Context) -> usize {
674 std::mem::size_of::<u32>()
675 }
676
677 #[inline(always)]
678 fn encode_is_copy() -> bool {
679 true
680 }
681
682 #[inline(always)]
683 fn decode_is_copy() -> bool {
684 false
685 }
686 }
687
688 impl fidl::encoding::ValueTypeMarker for BlobWrittenError {
689 type Borrowed<'a> = Self;
690 #[inline(always)]
691 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
692 *value
693 }
694 }
695
696 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
697 for BlobWrittenError
698 {
699 #[inline]
700 unsafe fn encode(
701 self,
702 encoder: &mut fidl::encoding::Encoder<'_, D>,
703 offset: usize,
704 _depth: fidl::encoding::Depth,
705 ) -> fidl::Result<()> {
706 encoder.debug_check_bounds::<Self>(offset);
707 encoder.write_num(self.into_primitive(), offset);
708 Ok(())
709 }
710 }
711
712 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlobWrittenError {
713 #[inline(always)]
714 fn new_empty() -> Self {
715 Self::NotWritten
716 }
717
718 #[inline]
719 unsafe fn decode(
720 &mut self,
721 decoder: &mut fidl::encoding::Decoder<'_, D>,
722 offset: usize,
723 _depth: fidl::encoding::Depth,
724 ) -> fidl::Result<()> {
725 decoder.debug_check_bounds::<Self>(offset);
726 let prim = decoder.read_num::<u32>(offset);
727
728 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
729 Ok(())
730 }
731 }
732 unsafe impl fidl::encoding::TypeMarker for GcProtection {
733 type Owned = Self;
734
735 #[inline(always)]
736 fn inline_align(_context: fidl::encoding::Context) -> usize {
737 std::mem::align_of::<u32>()
738 }
739
740 #[inline(always)]
741 fn inline_size(_context: fidl::encoding::Context) -> usize {
742 std::mem::size_of::<u32>()
743 }
744
745 #[inline(always)]
746 fn encode_is_copy() -> bool {
747 true
748 }
749
750 #[inline(always)]
751 fn decode_is_copy() -> bool {
752 false
753 }
754 }
755
756 impl fidl::encoding::ValueTypeMarker for GcProtection {
757 type Borrowed<'a> = Self;
758 #[inline(always)]
759 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
760 *value
761 }
762 }
763
764 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GcProtection {
765 #[inline]
766 unsafe fn encode(
767 self,
768 encoder: &mut fidl::encoding::Encoder<'_, D>,
769 offset: usize,
770 _depth: fidl::encoding::Depth,
771 ) -> fidl::Result<()> {
772 encoder.debug_check_bounds::<Self>(offset);
773 encoder.write_num(self.into_primitive(), offset);
774 Ok(())
775 }
776 }
777
778 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GcProtection {
779 #[inline(always)]
780 fn new_empty() -> Self {
781 Self::OpenPackageTracking
782 }
783
784 #[inline]
785 unsafe fn decode(
786 &mut self,
787 decoder: &mut fidl::encoding::Decoder<'_, D>,
788 offset: usize,
789 _depth: fidl::encoding::Depth,
790 ) -> fidl::Result<()> {
791 decoder.debug_check_bounds::<Self>(offset);
792 let prim = decoder.read_num::<u32>(offset);
793
794 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
795 Ok(())
796 }
797 }
798 unsafe impl fidl::encoding::TypeMarker for GetInfoError {
799 type Owned = Self;
800
801 #[inline(always)]
802 fn inline_align(_context: fidl::encoding::Context) -> usize {
803 std::mem::align_of::<u32>()
804 }
805
806 #[inline(always)]
807 fn inline_size(_context: fidl::encoding::Context) -> usize {
808 std::mem::size_of::<u32>()
809 }
810
811 #[inline(always)]
812 fn encode_is_copy() -> bool {
813 true
814 }
815
816 #[inline(always)]
817 fn decode_is_copy() -> bool {
818 false
819 }
820 }
821
822 impl fidl::encoding::ValueTypeMarker for GetInfoError {
823 type Borrowed<'a> = Self;
824 #[inline(always)]
825 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
826 *value
827 }
828 }
829
830 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GetInfoError {
831 #[inline]
832 unsafe fn encode(
833 self,
834 encoder: &mut fidl::encoding::Encoder<'_, D>,
835 offset: usize,
836 _depth: fidl::encoding::Depth,
837 ) -> fidl::Result<()> {
838 encoder.debug_check_bounds::<Self>(offset);
839 encoder.write_num(self.into_primitive(), offset);
840 Ok(())
841 }
842 }
843
844 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetInfoError {
845 #[inline(always)]
846 fn new_empty() -> Self {
847 Self::UnknownUrl
848 }
849
850 #[inline]
851 unsafe fn decode(
852 &mut self,
853 decoder: &mut fidl::encoding::Decoder<'_, D>,
854 offset: usize,
855 _depth: fidl::encoding::Depth,
856 ) -> fidl::Result<()> {
857 decoder.debug_check_bounds::<Self>(offset);
858 let prim = decoder.read_num::<u32>(offset);
859
860 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
861 Ok(())
862 }
863 }
864 unsafe impl fidl::encoding::TypeMarker for GetSubpackageError {
865 type Owned = Self;
866
867 #[inline(always)]
868 fn inline_align(_context: fidl::encoding::Context) -> usize {
869 std::mem::align_of::<u32>()
870 }
871
872 #[inline(always)]
873 fn inline_size(_context: fidl::encoding::Context) -> usize {
874 std::mem::size_of::<u32>()
875 }
876
877 #[inline(always)]
878 fn encode_is_copy() -> bool {
879 true
880 }
881
882 #[inline(always)]
883 fn decode_is_copy() -> bool {
884 false
885 }
886 }
887
888 impl fidl::encoding::ValueTypeMarker for GetSubpackageError {
889 type Borrowed<'a> = Self;
890 #[inline(always)]
891 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
892 *value
893 }
894 }
895
896 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
897 for GetSubpackageError
898 {
899 #[inline]
900 unsafe fn encode(
901 self,
902 encoder: &mut fidl::encoding::Encoder<'_, D>,
903 offset: usize,
904 _depth: fidl::encoding::Depth,
905 ) -> fidl::Result<()> {
906 encoder.debug_check_bounds::<Self>(offset);
907 encoder.write_num(self.into_primitive(), offset);
908 Ok(())
909 }
910 }
911
912 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetSubpackageError {
913 #[inline(always)]
914 fn new_empty() -> Self {
915 Self::SuperpackageClosed
916 }
917
918 #[inline]
919 unsafe fn decode(
920 &mut self,
921 decoder: &mut fidl::encoding::Decoder<'_, D>,
922 offset: usize,
923 _depth: fidl::encoding::Depth,
924 ) -> fidl::Result<()> {
925 decoder.debug_check_bounds::<Self>(offset);
926 let prim = decoder.read_num::<u32>(offset);
927
928 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
929 Ok(())
930 }
931 }
932 unsafe impl fidl::encoding::TypeMarker for OpenBlobError {
933 type Owned = Self;
934
935 #[inline(always)]
936 fn inline_align(_context: fidl::encoding::Context) -> usize {
937 std::mem::align_of::<u32>()
938 }
939
940 #[inline(always)]
941 fn inline_size(_context: fidl::encoding::Context) -> usize {
942 std::mem::size_of::<u32>()
943 }
944
945 #[inline(always)]
946 fn encode_is_copy() -> bool {
947 true
948 }
949
950 #[inline(always)]
951 fn decode_is_copy() -> bool {
952 false
953 }
954 }
955
956 impl fidl::encoding::ValueTypeMarker for OpenBlobError {
957 type Borrowed<'a> = Self;
958 #[inline(always)]
959 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
960 *value
961 }
962 }
963
964 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenBlobError {
965 #[inline]
966 unsafe fn encode(
967 self,
968 encoder: &mut fidl::encoding::Encoder<'_, D>,
969 offset: usize,
970 _depth: fidl::encoding::Depth,
971 ) -> fidl::Result<()> {
972 encoder.debug_check_bounds::<Self>(offset);
973 encoder.write_num(self.into_primitive(), offset);
974 Ok(())
975 }
976 }
977
978 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenBlobError {
979 #[inline(always)]
980 fn new_empty() -> Self {
981 Self::OutOfSpace
982 }
983
984 #[inline]
985 unsafe fn decode(
986 &mut self,
987 decoder: &mut fidl::encoding::Decoder<'_, D>,
988 offset: usize,
989 _depth: fidl::encoding::Depth,
990 ) -> fidl::Result<()> {
991 decoder.debug_check_bounds::<Self>(offset);
992 let prim = decoder.read_num::<u32>(offset);
993
994 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
995 Ok(())
996 }
997 }
998 unsafe impl fidl::encoding::TypeMarker for RepositoryStorageType {
999 type Owned = Self;
1000
1001 #[inline(always)]
1002 fn inline_align(_context: fidl::encoding::Context) -> usize {
1003 std::mem::align_of::<u32>()
1004 }
1005
1006 #[inline(always)]
1007 fn inline_size(_context: fidl::encoding::Context) -> usize {
1008 std::mem::size_of::<u32>()
1009 }
1010
1011 #[inline(always)]
1012 fn encode_is_copy() -> bool {
1013 true
1014 }
1015
1016 #[inline(always)]
1017 fn decode_is_copy() -> bool {
1018 false
1019 }
1020 }
1021
1022 impl fidl::encoding::ValueTypeMarker for RepositoryStorageType {
1023 type Borrowed<'a> = Self;
1024 #[inline(always)]
1025 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1026 *value
1027 }
1028 }
1029
1030 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1031 for RepositoryStorageType
1032 {
1033 #[inline]
1034 unsafe fn encode(
1035 self,
1036 encoder: &mut fidl::encoding::Encoder<'_, D>,
1037 offset: usize,
1038 _depth: fidl::encoding::Depth,
1039 ) -> fidl::Result<()> {
1040 encoder.debug_check_bounds::<Self>(offset);
1041 encoder.write_num(self.into_primitive(), offset);
1042 Ok(())
1043 }
1044 }
1045
1046 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryStorageType {
1047 #[inline(always)]
1048 fn new_empty() -> Self {
1049 Self::Ephemeral
1050 }
1051
1052 #[inline]
1053 unsafe fn decode(
1054 &mut self,
1055 decoder: &mut fidl::encoding::Decoder<'_, D>,
1056 offset: usize,
1057 _depth: fidl::encoding::Depth,
1058 ) -> fidl::Result<()> {
1059 decoder.debug_check_bounds::<Self>(offset);
1060 let prim = decoder.read_num::<u32>(offset);
1061
1062 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1063 Ok(())
1064 }
1065 }
1066 unsafe impl fidl::encoding::TypeMarker for ResolveError {
1067 type Owned = Self;
1068
1069 #[inline(always)]
1070 fn inline_align(_context: fidl::encoding::Context) -> usize {
1071 std::mem::align_of::<i32>()
1072 }
1073
1074 #[inline(always)]
1075 fn inline_size(_context: fidl::encoding::Context) -> usize {
1076 std::mem::size_of::<i32>()
1077 }
1078
1079 #[inline(always)]
1080 fn encode_is_copy() -> bool {
1081 true
1082 }
1083
1084 #[inline(always)]
1085 fn decode_is_copy() -> bool {
1086 false
1087 }
1088 }
1089
1090 impl fidl::encoding::ValueTypeMarker for ResolveError {
1091 type Borrowed<'a> = Self;
1092 #[inline(always)]
1093 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1094 *value
1095 }
1096 }
1097
1098 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResolveError {
1099 #[inline]
1100 unsafe fn encode(
1101 self,
1102 encoder: &mut fidl::encoding::Encoder<'_, D>,
1103 offset: usize,
1104 _depth: fidl::encoding::Depth,
1105 ) -> fidl::Result<()> {
1106 encoder.debug_check_bounds::<Self>(offset);
1107 encoder.write_num(self.into_primitive(), offset);
1108 Ok(())
1109 }
1110 }
1111
1112 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolveError {
1113 #[inline(always)]
1114 fn new_empty() -> Self {
1115 Self::Internal
1116 }
1117
1118 #[inline]
1119 unsafe fn decode(
1120 &mut self,
1121 decoder: &mut fidl::encoding::Decoder<'_, D>,
1122 offset: usize,
1123 _depth: fidl::encoding::Depth,
1124 ) -> fidl::Result<()> {
1125 decoder.debug_check_bounds::<Self>(offset);
1126 let prim = decoder.read_num::<i32>(offset);
1127
1128 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1129 Ok(())
1130 }
1131 }
1132 unsafe impl fidl::encoding::TypeMarker for SetUpgradableUrlsError {
1133 type Owned = Self;
1134
1135 #[inline(always)]
1136 fn inline_align(_context: fidl::encoding::Context) -> usize {
1137 std::mem::align_of::<u32>()
1138 }
1139
1140 #[inline(always)]
1141 fn inline_size(_context: fidl::encoding::Context) -> usize {
1142 std::mem::size_of::<u32>()
1143 }
1144
1145 #[inline(always)]
1146 fn encode_is_copy() -> bool {
1147 false
1148 }
1149
1150 #[inline(always)]
1151 fn decode_is_copy() -> bool {
1152 false
1153 }
1154 }
1155
1156 impl fidl::encoding::ValueTypeMarker for SetUpgradableUrlsError {
1157 type Borrowed<'a> = Self;
1158 #[inline(always)]
1159 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1160 *value
1161 }
1162 }
1163
1164 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1165 for SetUpgradableUrlsError
1166 {
1167 #[inline]
1168 unsafe fn encode(
1169 self,
1170 encoder: &mut fidl::encoding::Encoder<'_, D>,
1171 offset: usize,
1172 _depth: fidl::encoding::Depth,
1173 ) -> fidl::Result<()> {
1174 encoder.debug_check_bounds::<Self>(offset);
1175 encoder.write_num(self.into_primitive(), offset);
1176 Ok(())
1177 }
1178 }
1179
1180 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1181 for SetUpgradableUrlsError
1182 {
1183 #[inline(always)]
1184 fn new_empty() -> Self {
1185 Self::unknown()
1186 }
1187
1188 #[inline]
1189 unsafe fn decode(
1190 &mut self,
1191 decoder: &mut fidl::encoding::Decoder<'_, D>,
1192 offset: usize,
1193 _depth: fidl::encoding::Depth,
1194 ) -> fidl::Result<()> {
1195 decoder.debug_check_bounds::<Self>(offset);
1196 let prim = decoder.read_num::<u32>(offset);
1197
1198 *self = Self::from_primitive_allow_unknown(prim);
1199 Ok(())
1200 }
1201 }
1202 unsafe impl fidl::encoding::TypeMarker for WriteError {
1203 type Owned = Self;
1204
1205 #[inline(always)]
1206 fn inline_align(_context: fidl::encoding::Context) -> usize {
1207 std::mem::align_of::<u32>()
1208 }
1209
1210 #[inline(always)]
1211 fn inline_size(_context: fidl::encoding::Context) -> usize {
1212 std::mem::size_of::<u32>()
1213 }
1214
1215 #[inline(always)]
1216 fn encode_is_copy() -> bool {
1217 true
1218 }
1219
1220 #[inline(always)]
1221 fn decode_is_copy() -> bool {
1222 false
1223 }
1224 }
1225
1226 impl fidl::encoding::ValueTypeMarker for WriteError {
1227 type Borrowed<'a> = Self;
1228 #[inline(always)]
1229 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1230 *value
1231 }
1232 }
1233
1234 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WriteError {
1235 #[inline]
1236 unsafe fn encode(
1237 self,
1238 encoder: &mut fidl::encoding::Encoder<'_, D>,
1239 offset: usize,
1240 _depth: fidl::encoding::Depth,
1241 ) -> fidl::Result<()> {
1242 encoder.debug_check_bounds::<Self>(offset);
1243 encoder.write_num(self.into_primitive(), offset);
1244 Ok(())
1245 }
1246 }
1247
1248 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WriteError {
1249 #[inline(always)]
1250 fn new_empty() -> Self {
1251 Self::UnknownUrl
1252 }
1253
1254 #[inline]
1255 unsafe fn decode(
1256 &mut self,
1257 decoder: &mut fidl::encoding::Decoder<'_, D>,
1258 offset: usize,
1259 _depth: fidl::encoding::Depth,
1260 ) -> fidl::Result<()> {
1261 decoder.debug_check_bounds::<Self>(offset);
1262 let prim = decoder.read_num::<u32>(offset);
1263
1264 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1265 Ok(())
1266 }
1267 }
1268
1269 impl fidl::encoding::ValueTypeMarker for BlobId {
1270 type Borrowed<'a> = &'a Self;
1271 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1272 value
1273 }
1274 }
1275
1276 unsafe impl fidl::encoding::TypeMarker for BlobId {
1277 type Owned = Self;
1278
1279 #[inline(always)]
1280 fn inline_align(_context: fidl::encoding::Context) -> usize {
1281 1
1282 }
1283
1284 #[inline(always)]
1285 fn inline_size(_context: fidl::encoding::Context) -> usize {
1286 32
1287 }
1288 #[inline(always)]
1289 fn encode_is_copy() -> bool {
1290 true
1291 }
1292
1293 #[inline(always)]
1294 fn decode_is_copy() -> bool {
1295 true
1296 }
1297 }
1298
1299 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlobId, D> for &BlobId {
1300 #[inline]
1301 unsafe fn encode(
1302 self,
1303 encoder: &mut fidl::encoding::Encoder<'_, D>,
1304 offset: usize,
1305 _depth: fidl::encoding::Depth,
1306 ) -> fidl::Result<()> {
1307 encoder.debug_check_bounds::<BlobId>(offset);
1308 unsafe {
1309 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1311 (buf_ptr as *mut BlobId).write_unaligned((self as *const BlobId).read());
1312 }
1315 Ok(())
1316 }
1317 }
1318 unsafe impl<
1319 D: fidl::encoding::ResourceDialect,
1320 T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 32>, D>,
1321 > fidl::encoding::Encode<BlobId, D> for (T0,)
1322 {
1323 #[inline]
1324 unsafe fn encode(
1325 self,
1326 encoder: &mut fidl::encoding::Encoder<'_, D>,
1327 offset: usize,
1328 depth: fidl::encoding::Depth,
1329 ) -> fidl::Result<()> {
1330 encoder.debug_check_bounds::<BlobId>(offset);
1331 self.0.encode(encoder, offset + 0, depth)?;
1335 Ok(())
1336 }
1337 }
1338
1339 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlobId {
1340 #[inline(always)]
1341 fn new_empty() -> Self {
1342 Self { merkle_root: fidl::new_empty!(fidl::encoding::Array<u8, 32>, D) }
1343 }
1344
1345 #[inline]
1346 unsafe fn decode(
1347 &mut self,
1348 decoder: &mut fidl::encoding::Decoder<'_, D>,
1349 offset: usize,
1350 _depth: fidl::encoding::Depth,
1351 ) -> fidl::Result<()> {
1352 decoder.debug_check_bounds::<Self>(offset);
1353 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1354 unsafe {
1357 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
1358 }
1359 Ok(())
1360 }
1361 }
1362
1363 impl fidl::encoding::ValueTypeMarker for BlobIdIteratorNextResponse {
1364 type Borrowed<'a> = &'a Self;
1365 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1366 value
1367 }
1368 }
1369
1370 unsafe impl fidl::encoding::TypeMarker for BlobIdIteratorNextResponse {
1371 type Owned = Self;
1372
1373 #[inline(always)]
1374 fn inline_align(_context: fidl::encoding::Context) -> usize {
1375 8
1376 }
1377
1378 #[inline(always)]
1379 fn inline_size(_context: fidl::encoding::Context) -> usize {
1380 16
1381 }
1382 }
1383
1384 unsafe impl<D: fidl::encoding::ResourceDialect>
1385 fidl::encoding::Encode<BlobIdIteratorNextResponse, D> for &BlobIdIteratorNextResponse
1386 {
1387 #[inline]
1388 unsafe fn encode(
1389 self,
1390 encoder: &mut fidl::encoding::Encoder<'_, D>,
1391 offset: usize,
1392 _depth: fidl::encoding::Depth,
1393 ) -> fidl::Result<()> {
1394 encoder.debug_check_bounds::<BlobIdIteratorNextResponse>(offset);
1395 fidl::encoding::Encode::<BlobIdIteratorNextResponse, D>::encode(
1397 (
1398 <fidl::encoding::UnboundedVector<BlobId> as fidl::encoding::ValueTypeMarker>::borrow(&self.blobs),
1399 ),
1400 encoder, offset, _depth
1401 )
1402 }
1403 }
1404 unsafe impl<
1405 D: fidl::encoding::ResourceDialect,
1406 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<BlobId>, D>,
1407 > fidl::encoding::Encode<BlobIdIteratorNextResponse, D> for (T0,)
1408 {
1409 #[inline]
1410 unsafe fn encode(
1411 self,
1412 encoder: &mut fidl::encoding::Encoder<'_, D>,
1413 offset: usize,
1414 depth: fidl::encoding::Depth,
1415 ) -> fidl::Result<()> {
1416 encoder.debug_check_bounds::<BlobIdIteratorNextResponse>(offset);
1417 self.0.encode(encoder, offset + 0, depth)?;
1421 Ok(())
1422 }
1423 }
1424
1425 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1426 for BlobIdIteratorNextResponse
1427 {
1428 #[inline(always)]
1429 fn new_empty() -> Self {
1430 Self { blobs: fidl::new_empty!(fidl::encoding::UnboundedVector<BlobId>, D) }
1431 }
1432
1433 #[inline]
1434 unsafe fn decode(
1435 &mut self,
1436 decoder: &mut fidl::encoding::Decoder<'_, D>,
1437 offset: usize,
1438 _depth: fidl::encoding::Depth,
1439 ) -> fidl::Result<()> {
1440 decoder.debug_check_bounds::<Self>(offset);
1441 fidl::decode!(
1443 fidl::encoding::UnboundedVector<BlobId>,
1444 D,
1445 &mut self.blobs,
1446 decoder,
1447 offset + 0,
1448 _depth
1449 )?;
1450 Ok(())
1451 }
1452 }
1453
1454 impl fidl::encoding::ValueTypeMarker for BlobInfo {
1455 type Borrowed<'a> = &'a Self;
1456 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1457 value
1458 }
1459 }
1460
1461 unsafe impl fidl::encoding::TypeMarker for BlobInfo {
1462 type Owned = Self;
1463
1464 #[inline(always)]
1465 fn inline_align(_context: fidl::encoding::Context) -> usize {
1466 8
1467 }
1468
1469 #[inline(always)]
1470 fn inline_size(_context: fidl::encoding::Context) -> usize {
1471 40
1472 }
1473 #[inline(always)]
1474 fn encode_is_copy() -> bool {
1475 true
1476 }
1477
1478 #[inline(always)]
1479 fn decode_is_copy() -> bool {
1480 true
1481 }
1482 }
1483
1484 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlobInfo, D> for &BlobInfo {
1485 #[inline]
1486 unsafe fn encode(
1487 self,
1488 encoder: &mut fidl::encoding::Encoder<'_, D>,
1489 offset: usize,
1490 _depth: fidl::encoding::Depth,
1491 ) -> fidl::Result<()> {
1492 encoder.debug_check_bounds::<BlobInfo>(offset);
1493 unsafe {
1494 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1496 (buf_ptr as *mut BlobInfo).write_unaligned((self as *const BlobInfo).read());
1497 }
1500 Ok(())
1501 }
1502 }
1503 unsafe impl<
1504 D: fidl::encoding::ResourceDialect,
1505 T0: fidl::encoding::Encode<BlobId, D>,
1506 T1: fidl::encoding::Encode<u64, D>,
1507 > fidl::encoding::Encode<BlobInfo, D> for (T0, T1)
1508 {
1509 #[inline]
1510 unsafe fn encode(
1511 self,
1512 encoder: &mut fidl::encoding::Encoder<'_, D>,
1513 offset: usize,
1514 depth: fidl::encoding::Depth,
1515 ) -> fidl::Result<()> {
1516 encoder.debug_check_bounds::<BlobInfo>(offset);
1517 self.0.encode(encoder, offset + 0, depth)?;
1521 self.1.encode(encoder, offset + 32, depth)?;
1522 Ok(())
1523 }
1524 }
1525
1526 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlobInfo {
1527 #[inline(always)]
1528 fn new_empty() -> Self {
1529 Self { blob_id: fidl::new_empty!(BlobId, D), length: fidl::new_empty!(u64, D) }
1530 }
1531
1532 #[inline]
1533 unsafe fn decode(
1534 &mut self,
1535 decoder: &mut fidl::encoding::Decoder<'_, D>,
1536 offset: usize,
1537 _depth: fidl::encoding::Depth,
1538 ) -> fidl::Result<()> {
1539 decoder.debug_check_bounds::<Self>(offset);
1540 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1541 unsafe {
1544 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 40);
1545 }
1546 Ok(())
1547 }
1548 }
1549
1550 impl fidl::encoding::ValueTypeMarker for BlobInfoIteratorNextResponse {
1551 type Borrowed<'a> = &'a Self;
1552 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1553 value
1554 }
1555 }
1556
1557 unsafe impl fidl::encoding::TypeMarker for BlobInfoIteratorNextResponse {
1558 type Owned = Self;
1559
1560 #[inline(always)]
1561 fn inline_align(_context: fidl::encoding::Context) -> usize {
1562 8
1563 }
1564
1565 #[inline(always)]
1566 fn inline_size(_context: fidl::encoding::Context) -> usize {
1567 16
1568 }
1569 }
1570
1571 unsafe impl<D: fidl::encoding::ResourceDialect>
1572 fidl::encoding::Encode<BlobInfoIteratorNextResponse, D> for &BlobInfoIteratorNextResponse
1573 {
1574 #[inline]
1575 unsafe fn encode(
1576 self,
1577 encoder: &mut fidl::encoding::Encoder<'_, D>,
1578 offset: usize,
1579 _depth: fidl::encoding::Depth,
1580 ) -> fidl::Result<()> {
1581 encoder.debug_check_bounds::<BlobInfoIteratorNextResponse>(offset);
1582 fidl::encoding::Encode::<BlobInfoIteratorNextResponse, D>::encode(
1584 (
1585 <fidl::encoding::UnboundedVector<BlobInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.blobs),
1586 ),
1587 encoder, offset, _depth
1588 )
1589 }
1590 }
1591 unsafe impl<
1592 D: fidl::encoding::ResourceDialect,
1593 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<BlobInfo>, D>,
1594 > fidl::encoding::Encode<BlobInfoIteratorNextResponse, D> for (T0,)
1595 {
1596 #[inline]
1597 unsafe fn encode(
1598 self,
1599 encoder: &mut fidl::encoding::Encoder<'_, D>,
1600 offset: usize,
1601 depth: fidl::encoding::Depth,
1602 ) -> fidl::Result<()> {
1603 encoder.debug_check_bounds::<BlobInfoIteratorNextResponse>(offset);
1604 self.0.encode(encoder, offset + 0, depth)?;
1608 Ok(())
1609 }
1610 }
1611
1612 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1613 for BlobInfoIteratorNextResponse
1614 {
1615 #[inline(always)]
1616 fn new_empty() -> Self {
1617 Self { blobs: fidl::new_empty!(fidl::encoding::UnboundedVector<BlobInfo>, D) }
1618 }
1619
1620 #[inline]
1621 unsafe fn decode(
1622 &mut self,
1623 decoder: &mut fidl::encoding::Decoder<'_, D>,
1624 offset: usize,
1625 _depth: fidl::encoding::Depth,
1626 ) -> fidl::Result<()> {
1627 decoder.debug_check_bounds::<Self>(offset);
1628 fidl::decode!(
1630 fidl::encoding::UnboundedVector<BlobInfo>,
1631 D,
1632 &mut self.blobs,
1633 decoder,
1634 offset + 0,
1635 _depth
1636 )?;
1637 Ok(())
1638 }
1639 }
1640
1641 impl fidl::encoding::ValueTypeMarker for CupGetInfoRequest {
1642 type Borrowed<'a> = &'a Self;
1643 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1644 value
1645 }
1646 }
1647
1648 unsafe impl fidl::encoding::TypeMarker for CupGetInfoRequest {
1649 type Owned = Self;
1650
1651 #[inline(always)]
1652 fn inline_align(_context: fidl::encoding::Context) -> usize {
1653 8
1654 }
1655
1656 #[inline(always)]
1657 fn inline_size(_context: fidl::encoding::Context) -> usize {
1658 16
1659 }
1660 }
1661
1662 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupGetInfoRequest, D>
1663 for &CupGetInfoRequest
1664 {
1665 #[inline]
1666 unsafe fn encode(
1667 self,
1668 encoder: &mut fidl::encoding::Encoder<'_, D>,
1669 offset: usize,
1670 _depth: fidl::encoding::Depth,
1671 ) -> fidl::Result<()> {
1672 encoder.debug_check_bounds::<CupGetInfoRequest>(offset);
1673 fidl::encoding::Encode::<CupGetInfoRequest, D>::encode(
1675 (<PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.url),),
1676 encoder,
1677 offset,
1678 _depth,
1679 )
1680 }
1681 }
1682 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PackageUrl, D>>
1683 fidl::encoding::Encode<CupGetInfoRequest, D> for (T0,)
1684 {
1685 #[inline]
1686 unsafe fn encode(
1687 self,
1688 encoder: &mut fidl::encoding::Encoder<'_, D>,
1689 offset: usize,
1690 depth: fidl::encoding::Depth,
1691 ) -> fidl::Result<()> {
1692 encoder.debug_check_bounds::<CupGetInfoRequest>(offset);
1693 self.0.encode(encoder, offset + 0, depth)?;
1697 Ok(())
1698 }
1699 }
1700
1701 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupGetInfoRequest {
1702 #[inline(always)]
1703 fn new_empty() -> Self {
1704 Self { url: fidl::new_empty!(PackageUrl, D) }
1705 }
1706
1707 #[inline]
1708 unsafe fn decode(
1709 &mut self,
1710 decoder: &mut fidl::encoding::Decoder<'_, D>,
1711 offset: usize,
1712 _depth: fidl::encoding::Depth,
1713 ) -> fidl::Result<()> {
1714 decoder.debug_check_bounds::<Self>(offset);
1715 fidl::decode!(PackageUrl, D, &mut self.url, decoder, offset + 0, _depth)?;
1717 Ok(())
1718 }
1719 }
1720
1721 impl fidl::encoding::ValueTypeMarker for CupWriteRequest {
1722 type Borrowed<'a> = &'a Self;
1723 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1724 value
1725 }
1726 }
1727
1728 unsafe impl fidl::encoding::TypeMarker for CupWriteRequest {
1729 type Owned = Self;
1730
1731 #[inline(always)]
1732 fn inline_align(_context: fidl::encoding::Context) -> usize {
1733 8
1734 }
1735
1736 #[inline(always)]
1737 fn inline_size(_context: fidl::encoding::Context) -> usize {
1738 32
1739 }
1740 }
1741
1742 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupWriteRequest, D>
1743 for &CupWriteRequest
1744 {
1745 #[inline]
1746 unsafe fn encode(
1747 self,
1748 encoder: &mut fidl::encoding::Encoder<'_, D>,
1749 offset: usize,
1750 _depth: fidl::encoding::Depth,
1751 ) -> fidl::Result<()> {
1752 encoder.debug_check_bounds::<CupWriteRequest>(offset);
1753 fidl::encoding::Encode::<CupWriteRequest, D>::encode(
1755 (
1756 <PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
1757 <CupData as fidl::encoding::ValueTypeMarker>::borrow(&self.cup),
1758 ),
1759 encoder,
1760 offset,
1761 _depth,
1762 )
1763 }
1764 }
1765 unsafe impl<
1766 D: fidl::encoding::ResourceDialect,
1767 T0: fidl::encoding::Encode<PackageUrl, D>,
1768 T1: fidl::encoding::Encode<CupData, D>,
1769 > fidl::encoding::Encode<CupWriteRequest, D> for (T0, T1)
1770 {
1771 #[inline]
1772 unsafe fn encode(
1773 self,
1774 encoder: &mut fidl::encoding::Encoder<'_, D>,
1775 offset: usize,
1776 depth: fidl::encoding::Depth,
1777 ) -> fidl::Result<()> {
1778 encoder.debug_check_bounds::<CupWriteRequest>(offset);
1779 self.0.encode(encoder, offset + 0, depth)?;
1783 self.1.encode(encoder, offset + 16, depth)?;
1784 Ok(())
1785 }
1786 }
1787
1788 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupWriteRequest {
1789 #[inline(always)]
1790 fn new_empty() -> Self {
1791 Self { url: fidl::new_empty!(PackageUrl, D), cup: fidl::new_empty!(CupData, D) }
1792 }
1793
1794 #[inline]
1795 unsafe fn decode(
1796 &mut self,
1797 decoder: &mut fidl::encoding::Decoder<'_, D>,
1798 offset: usize,
1799 _depth: fidl::encoding::Depth,
1800 ) -> fidl::Result<()> {
1801 decoder.debug_check_bounds::<Self>(offset);
1802 fidl::decode!(PackageUrl, D, &mut self.url, decoder, offset + 0, _depth)?;
1804 fidl::decode!(CupData, D, &mut self.cup, decoder, offset + 16, _depth)?;
1805 Ok(())
1806 }
1807 }
1808
1809 impl fidl::encoding::ValueTypeMarker for CupGetInfoResponse {
1810 type Borrowed<'a> = &'a Self;
1811 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1812 value
1813 }
1814 }
1815
1816 unsafe impl fidl::encoding::TypeMarker for CupGetInfoResponse {
1817 type Owned = Self;
1818
1819 #[inline(always)]
1820 fn inline_align(_context: fidl::encoding::Context) -> usize {
1821 8
1822 }
1823
1824 #[inline(always)]
1825 fn inline_size(_context: fidl::encoding::Context) -> usize {
1826 32
1827 }
1828 }
1829
1830 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupGetInfoResponse, D>
1831 for &CupGetInfoResponse
1832 {
1833 #[inline]
1834 unsafe fn encode(
1835 self,
1836 encoder: &mut fidl::encoding::Encoder<'_, D>,
1837 offset: usize,
1838 _depth: fidl::encoding::Depth,
1839 ) -> fidl::Result<()> {
1840 encoder.debug_check_bounds::<CupGetInfoResponse>(offset);
1841 fidl::encoding::Encode::<CupGetInfoResponse, D>::encode(
1843 (
1844 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
1845 &self.version,
1846 ),
1847 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(
1848 &self.channel,
1849 ),
1850 ),
1851 encoder,
1852 offset,
1853 _depth,
1854 )
1855 }
1856 }
1857 unsafe impl<
1858 D: fidl::encoding::ResourceDialect,
1859 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
1860 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1861 > fidl::encoding::Encode<CupGetInfoResponse, D> for (T0, T1)
1862 {
1863 #[inline]
1864 unsafe fn encode(
1865 self,
1866 encoder: &mut fidl::encoding::Encoder<'_, D>,
1867 offset: usize,
1868 depth: fidl::encoding::Depth,
1869 ) -> fidl::Result<()> {
1870 encoder.debug_check_bounds::<CupGetInfoResponse>(offset);
1871 self.0.encode(encoder, offset + 0, depth)?;
1875 self.1.encode(encoder, offset + 16, depth)?;
1876 Ok(())
1877 }
1878 }
1879
1880 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupGetInfoResponse {
1881 #[inline(always)]
1882 fn new_empty() -> Self {
1883 Self {
1884 version: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
1885 channel: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1886 }
1887 }
1888
1889 #[inline]
1890 unsafe fn decode(
1891 &mut self,
1892 decoder: &mut fidl::encoding::Decoder<'_, D>,
1893 offset: usize,
1894 _depth: fidl::encoding::Depth,
1895 ) -> fidl::Result<()> {
1896 decoder.debug_check_bounds::<Self>(offset);
1897 fidl::decode!(
1899 fidl::encoding::BoundedString<64>,
1900 D,
1901 &mut self.version,
1902 decoder,
1903 offset + 0,
1904 _depth
1905 )?;
1906 fidl::decode!(
1907 fidl::encoding::BoundedString<128>,
1908 D,
1909 &mut self.channel,
1910 decoder,
1911 offset + 16,
1912 _depth
1913 )?;
1914 Ok(())
1915 }
1916 }
1917
1918 impl fidl::encoding::ValueTypeMarker for NeededBlobsBlobWrittenRequest {
1919 type Borrowed<'a> = &'a Self;
1920 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1921 value
1922 }
1923 }
1924
1925 unsafe impl fidl::encoding::TypeMarker for NeededBlobsBlobWrittenRequest {
1926 type Owned = Self;
1927
1928 #[inline(always)]
1929 fn inline_align(_context: fidl::encoding::Context) -> usize {
1930 1
1931 }
1932
1933 #[inline(always)]
1934 fn inline_size(_context: fidl::encoding::Context) -> usize {
1935 32
1936 }
1937 #[inline(always)]
1938 fn encode_is_copy() -> bool {
1939 true
1940 }
1941
1942 #[inline(always)]
1943 fn decode_is_copy() -> bool {
1944 true
1945 }
1946 }
1947
1948 unsafe impl<D: fidl::encoding::ResourceDialect>
1949 fidl::encoding::Encode<NeededBlobsBlobWrittenRequest, D>
1950 for &NeededBlobsBlobWrittenRequest
1951 {
1952 #[inline]
1953 unsafe fn encode(
1954 self,
1955 encoder: &mut fidl::encoding::Encoder<'_, D>,
1956 offset: usize,
1957 _depth: fidl::encoding::Depth,
1958 ) -> fidl::Result<()> {
1959 encoder.debug_check_bounds::<NeededBlobsBlobWrittenRequest>(offset);
1960 unsafe {
1961 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1963 (buf_ptr as *mut NeededBlobsBlobWrittenRequest)
1964 .write_unaligned((self as *const NeededBlobsBlobWrittenRequest).read());
1965 }
1968 Ok(())
1969 }
1970 }
1971 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlobId, D>>
1972 fidl::encoding::Encode<NeededBlobsBlobWrittenRequest, D> for (T0,)
1973 {
1974 #[inline]
1975 unsafe fn encode(
1976 self,
1977 encoder: &mut fidl::encoding::Encoder<'_, D>,
1978 offset: usize,
1979 depth: fidl::encoding::Depth,
1980 ) -> fidl::Result<()> {
1981 encoder.debug_check_bounds::<NeededBlobsBlobWrittenRequest>(offset);
1982 self.0.encode(encoder, offset + 0, depth)?;
1986 Ok(())
1987 }
1988 }
1989
1990 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1991 for NeededBlobsBlobWrittenRequest
1992 {
1993 #[inline(always)]
1994 fn new_empty() -> Self {
1995 Self { blob_id: fidl::new_empty!(BlobId, D) }
1996 }
1997
1998 #[inline]
1999 unsafe fn decode(
2000 &mut self,
2001 decoder: &mut fidl::encoding::Decoder<'_, D>,
2002 offset: usize,
2003 _depth: fidl::encoding::Depth,
2004 ) -> fidl::Result<()> {
2005 decoder.debug_check_bounds::<Self>(offset);
2006 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2007 unsafe {
2010 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
2011 }
2012 Ok(())
2013 }
2014 }
2015
2016 impl fidl::encoding::ValueTypeMarker for NeededBlobsOpenBlobRequest {
2017 type Borrowed<'a> = &'a Self;
2018 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2019 value
2020 }
2021 }
2022
2023 unsafe impl fidl::encoding::TypeMarker for NeededBlobsOpenBlobRequest {
2024 type Owned = Self;
2025
2026 #[inline(always)]
2027 fn inline_align(_context: fidl::encoding::Context) -> usize {
2028 1
2029 }
2030
2031 #[inline(always)]
2032 fn inline_size(_context: fidl::encoding::Context) -> usize {
2033 32
2034 }
2035 #[inline(always)]
2036 fn encode_is_copy() -> bool {
2037 true
2038 }
2039
2040 #[inline(always)]
2041 fn decode_is_copy() -> bool {
2042 true
2043 }
2044 }
2045
2046 unsafe impl<D: fidl::encoding::ResourceDialect>
2047 fidl::encoding::Encode<NeededBlobsOpenBlobRequest, D> for &NeededBlobsOpenBlobRequest
2048 {
2049 #[inline]
2050 unsafe fn encode(
2051 self,
2052 encoder: &mut fidl::encoding::Encoder<'_, D>,
2053 offset: usize,
2054 _depth: fidl::encoding::Depth,
2055 ) -> fidl::Result<()> {
2056 encoder.debug_check_bounds::<NeededBlobsOpenBlobRequest>(offset);
2057 unsafe {
2058 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2060 (buf_ptr as *mut NeededBlobsOpenBlobRequest)
2061 .write_unaligned((self as *const NeededBlobsOpenBlobRequest).read());
2062 }
2065 Ok(())
2066 }
2067 }
2068 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlobId, D>>
2069 fidl::encoding::Encode<NeededBlobsOpenBlobRequest, D> for (T0,)
2070 {
2071 #[inline]
2072 unsafe fn encode(
2073 self,
2074 encoder: &mut fidl::encoding::Encoder<'_, D>,
2075 offset: usize,
2076 depth: fidl::encoding::Depth,
2077 ) -> fidl::Result<()> {
2078 encoder.debug_check_bounds::<NeededBlobsOpenBlobRequest>(offset);
2079 self.0.encode(encoder, offset + 0, depth)?;
2083 Ok(())
2084 }
2085 }
2086
2087 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2088 for NeededBlobsOpenBlobRequest
2089 {
2090 #[inline(always)]
2091 fn new_empty() -> Self {
2092 Self { blob_id: fidl::new_empty!(BlobId, D) }
2093 }
2094
2095 #[inline]
2096 unsafe fn decode(
2097 &mut self,
2098 decoder: &mut fidl::encoding::Decoder<'_, D>,
2099 offset: usize,
2100 _depth: fidl::encoding::Depth,
2101 ) -> fidl::Result<()> {
2102 decoder.debug_check_bounds::<Self>(offset);
2103 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2104 unsafe {
2107 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
2108 }
2109 Ok(())
2110 }
2111 }
2112
2113 impl fidl::encoding::ValueTypeMarker for PackageCacheSetUpgradableUrlsRequest {
2114 type Borrowed<'a> = &'a Self;
2115 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2116 value
2117 }
2118 }
2119
2120 unsafe impl fidl::encoding::TypeMarker for PackageCacheSetUpgradableUrlsRequest {
2121 type Owned = Self;
2122
2123 #[inline(always)]
2124 fn inline_align(_context: fidl::encoding::Context) -> usize {
2125 8
2126 }
2127
2128 #[inline(always)]
2129 fn inline_size(_context: fidl::encoding::Context) -> usize {
2130 16
2131 }
2132 }
2133
2134 unsafe impl<D: fidl::encoding::ResourceDialect>
2135 fidl::encoding::Encode<PackageCacheSetUpgradableUrlsRequest, D>
2136 for &PackageCacheSetUpgradableUrlsRequest
2137 {
2138 #[inline]
2139 unsafe fn encode(
2140 self,
2141 encoder: &mut fidl::encoding::Encoder<'_, D>,
2142 offset: usize,
2143 _depth: fidl::encoding::Depth,
2144 ) -> fidl::Result<()> {
2145 encoder.debug_check_bounds::<PackageCacheSetUpgradableUrlsRequest>(offset);
2146 fidl::encoding::Encode::<PackageCacheSetUpgradableUrlsRequest, D>::encode(
2148 (
2149 <fidl::encoding::UnboundedVector<PackageUrl> as fidl::encoding::ValueTypeMarker>::borrow(&self.pinned_urls),
2150 ),
2151 encoder, offset, _depth
2152 )
2153 }
2154 }
2155 unsafe impl<
2156 D: fidl::encoding::ResourceDialect,
2157 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<PackageUrl>, D>,
2158 > fidl::encoding::Encode<PackageCacheSetUpgradableUrlsRequest, D> for (T0,)
2159 {
2160 #[inline]
2161 unsafe fn encode(
2162 self,
2163 encoder: &mut fidl::encoding::Encoder<'_, D>,
2164 offset: usize,
2165 depth: fidl::encoding::Depth,
2166 ) -> fidl::Result<()> {
2167 encoder.debug_check_bounds::<PackageCacheSetUpgradableUrlsRequest>(offset);
2168 self.0.encode(encoder, offset + 0, depth)?;
2172 Ok(())
2173 }
2174 }
2175
2176 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2177 for PackageCacheSetUpgradableUrlsRequest
2178 {
2179 #[inline(always)]
2180 fn new_empty() -> Self {
2181 Self { pinned_urls: fidl::new_empty!(fidl::encoding::UnboundedVector<PackageUrl>, D) }
2182 }
2183
2184 #[inline]
2185 unsafe fn decode(
2186 &mut self,
2187 decoder: &mut fidl::encoding::Decoder<'_, D>,
2188 offset: usize,
2189 _depth: fidl::encoding::Depth,
2190 ) -> fidl::Result<()> {
2191 decoder.debug_check_bounds::<Self>(offset);
2192 fidl::decode!(
2194 fidl::encoding::UnboundedVector<PackageUrl>,
2195 D,
2196 &mut self.pinned_urls,
2197 decoder,
2198 offset + 0,
2199 _depth
2200 )?;
2201 Ok(())
2202 }
2203 }
2204
2205 impl fidl::encoding::ValueTypeMarker for PackageIndexEntry {
2206 type Borrowed<'a> = &'a Self;
2207 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2208 value
2209 }
2210 }
2211
2212 unsafe impl fidl::encoding::TypeMarker for PackageIndexEntry {
2213 type Owned = Self;
2214
2215 #[inline(always)]
2216 fn inline_align(_context: fidl::encoding::Context) -> usize {
2217 8
2218 }
2219
2220 #[inline(always)]
2221 fn inline_size(_context: fidl::encoding::Context) -> usize {
2222 48
2223 }
2224 }
2225
2226 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PackageIndexEntry, D>
2227 for &PackageIndexEntry
2228 {
2229 #[inline]
2230 unsafe fn encode(
2231 self,
2232 encoder: &mut fidl::encoding::Encoder<'_, D>,
2233 offset: usize,
2234 _depth: fidl::encoding::Depth,
2235 ) -> fidl::Result<()> {
2236 encoder.debug_check_bounds::<PackageIndexEntry>(offset);
2237 fidl::encoding::Encode::<PackageIndexEntry, D>::encode(
2239 (
2240 <PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.package_url),
2241 <BlobId as fidl::encoding::ValueTypeMarker>::borrow(&self.meta_far_blob_id),
2242 ),
2243 encoder,
2244 offset,
2245 _depth,
2246 )
2247 }
2248 }
2249 unsafe impl<
2250 D: fidl::encoding::ResourceDialect,
2251 T0: fidl::encoding::Encode<PackageUrl, D>,
2252 T1: fidl::encoding::Encode<BlobId, D>,
2253 > fidl::encoding::Encode<PackageIndexEntry, D> for (T0, T1)
2254 {
2255 #[inline]
2256 unsafe fn encode(
2257 self,
2258 encoder: &mut fidl::encoding::Encoder<'_, D>,
2259 offset: usize,
2260 depth: fidl::encoding::Depth,
2261 ) -> fidl::Result<()> {
2262 encoder.debug_check_bounds::<PackageIndexEntry>(offset);
2263 self.0.encode(encoder, offset + 0, depth)?;
2267 self.1.encode(encoder, offset + 16, depth)?;
2268 Ok(())
2269 }
2270 }
2271
2272 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PackageIndexEntry {
2273 #[inline(always)]
2274 fn new_empty() -> Self {
2275 Self {
2276 package_url: fidl::new_empty!(PackageUrl, D),
2277 meta_far_blob_id: fidl::new_empty!(BlobId, D),
2278 }
2279 }
2280
2281 #[inline]
2282 unsafe fn decode(
2283 &mut self,
2284 decoder: &mut fidl::encoding::Decoder<'_, D>,
2285 offset: usize,
2286 _depth: fidl::encoding::Depth,
2287 ) -> fidl::Result<()> {
2288 decoder.debug_check_bounds::<Self>(offset);
2289 fidl::decode!(PackageUrl, D, &mut self.package_url, decoder, offset + 0, _depth)?;
2291 fidl::decode!(BlobId, D, &mut self.meta_far_blob_id, decoder, offset + 16, _depth)?;
2292 Ok(())
2293 }
2294 }
2295
2296 impl fidl::encoding::ValueTypeMarker for PackageIndexIteratorNextResponse {
2297 type Borrowed<'a> = &'a Self;
2298 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2299 value
2300 }
2301 }
2302
2303 unsafe impl fidl::encoding::TypeMarker for PackageIndexIteratorNextResponse {
2304 type Owned = Self;
2305
2306 #[inline(always)]
2307 fn inline_align(_context: fidl::encoding::Context) -> usize {
2308 8
2309 }
2310
2311 #[inline(always)]
2312 fn inline_size(_context: fidl::encoding::Context) -> usize {
2313 16
2314 }
2315 }
2316
2317 unsafe impl<D: fidl::encoding::ResourceDialect>
2318 fidl::encoding::Encode<PackageIndexIteratorNextResponse, D>
2319 for &PackageIndexIteratorNextResponse
2320 {
2321 #[inline]
2322 unsafe fn encode(
2323 self,
2324 encoder: &mut fidl::encoding::Encoder<'_, D>,
2325 offset: usize,
2326 _depth: fidl::encoding::Depth,
2327 ) -> fidl::Result<()> {
2328 encoder.debug_check_bounds::<PackageIndexIteratorNextResponse>(offset);
2329 fidl::encoding::Encode::<PackageIndexIteratorNextResponse, D>::encode(
2331 (
2332 <fidl::encoding::UnboundedVector<PackageIndexEntry> as fidl::encoding::ValueTypeMarker>::borrow(&self.entries),
2333 ),
2334 encoder, offset, _depth
2335 )
2336 }
2337 }
2338 unsafe impl<
2339 D: fidl::encoding::ResourceDialect,
2340 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<PackageIndexEntry>, D>,
2341 > fidl::encoding::Encode<PackageIndexIteratorNextResponse, D> for (T0,)
2342 {
2343 #[inline]
2344 unsafe fn encode(
2345 self,
2346 encoder: &mut fidl::encoding::Encoder<'_, D>,
2347 offset: usize,
2348 depth: fidl::encoding::Depth,
2349 ) -> fidl::Result<()> {
2350 encoder.debug_check_bounds::<PackageIndexIteratorNextResponse>(offset);
2351 self.0.encode(encoder, offset + 0, depth)?;
2355 Ok(())
2356 }
2357 }
2358
2359 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2360 for PackageIndexIteratorNextResponse
2361 {
2362 #[inline(always)]
2363 fn new_empty() -> Self {
2364 Self {
2365 entries: fidl::new_empty!(fidl::encoding::UnboundedVector<PackageIndexEntry>, D),
2366 }
2367 }
2368
2369 #[inline]
2370 unsafe fn decode(
2371 &mut self,
2372 decoder: &mut fidl::encoding::Decoder<'_, D>,
2373 offset: usize,
2374 _depth: fidl::encoding::Depth,
2375 ) -> fidl::Result<()> {
2376 decoder.debug_check_bounds::<Self>(offset);
2377 fidl::decode!(
2379 fidl::encoding::UnboundedVector<PackageIndexEntry>,
2380 D,
2381 &mut self.entries,
2382 decoder,
2383 offset + 0,
2384 _depth
2385 )?;
2386 Ok(())
2387 }
2388 }
2389
2390 impl fidl::encoding::ValueTypeMarker for PackageResolverGetHashRequest {
2391 type Borrowed<'a> = &'a Self;
2392 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2393 value
2394 }
2395 }
2396
2397 unsafe impl fidl::encoding::TypeMarker for PackageResolverGetHashRequest {
2398 type Owned = Self;
2399
2400 #[inline(always)]
2401 fn inline_align(_context: fidl::encoding::Context) -> usize {
2402 8
2403 }
2404
2405 #[inline(always)]
2406 fn inline_size(_context: fidl::encoding::Context) -> usize {
2407 16
2408 }
2409 }
2410
2411 unsafe impl<D: fidl::encoding::ResourceDialect>
2412 fidl::encoding::Encode<PackageResolverGetHashRequest, D>
2413 for &PackageResolverGetHashRequest
2414 {
2415 #[inline]
2416 unsafe fn encode(
2417 self,
2418 encoder: &mut fidl::encoding::Encoder<'_, D>,
2419 offset: usize,
2420 _depth: fidl::encoding::Depth,
2421 ) -> fidl::Result<()> {
2422 encoder.debug_check_bounds::<PackageResolverGetHashRequest>(offset);
2423 fidl::encoding::Encode::<PackageResolverGetHashRequest, D>::encode(
2425 (<PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.package_url),),
2426 encoder,
2427 offset,
2428 _depth,
2429 )
2430 }
2431 }
2432 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PackageUrl, D>>
2433 fidl::encoding::Encode<PackageResolverGetHashRequest, D> for (T0,)
2434 {
2435 #[inline]
2436 unsafe fn encode(
2437 self,
2438 encoder: &mut fidl::encoding::Encoder<'_, D>,
2439 offset: usize,
2440 depth: fidl::encoding::Depth,
2441 ) -> fidl::Result<()> {
2442 encoder.debug_check_bounds::<PackageResolverGetHashRequest>(offset);
2443 self.0.encode(encoder, offset + 0, depth)?;
2447 Ok(())
2448 }
2449 }
2450
2451 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2452 for PackageResolverGetHashRequest
2453 {
2454 #[inline(always)]
2455 fn new_empty() -> Self {
2456 Self { package_url: fidl::new_empty!(PackageUrl, D) }
2457 }
2458
2459 #[inline]
2460 unsafe fn decode(
2461 &mut self,
2462 decoder: &mut fidl::encoding::Decoder<'_, D>,
2463 offset: usize,
2464 _depth: fidl::encoding::Depth,
2465 ) -> fidl::Result<()> {
2466 decoder.debug_check_bounds::<Self>(offset);
2467 fidl::decode!(PackageUrl, D, &mut self.package_url, decoder, offset + 0, _depth)?;
2469 Ok(())
2470 }
2471 }
2472
2473 impl fidl::encoding::ValueTypeMarker for PackageResolverGetHashResponse {
2474 type Borrowed<'a> = &'a Self;
2475 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2476 value
2477 }
2478 }
2479
2480 unsafe impl fidl::encoding::TypeMarker for PackageResolverGetHashResponse {
2481 type Owned = Self;
2482
2483 #[inline(always)]
2484 fn inline_align(_context: fidl::encoding::Context) -> usize {
2485 1
2486 }
2487
2488 #[inline(always)]
2489 fn inline_size(_context: fidl::encoding::Context) -> usize {
2490 32
2491 }
2492 #[inline(always)]
2493 fn encode_is_copy() -> bool {
2494 true
2495 }
2496
2497 #[inline(always)]
2498 fn decode_is_copy() -> bool {
2499 true
2500 }
2501 }
2502
2503 unsafe impl<D: fidl::encoding::ResourceDialect>
2504 fidl::encoding::Encode<PackageResolverGetHashResponse, D>
2505 for &PackageResolverGetHashResponse
2506 {
2507 #[inline]
2508 unsafe fn encode(
2509 self,
2510 encoder: &mut fidl::encoding::Encoder<'_, D>,
2511 offset: usize,
2512 _depth: fidl::encoding::Depth,
2513 ) -> fidl::Result<()> {
2514 encoder.debug_check_bounds::<PackageResolverGetHashResponse>(offset);
2515 unsafe {
2516 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2518 (buf_ptr as *mut PackageResolverGetHashResponse)
2519 .write_unaligned((self as *const PackageResolverGetHashResponse).read());
2520 }
2523 Ok(())
2524 }
2525 }
2526 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlobId, D>>
2527 fidl::encoding::Encode<PackageResolverGetHashResponse, D> for (T0,)
2528 {
2529 #[inline]
2530 unsafe fn encode(
2531 self,
2532 encoder: &mut fidl::encoding::Encoder<'_, D>,
2533 offset: usize,
2534 depth: fidl::encoding::Depth,
2535 ) -> fidl::Result<()> {
2536 encoder.debug_check_bounds::<PackageResolverGetHashResponse>(offset);
2537 self.0.encode(encoder, offset + 0, depth)?;
2541 Ok(())
2542 }
2543 }
2544
2545 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2546 for PackageResolverGetHashResponse
2547 {
2548 #[inline(always)]
2549 fn new_empty() -> Self {
2550 Self { meta_far_blob_id: fidl::new_empty!(BlobId, D) }
2551 }
2552
2553 #[inline]
2554 unsafe fn decode(
2555 &mut self,
2556 decoder: &mut fidl::encoding::Decoder<'_, D>,
2557 offset: usize,
2558 _depth: fidl::encoding::Depth,
2559 ) -> fidl::Result<()> {
2560 decoder.debug_check_bounds::<Self>(offset);
2561 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2562 unsafe {
2565 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
2566 }
2567 Ok(())
2568 }
2569 }
2570
2571 impl fidl::encoding::ValueTypeMarker for PackageResolverResolveWithContextResponse {
2572 type Borrowed<'a> = &'a Self;
2573 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2574 value
2575 }
2576 }
2577
2578 unsafe impl fidl::encoding::TypeMarker for PackageResolverResolveWithContextResponse {
2579 type Owned = Self;
2580
2581 #[inline(always)]
2582 fn inline_align(_context: fidl::encoding::Context) -> usize {
2583 8
2584 }
2585
2586 #[inline(always)]
2587 fn inline_size(_context: fidl::encoding::Context) -> usize {
2588 16
2589 }
2590 }
2591
2592 unsafe impl<D: fidl::encoding::ResourceDialect>
2593 fidl::encoding::Encode<PackageResolverResolveWithContextResponse, D>
2594 for &PackageResolverResolveWithContextResponse
2595 {
2596 #[inline]
2597 unsafe fn encode(
2598 self,
2599 encoder: &mut fidl::encoding::Encoder<'_, D>,
2600 offset: usize,
2601 _depth: fidl::encoding::Depth,
2602 ) -> fidl::Result<()> {
2603 encoder.debug_check_bounds::<PackageResolverResolveWithContextResponse>(offset);
2604 fidl::encoding::Encode::<PackageResolverResolveWithContextResponse, D>::encode(
2606 (<ResolutionContext as fidl::encoding::ValueTypeMarker>::borrow(
2607 &self.resolved_context,
2608 ),),
2609 encoder,
2610 offset,
2611 _depth,
2612 )
2613 }
2614 }
2615 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResolutionContext, D>>
2616 fidl::encoding::Encode<PackageResolverResolveWithContextResponse, D> for (T0,)
2617 {
2618 #[inline]
2619 unsafe fn encode(
2620 self,
2621 encoder: &mut fidl::encoding::Encoder<'_, D>,
2622 offset: usize,
2623 depth: fidl::encoding::Depth,
2624 ) -> fidl::Result<()> {
2625 encoder.debug_check_bounds::<PackageResolverResolveWithContextResponse>(offset);
2626 self.0.encode(encoder, offset + 0, depth)?;
2630 Ok(())
2631 }
2632 }
2633
2634 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2635 for PackageResolverResolveWithContextResponse
2636 {
2637 #[inline(always)]
2638 fn new_empty() -> Self {
2639 Self { resolved_context: fidl::new_empty!(ResolutionContext, D) }
2640 }
2641
2642 #[inline]
2643 unsafe fn decode(
2644 &mut self,
2645 decoder: &mut fidl::encoding::Decoder<'_, D>,
2646 offset: usize,
2647 _depth: fidl::encoding::Depth,
2648 ) -> fidl::Result<()> {
2649 decoder.debug_check_bounds::<Self>(offset);
2650 fidl::decode!(
2652 ResolutionContext,
2653 D,
2654 &mut self.resolved_context,
2655 decoder,
2656 offset + 0,
2657 _depth
2658 )?;
2659 Ok(())
2660 }
2661 }
2662
2663 impl fidl::encoding::ValueTypeMarker for PackageResolverResolveResponse {
2664 type Borrowed<'a> = &'a Self;
2665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2666 value
2667 }
2668 }
2669
2670 unsafe impl fidl::encoding::TypeMarker for PackageResolverResolveResponse {
2671 type Owned = Self;
2672
2673 #[inline(always)]
2674 fn inline_align(_context: fidl::encoding::Context) -> usize {
2675 8
2676 }
2677
2678 #[inline(always)]
2679 fn inline_size(_context: fidl::encoding::Context) -> usize {
2680 16
2681 }
2682 }
2683
2684 unsafe impl<D: fidl::encoding::ResourceDialect>
2685 fidl::encoding::Encode<PackageResolverResolveResponse, D>
2686 for &PackageResolverResolveResponse
2687 {
2688 #[inline]
2689 unsafe fn encode(
2690 self,
2691 encoder: &mut fidl::encoding::Encoder<'_, D>,
2692 offset: usize,
2693 _depth: fidl::encoding::Depth,
2694 ) -> fidl::Result<()> {
2695 encoder.debug_check_bounds::<PackageResolverResolveResponse>(offset);
2696 fidl::encoding::Encode::<PackageResolverResolveResponse, D>::encode(
2698 (<ResolutionContext as fidl::encoding::ValueTypeMarker>::borrow(
2699 &self.resolved_context,
2700 ),),
2701 encoder,
2702 offset,
2703 _depth,
2704 )
2705 }
2706 }
2707 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResolutionContext, D>>
2708 fidl::encoding::Encode<PackageResolverResolveResponse, D> for (T0,)
2709 {
2710 #[inline]
2711 unsafe fn encode(
2712 self,
2713 encoder: &mut fidl::encoding::Encoder<'_, D>,
2714 offset: usize,
2715 depth: fidl::encoding::Depth,
2716 ) -> fidl::Result<()> {
2717 encoder.debug_check_bounds::<PackageResolverResolveResponse>(offset);
2718 self.0.encode(encoder, offset + 0, depth)?;
2722 Ok(())
2723 }
2724 }
2725
2726 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2727 for PackageResolverResolveResponse
2728 {
2729 #[inline(always)]
2730 fn new_empty() -> Self {
2731 Self { resolved_context: fidl::new_empty!(ResolutionContext, D) }
2732 }
2733
2734 #[inline]
2735 unsafe fn decode(
2736 &mut self,
2737 decoder: &mut fidl::encoding::Decoder<'_, D>,
2738 offset: usize,
2739 _depth: fidl::encoding::Depth,
2740 ) -> fidl::Result<()> {
2741 decoder.debug_check_bounds::<Self>(offset);
2742 fidl::decode!(
2744 ResolutionContext,
2745 D,
2746 &mut self.resolved_context,
2747 decoder,
2748 offset + 0,
2749 _depth
2750 )?;
2751 Ok(())
2752 }
2753 }
2754
2755 impl fidl::encoding::ValueTypeMarker for PackageUrl {
2756 type Borrowed<'a> = &'a Self;
2757 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2758 value
2759 }
2760 }
2761
2762 unsafe impl fidl::encoding::TypeMarker for PackageUrl {
2763 type Owned = Self;
2764
2765 #[inline(always)]
2766 fn inline_align(_context: fidl::encoding::Context) -> usize {
2767 8
2768 }
2769
2770 #[inline(always)]
2771 fn inline_size(_context: fidl::encoding::Context) -> usize {
2772 16
2773 }
2774 }
2775
2776 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PackageUrl, D>
2777 for &PackageUrl
2778 {
2779 #[inline]
2780 unsafe fn encode(
2781 self,
2782 encoder: &mut fidl::encoding::Encoder<'_, D>,
2783 offset: usize,
2784 _depth: fidl::encoding::Depth,
2785 ) -> fidl::Result<()> {
2786 encoder.debug_check_bounds::<PackageUrl>(offset);
2787 fidl::encoding::Encode::<PackageUrl, D>::encode(
2789 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
2790 &self.url,
2791 ),),
2792 encoder,
2793 offset,
2794 _depth,
2795 )
2796 }
2797 }
2798 unsafe impl<
2799 D: fidl::encoding::ResourceDialect,
2800 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
2801 > fidl::encoding::Encode<PackageUrl, D> for (T0,)
2802 {
2803 #[inline]
2804 unsafe fn encode(
2805 self,
2806 encoder: &mut fidl::encoding::Encoder<'_, D>,
2807 offset: usize,
2808 depth: fidl::encoding::Depth,
2809 ) -> fidl::Result<()> {
2810 encoder.debug_check_bounds::<PackageUrl>(offset);
2811 self.0.encode(encoder, offset + 0, depth)?;
2815 Ok(())
2816 }
2817 }
2818
2819 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PackageUrl {
2820 #[inline(always)]
2821 fn new_empty() -> Self {
2822 Self { url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
2823 }
2824
2825 #[inline]
2826 unsafe fn decode(
2827 &mut self,
2828 decoder: &mut fidl::encoding::Decoder<'_, D>,
2829 offset: usize,
2830 _depth: fidl::encoding::Depth,
2831 ) -> fidl::Result<()> {
2832 decoder.debug_check_bounds::<Self>(offset);
2833 fidl::decode!(
2835 fidl::encoding::BoundedString<4096>,
2836 D,
2837 &mut self.url,
2838 decoder,
2839 offset + 0,
2840 _depth
2841 )?;
2842 Ok(())
2843 }
2844 }
2845
2846 impl fidl::encoding::ValueTypeMarker for RepositoryIteratorNextResponse {
2847 type Borrowed<'a> = &'a Self;
2848 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2849 value
2850 }
2851 }
2852
2853 unsafe impl fidl::encoding::TypeMarker for RepositoryIteratorNextResponse {
2854 type Owned = Self;
2855
2856 #[inline(always)]
2857 fn inline_align(_context: fidl::encoding::Context) -> usize {
2858 8
2859 }
2860
2861 #[inline(always)]
2862 fn inline_size(_context: fidl::encoding::Context) -> usize {
2863 16
2864 }
2865 }
2866
2867 unsafe impl<D: fidl::encoding::ResourceDialect>
2868 fidl::encoding::Encode<RepositoryIteratorNextResponse, D>
2869 for &RepositoryIteratorNextResponse
2870 {
2871 #[inline]
2872 unsafe fn encode(
2873 self,
2874 encoder: &mut fidl::encoding::Encoder<'_, D>,
2875 offset: usize,
2876 _depth: fidl::encoding::Depth,
2877 ) -> fidl::Result<()> {
2878 encoder.debug_check_bounds::<RepositoryIteratorNextResponse>(offset);
2879 fidl::encoding::Encode::<RepositoryIteratorNextResponse, D>::encode(
2881 (
2882 <fidl::encoding::UnboundedVector<RepositoryConfig> as fidl::encoding::ValueTypeMarker>::borrow(&self.repos),
2883 ),
2884 encoder, offset, _depth
2885 )
2886 }
2887 }
2888 unsafe impl<
2889 D: fidl::encoding::ResourceDialect,
2890 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RepositoryConfig>, D>,
2891 > fidl::encoding::Encode<RepositoryIteratorNextResponse, D> for (T0,)
2892 {
2893 #[inline]
2894 unsafe fn encode(
2895 self,
2896 encoder: &mut fidl::encoding::Encoder<'_, D>,
2897 offset: usize,
2898 depth: fidl::encoding::Depth,
2899 ) -> fidl::Result<()> {
2900 encoder.debug_check_bounds::<RepositoryIteratorNextResponse>(offset);
2901 self.0.encode(encoder, offset + 0, depth)?;
2905 Ok(())
2906 }
2907 }
2908
2909 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2910 for RepositoryIteratorNextResponse
2911 {
2912 #[inline(always)]
2913 fn new_empty() -> Self {
2914 Self { repos: fidl::new_empty!(fidl::encoding::UnboundedVector<RepositoryConfig>, D) }
2915 }
2916
2917 #[inline]
2918 unsafe fn decode(
2919 &mut self,
2920 decoder: &mut fidl::encoding::Decoder<'_, D>,
2921 offset: usize,
2922 _depth: fidl::encoding::Depth,
2923 ) -> fidl::Result<()> {
2924 decoder.debug_check_bounds::<Self>(offset);
2925 fidl::decode!(
2927 fidl::encoding::UnboundedVector<RepositoryConfig>,
2928 D,
2929 &mut self.repos,
2930 decoder,
2931 offset + 0,
2932 _depth
2933 )?;
2934 Ok(())
2935 }
2936 }
2937
2938 impl fidl::encoding::ValueTypeMarker for RepositoryManagerAddMirrorRequest {
2939 type Borrowed<'a> = &'a Self;
2940 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2941 value
2942 }
2943 }
2944
2945 unsafe impl fidl::encoding::TypeMarker for RepositoryManagerAddMirrorRequest {
2946 type Owned = Self;
2947
2948 #[inline(always)]
2949 fn inline_align(_context: fidl::encoding::Context) -> usize {
2950 8
2951 }
2952
2953 #[inline(always)]
2954 fn inline_size(_context: fidl::encoding::Context) -> usize {
2955 32
2956 }
2957 }
2958
2959 unsafe impl<D: fidl::encoding::ResourceDialect>
2960 fidl::encoding::Encode<RepositoryManagerAddMirrorRequest, D>
2961 for &RepositoryManagerAddMirrorRequest
2962 {
2963 #[inline]
2964 unsafe fn encode(
2965 self,
2966 encoder: &mut fidl::encoding::Encoder<'_, D>,
2967 offset: usize,
2968 _depth: fidl::encoding::Depth,
2969 ) -> fidl::Result<()> {
2970 encoder.debug_check_bounds::<RepositoryManagerAddMirrorRequest>(offset);
2971 fidl::encoding::Encode::<RepositoryManagerAddMirrorRequest, D>::encode(
2973 (
2974 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
2975 &self.repo_url,
2976 ),
2977 <MirrorConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.mirror),
2978 ),
2979 encoder,
2980 offset,
2981 _depth,
2982 )
2983 }
2984 }
2985 unsafe impl<
2986 D: fidl::encoding::ResourceDialect,
2987 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
2988 T1: fidl::encoding::Encode<MirrorConfig, D>,
2989 > fidl::encoding::Encode<RepositoryManagerAddMirrorRequest, D> for (T0, T1)
2990 {
2991 #[inline]
2992 unsafe fn encode(
2993 self,
2994 encoder: &mut fidl::encoding::Encoder<'_, D>,
2995 offset: usize,
2996 depth: fidl::encoding::Depth,
2997 ) -> fidl::Result<()> {
2998 encoder.debug_check_bounds::<RepositoryManagerAddMirrorRequest>(offset);
2999 self.0.encode(encoder, offset + 0, depth)?;
3003 self.1.encode(encoder, offset + 16, depth)?;
3004 Ok(())
3005 }
3006 }
3007
3008 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3009 for RepositoryManagerAddMirrorRequest
3010 {
3011 #[inline(always)]
3012 fn new_empty() -> Self {
3013 Self {
3014 repo_url: fidl::new_empty!(fidl::encoding::UnboundedString, D),
3015 mirror: fidl::new_empty!(MirrorConfig, D),
3016 }
3017 }
3018
3019 #[inline]
3020 unsafe fn decode(
3021 &mut self,
3022 decoder: &mut fidl::encoding::Decoder<'_, D>,
3023 offset: usize,
3024 _depth: fidl::encoding::Depth,
3025 ) -> fidl::Result<()> {
3026 decoder.debug_check_bounds::<Self>(offset);
3027 fidl::decode!(
3029 fidl::encoding::UnboundedString,
3030 D,
3031 &mut self.repo_url,
3032 decoder,
3033 offset + 0,
3034 _depth
3035 )?;
3036 fidl::decode!(MirrorConfig, D, &mut self.mirror, decoder, offset + 16, _depth)?;
3037 Ok(())
3038 }
3039 }
3040
3041 impl fidl::encoding::ValueTypeMarker for RepositoryManagerAddRequest {
3042 type Borrowed<'a> = &'a Self;
3043 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3044 value
3045 }
3046 }
3047
3048 unsafe impl fidl::encoding::TypeMarker for RepositoryManagerAddRequest {
3049 type Owned = Self;
3050
3051 #[inline(always)]
3052 fn inline_align(_context: fidl::encoding::Context) -> usize {
3053 8
3054 }
3055
3056 #[inline(always)]
3057 fn inline_size(_context: fidl::encoding::Context) -> usize {
3058 16
3059 }
3060 }
3061
3062 unsafe impl<D: fidl::encoding::ResourceDialect>
3063 fidl::encoding::Encode<RepositoryManagerAddRequest, D> for &RepositoryManagerAddRequest
3064 {
3065 #[inline]
3066 unsafe fn encode(
3067 self,
3068 encoder: &mut fidl::encoding::Encoder<'_, D>,
3069 offset: usize,
3070 _depth: fidl::encoding::Depth,
3071 ) -> fidl::Result<()> {
3072 encoder.debug_check_bounds::<RepositoryManagerAddRequest>(offset);
3073 fidl::encoding::Encode::<RepositoryManagerAddRequest, D>::encode(
3075 (<RepositoryConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.repo),),
3076 encoder,
3077 offset,
3078 _depth,
3079 )
3080 }
3081 }
3082 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RepositoryConfig, D>>
3083 fidl::encoding::Encode<RepositoryManagerAddRequest, D> for (T0,)
3084 {
3085 #[inline]
3086 unsafe fn encode(
3087 self,
3088 encoder: &mut fidl::encoding::Encoder<'_, D>,
3089 offset: usize,
3090 depth: fidl::encoding::Depth,
3091 ) -> fidl::Result<()> {
3092 encoder.debug_check_bounds::<RepositoryManagerAddRequest>(offset);
3093 self.0.encode(encoder, offset + 0, depth)?;
3097 Ok(())
3098 }
3099 }
3100
3101 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3102 for RepositoryManagerAddRequest
3103 {
3104 #[inline(always)]
3105 fn new_empty() -> Self {
3106 Self { repo: fidl::new_empty!(RepositoryConfig, D) }
3107 }
3108
3109 #[inline]
3110 unsafe fn decode(
3111 &mut self,
3112 decoder: &mut fidl::encoding::Decoder<'_, D>,
3113 offset: usize,
3114 _depth: fidl::encoding::Depth,
3115 ) -> fidl::Result<()> {
3116 decoder.debug_check_bounds::<Self>(offset);
3117 fidl::decode!(RepositoryConfig, D, &mut self.repo, decoder, offset + 0, _depth)?;
3119 Ok(())
3120 }
3121 }
3122
3123 impl fidl::encoding::ValueTypeMarker for RepositoryManagerRemoveMirrorRequest {
3124 type Borrowed<'a> = &'a Self;
3125 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3126 value
3127 }
3128 }
3129
3130 unsafe impl fidl::encoding::TypeMarker for RepositoryManagerRemoveMirrorRequest {
3131 type Owned = Self;
3132
3133 #[inline(always)]
3134 fn inline_align(_context: fidl::encoding::Context) -> usize {
3135 8
3136 }
3137
3138 #[inline(always)]
3139 fn inline_size(_context: fidl::encoding::Context) -> usize {
3140 32
3141 }
3142 }
3143
3144 unsafe impl<D: fidl::encoding::ResourceDialect>
3145 fidl::encoding::Encode<RepositoryManagerRemoveMirrorRequest, D>
3146 for &RepositoryManagerRemoveMirrorRequest
3147 {
3148 #[inline]
3149 unsafe fn encode(
3150 self,
3151 encoder: &mut fidl::encoding::Encoder<'_, D>,
3152 offset: usize,
3153 _depth: fidl::encoding::Depth,
3154 ) -> fidl::Result<()> {
3155 encoder.debug_check_bounds::<RepositoryManagerRemoveMirrorRequest>(offset);
3156 fidl::encoding::Encode::<RepositoryManagerRemoveMirrorRequest, D>::encode(
3158 (
3159 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
3160 &self.repo_url,
3161 ),
3162 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
3163 &self.mirror_url,
3164 ),
3165 ),
3166 encoder,
3167 offset,
3168 _depth,
3169 )
3170 }
3171 }
3172 unsafe impl<
3173 D: fidl::encoding::ResourceDialect,
3174 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
3175 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
3176 > fidl::encoding::Encode<RepositoryManagerRemoveMirrorRequest, D> for (T0, T1)
3177 {
3178 #[inline]
3179 unsafe fn encode(
3180 self,
3181 encoder: &mut fidl::encoding::Encoder<'_, D>,
3182 offset: usize,
3183 depth: fidl::encoding::Depth,
3184 ) -> fidl::Result<()> {
3185 encoder.debug_check_bounds::<RepositoryManagerRemoveMirrorRequest>(offset);
3186 self.0.encode(encoder, offset + 0, depth)?;
3190 self.1.encode(encoder, offset + 16, depth)?;
3191 Ok(())
3192 }
3193 }
3194
3195 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3196 for RepositoryManagerRemoveMirrorRequest
3197 {
3198 #[inline(always)]
3199 fn new_empty() -> Self {
3200 Self {
3201 repo_url: fidl::new_empty!(fidl::encoding::UnboundedString, D),
3202 mirror_url: fidl::new_empty!(fidl::encoding::UnboundedString, D),
3203 }
3204 }
3205
3206 #[inline]
3207 unsafe fn decode(
3208 &mut self,
3209 decoder: &mut fidl::encoding::Decoder<'_, D>,
3210 offset: usize,
3211 _depth: fidl::encoding::Depth,
3212 ) -> fidl::Result<()> {
3213 decoder.debug_check_bounds::<Self>(offset);
3214 fidl::decode!(
3216 fidl::encoding::UnboundedString,
3217 D,
3218 &mut self.repo_url,
3219 decoder,
3220 offset + 0,
3221 _depth
3222 )?;
3223 fidl::decode!(
3224 fidl::encoding::UnboundedString,
3225 D,
3226 &mut self.mirror_url,
3227 decoder,
3228 offset + 16,
3229 _depth
3230 )?;
3231 Ok(())
3232 }
3233 }
3234
3235 impl fidl::encoding::ValueTypeMarker for RepositoryManagerRemoveRequest {
3236 type Borrowed<'a> = &'a Self;
3237 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3238 value
3239 }
3240 }
3241
3242 unsafe impl fidl::encoding::TypeMarker for RepositoryManagerRemoveRequest {
3243 type Owned = Self;
3244
3245 #[inline(always)]
3246 fn inline_align(_context: fidl::encoding::Context) -> usize {
3247 8
3248 }
3249
3250 #[inline(always)]
3251 fn inline_size(_context: fidl::encoding::Context) -> usize {
3252 16
3253 }
3254 }
3255
3256 unsafe impl<D: fidl::encoding::ResourceDialect>
3257 fidl::encoding::Encode<RepositoryManagerRemoveRequest, D>
3258 for &RepositoryManagerRemoveRequest
3259 {
3260 #[inline]
3261 unsafe fn encode(
3262 self,
3263 encoder: &mut fidl::encoding::Encoder<'_, D>,
3264 offset: usize,
3265 _depth: fidl::encoding::Depth,
3266 ) -> fidl::Result<()> {
3267 encoder.debug_check_bounds::<RepositoryManagerRemoveRequest>(offset);
3268 fidl::encoding::Encode::<RepositoryManagerRemoveRequest, D>::encode(
3270 (<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
3271 &self.repo_url,
3272 ),),
3273 encoder,
3274 offset,
3275 _depth,
3276 )
3277 }
3278 }
3279 unsafe impl<
3280 D: fidl::encoding::ResourceDialect,
3281 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
3282 > fidl::encoding::Encode<RepositoryManagerRemoveRequest, D> for (T0,)
3283 {
3284 #[inline]
3285 unsafe fn encode(
3286 self,
3287 encoder: &mut fidl::encoding::Encoder<'_, D>,
3288 offset: usize,
3289 depth: fidl::encoding::Depth,
3290 ) -> fidl::Result<()> {
3291 encoder.debug_check_bounds::<RepositoryManagerRemoveRequest>(offset);
3292 self.0.encode(encoder, offset + 0, depth)?;
3296 Ok(())
3297 }
3298 }
3299
3300 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3301 for RepositoryManagerRemoveRequest
3302 {
3303 #[inline(always)]
3304 fn new_empty() -> Self {
3305 Self { repo_url: fidl::new_empty!(fidl::encoding::UnboundedString, D) }
3306 }
3307
3308 #[inline]
3309 unsafe fn decode(
3310 &mut self,
3311 decoder: &mut fidl::encoding::Decoder<'_, D>,
3312 offset: usize,
3313 _depth: fidl::encoding::Depth,
3314 ) -> fidl::Result<()> {
3315 decoder.debug_check_bounds::<Self>(offset);
3316 fidl::decode!(
3318 fidl::encoding::UnboundedString,
3319 D,
3320 &mut self.repo_url,
3321 decoder,
3322 offset + 0,
3323 _depth
3324 )?;
3325 Ok(())
3326 }
3327 }
3328
3329 impl fidl::encoding::ValueTypeMarker for RepositoryUrl {
3330 type Borrowed<'a> = &'a Self;
3331 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3332 value
3333 }
3334 }
3335
3336 unsafe impl fidl::encoding::TypeMarker for RepositoryUrl {
3337 type Owned = Self;
3338
3339 #[inline(always)]
3340 fn inline_align(_context: fidl::encoding::Context) -> usize {
3341 8
3342 }
3343
3344 #[inline(always)]
3345 fn inline_size(_context: fidl::encoding::Context) -> usize {
3346 16
3347 }
3348 }
3349
3350 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RepositoryUrl, D>
3351 for &RepositoryUrl
3352 {
3353 #[inline]
3354 unsafe fn encode(
3355 self,
3356 encoder: &mut fidl::encoding::Encoder<'_, D>,
3357 offset: usize,
3358 _depth: fidl::encoding::Depth,
3359 ) -> fidl::Result<()> {
3360 encoder.debug_check_bounds::<RepositoryUrl>(offset);
3361 fidl::encoding::Encode::<RepositoryUrl, D>::encode(
3363 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3364 &self.url,
3365 ),),
3366 encoder,
3367 offset,
3368 _depth,
3369 )
3370 }
3371 }
3372 unsafe impl<
3373 D: fidl::encoding::ResourceDialect,
3374 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3375 > fidl::encoding::Encode<RepositoryUrl, D> for (T0,)
3376 {
3377 #[inline]
3378 unsafe fn encode(
3379 self,
3380 encoder: &mut fidl::encoding::Encoder<'_, D>,
3381 offset: usize,
3382 depth: fidl::encoding::Depth,
3383 ) -> fidl::Result<()> {
3384 encoder.debug_check_bounds::<RepositoryUrl>(offset);
3385 self.0.encode(encoder, offset + 0, depth)?;
3389 Ok(())
3390 }
3391 }
3392
3393 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryUrl {
3394 #[inline(always)]
3395 fn new_empty() -> Self {
3396 Self { url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3397 }
3398
3399 #[inline]
3400 unsafe fn decode(
3401 &mut self,
3402 decoder: &mut fidl::encoding::Decoder<'_, D>,
3403 offset: usize,
3404 _depth: fidl::encoding::Depth,
3405 ) -> fidl::Result<()> {
3406 decoder.debug_check_bounds::<Self>(offset);
3407 fidl::decode!(
3409 fidl::encoding::BoundedString<4096>,
3410 D,
3411 &mut self.url,
3412 decoder,
3413 offset + 0,
3414 _depth
3415 )?;
3416 Ok(())
3417 }
3418 }
3419
3420 impl fidl::encoding::ValueTypeMarker for ResolutionContext {
3421 type Borrowed<'a> = &'a Self;
3422 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3423 value
3424 }
3425 }
3426
3427 unsafe impl fidl::encoding::TypeMarker for ResolutionContext {
3428 type Owned = Self;
3429
3430 #[inline(always)]
3431 fn inline_align(_context: fidl::encoding::Context) -> usize {
3432 8
3433 }
3434
3435 #[inline(always)]
3436 fn inline_size(_context: fidl::encoding::Context) -> usize {
3437 16
3438 }
3439 }
3440
3441 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolutionContext, D>
3442 for &ResolutionContext
3443 {
3444 #[inline]
3445 unsafe fn encode(
3446 self,
3447 encoder: &mut fidl::encoding::Encoder<'_, D>,
3448 offset: usize,
3449 _depth: fidl::encoding::Depth,
3450 ) -> fidl::Result<()> {
3451 encoder.debug_check_bounds::<ResolutionContext>(offset);
3452 fidl::encoding::Encode::<ResolutionContext, D>::encode(
3454 (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
3455 &self.bytes,
3456 ),),
3457 encoder,
3458 offset,
3459 _depth,
3460 )
3461 }
3462 }
3463 unsafe impl<
3464 D: fidl::encoding::ResourceDialect,
3465 T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
3466 > fidl::encoding::Encode<ResolutionContext, D> for (T0,)
3467 {
3468 #[inline]
3469 unsafe fn encode(
3470 self,
3471 encoder: &mut fidl::encoding::Encoder<'_, D>,
3472 offset: usize,
3473 depth: fidl::encoding::Depth,
3474 ) -> fidl::Result<()> {
3475 encoder.debug_check_bounds::<ResolutionContext>(offset);
3476 self.0.encode(encoder, offset + 0, depth)?;
3480 Ok(())
3481 }
3482 }
3483
3484 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolutionContext {
3485 #[inline(always)]
3486 fn new_empty() -> Self {
3487 Self { bytes: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
3488 }
3489
3490 #[inline]
3491 unsafe fn decode(
3492 &mut self,
3493 decoder: &mut fidl::encoding::Decoder<'_, D>,
3494 offset: usize,
3495 _depth: fidl::encoding::Depth,
3496 ) -> fidl::Result<()> {
3497 decoder.debug_check_bounds::<Self>(offset);
3498 fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.bytes, decoder, offset + 0, _depth)?;
3500 Ok(())
3501 }
3502 }
3503
3504 impl CupData {
3505 #[inline(always)]
3506 fn max_ordinal_present(&self) -> u64 {
3507 if let Some(_) = self.signature {
3508 return 5;
3509 }
3510 if let Some(_) = self.response {
3511 return 4;
3512 }
3513 if let Some(_) = self.nonce {
3514 return 3;
3515 }
3516 if let Some(_) = self.key_id {
3517 return 2;
3518 }
3519 if let Some(_) = self.request {
3520 return 1;
3521 }
3522 0
3523 }
3524 }
3525
3526 impl fidl::encoding::ValueTypeMarker for CupData {
3527 type Borrowed<'a> = &'a Self;
3528 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3529 value
3530 }
3531 }
3532
3533 unsafe impl fidl::encoding::TypeMarker for CupData {
3534 type Owned = Self;
3535
3536 #[inline(always)]
3537 fn inline_align(_context: fidl::encoding::Context) -> usize {
3538 8
3539 }
3540
3541 #[inline(always)]
3542 fn inline_size(_context: fidl::encoding::Context) -> usize {
3543 16
3544 }
3545 }
3546
3547 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupData, D> for &CupData {
3548 unsafe fn encode(
3549 self,
3550 encoder: &mut fidl::encoding::Encoder<'_, D>,
3551 offset: usize,
3552 mut depth: fidl::encoding::Depth,
3553 ) -> fidl::Result<()> {
3554 encoder.debug_check_bounds::<CupData>(offset);
3555 let max_ordinal: u64 = self.max_ordinal_present();
3557 encoder.write_num(max_ordinal, offset);
3558 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3559 if max_ordinal == 0 {
3561 return Ok(());
3562 }
3563 depth.increment()?;
3564 let envelope_size = 8;
3565 let bytes_len = max_ordinal as usize * envelope_size;
3566 #[allow(unused_variables)]
3567 let offset = encoder.out_of_line_offset(bytes_len);
3568 let mut _prev_end_offset: usize = 0;
3569 if 1 > max_ordinal {
3570 return Ok(());
3571 }
3572
3573 let cur_offset: usize = (1 - 1) * envelope_size;
3576
3577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3579
3580 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 65536>, D>(
3585 self.request.as_ref().map(
3586 <fidl::encoding::Vector<u8, 65536> as fidl::encoding::ValueTypeMarker>::borrow,
3587 ),
3588 encoder,
3589 offset + cur_offset,
3590 depth,
3591 )?;
3592
3593 _prev_end_offset = cur_offset + envelope_size;
3594 if 2 > max_ordinal {
3595 return Ok(());
3596 }
3597
3598 let cur_offset: usize = (2 - 1) * envelope_size;
3601
3602 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3604
3605 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3610 self.key_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3611 encoder,
3612 offset + cur_offset,
3613 depth,
3614 )?;
3615
3616 _prev_end_offset = cur_offset + envelope_size;
3617 if 3 > max_ordinal {
3618 return Ok(());
3619 }
3620
3621 let cur_offset: usize = (3 - 1) * envelope_size;
3624
3625 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3627
3628 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 32>, D>(
3633 self.nonce.as_ref().map(
3634 <fidl::encoding::Array<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
3635 ),
3636 encoder,
3637 offset + cur_offset,
3638 depth,
3639 )?;
3640
3641 _prev_end_offset = cur_offset + envelope_size;
3642 if 4 > max_ordinal {
3643 return Ok(());
3644 }
3645
3646 let cur_offset: usize = (4 - 1) * envelope_size;
3649
3650 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3652
3653 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 65536>, D>(
3658 self.response.as_ref().map(
3659 <fidl::encoding::Vector<u8, 65536> as fidl::encoding::ValueTypeMarker>::borrow,
3660 ),
3661 encoder,
3662 offset + cur_offset,
3663 depth,
3664 )?;
3665
3666 _prev_end_offset = cur_offset + envelope_size;
3667 if 5 > max_ordinal {
3668 return Ok(());
3669 }
3670
3671 let cur_offset: usize = (5 - 1) * envelope_size;
3674
3675 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3677
3678 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 72>, D>(
3683 self.signature.as_ref().map(
3684 <fidl::encoding::Vector<u8, 72> as fidl::encoding::ValueTypeMarker>::borrow,
3685 ),
3686 encoder,
3687 offset + cur_offset,
3688 depth,
3689 )?;
3690
3691 _prev_end_offset = cur_offset + envelope_size;
3692
3693 Ok(())
3694 }
3695 }
3696
3697 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupData {
3698 #[inline(always)]
3699 fn new_empty() -> Self {
3700 Self::default()
3701 }
3702
3703 unsafe fn decode(
3704 &mut self,
3705 decoder: &mut fidl::encoding::Decoder<'_, D>,
3706 offset: usize,
3707 mut depth: fidl::encoding::Depth,
3708 ) -> fidl::Result<()> {
3709 decoder.debug_check_bounds::<Self>(offset);
3710 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3711 None => return Err(fidl::Error::NotNullable),
3712 Some(len) => len,
3713 };
3714 if len == 0 {
3716 return Ok(());
3717 };
3718 depth.increment()?;
3719 let envelope_size = 8;
3720 let bytes_len = len * envelope_size;
3721 let offset = decoder.out_of_line_offset(bytes_len)?;
3722 let mut _next_ordinal_to_read = 0;
3724 let mut next_offset = offset;
3725 let end_offset = offset + bytes_len;
3726 _next_ordinal_to_read += 1;
3727 if next_offset >= end_offset {
3728 return Ok(());
3729 }
3730
3731 while _next_ordinal_to_read < 1 {
3733 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3734 _next_ordinal_to_read += 1;
3735 next_offset += envelope_size;
3736 }
3737
3738 let next_out_of_line = decoder.next_out_of_line();
3739 let handles_before = decoder.remaining_handles();
3740 if let Some((inlined, num_bytes, num_handles)) =
3741 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3742 {
3743 let member_inline_size =
3744 <fidl::encoding::Vector<u8, 65536> as fidl::encoding::TypeMarker>::inline_size(
3745 decoder.context,
3746 );
3747 if inlined != (member_inline_size <= 4) {
3748 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3749 }
3750 let inner_offset;
3751 let mut inner_depth = depth.clone();
3752 if inlined {
3753 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3754 inner_offset = next_offset;
3755 } else {
3756 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3757 inner_depth.increment()?;
3758 }
3759 let val_ref = self
3760 .request
3761 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 65536>, D));
3762 fidl::decode!(fidl::encoding::Vector<u8, 65536>, D, val_ref, decoder, inner_offset, inner_depth)?;
3763 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3764 {
3765 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3766 }
3767 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3768 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3769 }
3770 }
3771
3772 next_offset += envelope_size;
3773 _next_ordinal_to_read += 1;
3774 if next_offset >= end_offset {
3775 return Ok(());
3776 }
3777
3778 while _next_ordinal_to_read < 2 {
3780 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3781 _next_ordinal_to_read += 1;
3782 next_offset += envelope_size;
3783 }
3784
3785 let next_out_of_line = decoder.next_out_of_line();
3786 let handles_before = decoder.remaining_handles();
3787 if let Some((inlined, num_bytes, num_handles)) =
3788 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3789 {
3790 let member_inline_size =
3791 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3792 if inlined != (member_inline_size <= 4) {
3793 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3794 }
3795 let inner_offset;
3796 let mut inner_depth = depth.clone();
3797 if inlined {
3798 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3799 inner_offset = next_offset;
3800 } else {
3801 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3802 inner_depth.increment()?;
3803 }
3804 let val_ref = self.key_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3805 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3806 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3807 {
3808 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3809 }
3810 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3811 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3812 }
3813 }
3814
3815 next_offset += envelope_size;
3816 _next_ordinal_to_read += 1;
3817 if next_offset >= end_offset {
3818 return Ok(());
3819 }
3820
3821 while _next_ordinal_to_read < 3 {
3823 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3824 _next_ordinal_to_read += 1;
3825 next_offset += envelope_size;
3826 }
3827
3828 let next_out_of_line = decoder.next_out_of_line();
3829 let handles_before = decoder.remaining_handles();
3830 if let Some((inlined, num_bytes, num_handles)) =
3831 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3832 {
3833 let member_inline_size =
3834 <fidl::encoding::Array<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
3835 decoder.context,
3836 );
3837 if inlined != (member_inline_size <= 4) {
3838 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3839 }
3840 let inner_offset;
3841 let mut inner_depth = depth.clone();
3842 if inlined {
3843 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3844 inner_offset = next_offset;
3845 } else {
3846 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3847 inner_depth.increment()?;
3848 }
3849 let val_ref = self
3850 .nonce
3851 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 32>, D));
3852 fidl::decode!(fidl::encoding::Array<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3853 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3854 {
3855 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3856 }
3857 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3858 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3859 }
3860 }
3861
3862 next_offset += envelope_size;
3863 _next_ordinal_to_read += 1;
3864 if next_offset >= end_offset {
3865 return Ok(());
3866 }
3867
3868 while _next_ordinal_to_read < 4 {
3870 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3871 _next_ordinal_to_read += 1;
3872 next_offset += envelope_size;
3873 }
3874
3875 let next_out_of_line = decoder.next_out_of_line();
3876 let handles_before = decoder.remaining_handles();
3877 if let Some((inlined, num_bytes, num_handles)) =
3878 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3879 {
3880 let member_inline_size =
3881 <fidl::encoding::Vector<u8, 65536> as fidl::encoding::TypeMarker>::inline_size(
3882 decoder.context,
3883 );
3884 if inlined != (member_inline_size <= 4) {
3885 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3886 }
3887 let inner_offset;
3888 let mut inner_depth = depth.clone();
3889 if inlined {
3890 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3891 inner_offset = next_offset;
3892 } else {
3893 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3894 inner_depth.increment()?;
3895 }
3896 let val_ref = self
3897 .response
3898 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 65536>, D));
3899 fidl::decode!(fidl::encoding::Vector<u8, 65536>, D, val_ref, decoder, inner_offset, inner_depth)?;
3900 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3901 {
3902 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3903 }
3904 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3905 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3906 }
3907 }
3908
3909 next_offset += envelope_size;
3910 _next_ordinal_to_read += 1;
3911 if next_offset >= end_offset {
3912 return Ok(());
3913 }
3914
3915 while _next_ordinal_to_read < 5 {
3917 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3918 _next_ordinal_to_read += 1;
3919 next_offset += envelope_size;
3920 }
3921
3922 let next_out_of_line = decoder.next_out_of_line();
3923 let handles_before = decoder.remaining_handles();
3924 if let Some((inlined, num_bytes, num_handles)) =
3925 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3926 {
3927 let member_inline_size =
3928 <fidl::encoding::Vector<u8, 72> as fidl::encoding::TypeMarker>::inline_size(
3929 decoder.context,
3930 );
3931 if inlined != (member_inline_size <= 4) {
3932 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3933 }
3934 let inner_offset;
3935 let mut inner_depth = depth.clone();
3936 if inlined {
3937 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3938 inner_offset = next_offset;
3939 } else {
3940 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3941 inner_depth.increment()?;
3942 }
3943 let val_ref = self
3944 .signature
3945 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 72>, D));
3946 fidl::decode!(fidl::encoding::Vector<u8, 72>, D, val_ref, decoder, inner_offset, inner_depth)?;
3947 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3948 {
3949 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3950 }
3951 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3952 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3953 }
3954 }
3955
3956 next_offset += envelope_size;
3957
3958 while next_offset < end_offset {
3960 _next_ordinal_to_read += 1;
3961 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3962 next_offset += envelope_size;
3963 }
3964
3965 Ok(())
3966 }
3967 }
3968
3969 impl MirrorConfig {
3970 #[inline(always)]
3971 fn max_ordinal_present(&self) -> u64 {
3972 if let Some(_) = self.blob_mirror_url {
3973 return 4;
3974 }
3975 if let Some(_) = self.subscribe {
3976 return 2;
3977 }
3978 if let Some(_) = self.mirror_url {
3979 return 1;
3980 }
3981 0
3982 }
3983 }
3984
3985 impl fidl::encoding::ValueTypeMarker for MirrorConfig {
3986 type Borrowed<'a> = &'a Self;
3987 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3988 value
3989 }
3990 }
3991
3992 unsafe impl fidl::encoding::TypeMarker for MirrorConfig {
3993 type Owned = Self;
3994
3995 #[inline(always)]
3996 fn inline_align(_context: fidl::encoding::Context) -> usize {
3997 8
3998 }
3999
4000 #[inline(always)]
4001 fn inline_size(_context: fidl::encoding::Context) -> usize {
4002 16
4003 }
4004 }
4005
4006 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MirrorConfig, D>
4007 for &MirrorConfig
4008 {
4009 unsafe fn encode(
4010 self,
4011 encoder: &mut fidl::encoding::Encoder<'_, D>,
4012 offset: usize,
4013 mut depth: fidl::encoding::Depth,
4014 ) -> fidl::Result<()> {
4015 encoder.debug_check_bounds::<MirrorConfig>(offset);
4016 let max_ordinal: u64 = self.max_ordinal_present();
4018 encoder.write_num(max_ordinal, offset);
4019 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4020 if max_ordinal == 0 {
4022 return Ok(());
4023 }
4024 depth.increment()?;
4025 let envelope_size = 8;
4026 let bytes_len = max_ordinal as usize * envelope_size;
4027 #[allow(unused_variables)]
4028 let offset = encoder.out_of_line_offset(bytes_len);
4029 let mut _prev_end_offset: usize = 0;
4030 if 1 > max_ordinal {
4031 return Ok(());
4032 }
4033
4034 let cur_offset: usize = (1 - 1) * envelope_size;
4037
4038 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4040
4041 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4046 self.mirror_url.as_ref().map(
4047 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4048 ),
4049 encoder,
4050 offset + cur_offset,
4051 depth,
4052 )?;
4053
4054 _prev_end_offset = cur_offset + envelope_size;
4055 if 2 > max_ordinal {
4056 return Ok(());
4057 }
4058
4059 let cur_offset: usize = (2 - 1) * envelope_size;
4062
4063 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4065
4066 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4071 self.subscribe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4072 encoder,
4073 offset + cur_offset,
4074 depth,
4075 )?;
4076
4077 _prev_end_offset = cur_offset + envelope_size;
4078 if 4 > max_ordinal {
4079 return Ok(());
4080 }
4081
4082 let cur_offset: usize = (4 - 1) * envelope_size;
4085
4086 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4088
4089 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4094 self.blob_mirror_url.as_ref().map(
4095 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4096 ),
4097 encoder,
4098 offset + cur_offset,
4099 depth,
4100 )?;
4101
4102 _prev_end_offset = cur_offset + envelope_size;
4103
4104 Ok(())
4105 }
4106 }
4107
4108 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MirrorConfig {
4109 #[inline(always)]
4110 fn new_empty() -> Self {
4111 Self::default()
4112 }
4113
4114 unsafe fn decode(
4115 &mut self,
4116 decoder: &mut fidl::encoding::Decoder<'_, D>,
4117 offset: usize,
4118 mut depth: fidl::encoding::Depth,
4119 ) -> fidl::Result<()> {
4120 decoder.debug_check_bounds::<Self>(offset);
4121 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4122 None => return Err(fidl::Error::NotNullable),
4123 Some(len) => len,
4124 };
4125 if len == 0 {
4127 return Ok(());
4128 };
4129 depth.increment()?;
4130 let envelope_size = 8;
4131 let bytes_len = len * envelope_size;
4132 let offset = decoder.out_of_line_offset(bytes_len)?;
4133 let mut _next_ordinal_to_read = 0;
4135 let mut next_offset = offset;
4136 let end_offset = offset + bytes_len;
4137 _next_ordinal_to_read += 1;
4138 if next_offset >= end_offset {
4139 return Ok(());
4140 }
4141
4142 while _next_ordinal_to_read < 1 {
4144 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4145 _next_ordinal_to_read += 1;
4146 next_offset += envelope_size;
4147 }
4148
4149 let next_out_of_line = decoder.next_out_of_line();
4150 let handles_before = decoder.remaining_handles();
4151 if let Some((inlined, num_bytes, num_handles)) =
4152 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4153 {
4154 let member_inline_size =
4155 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4156 decoder.context,
4157 );
4158 if inlined != (member_inline_size <= 4) {
4159 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4160 }
4161 let inner_offset;
4162 let mut inner_depth = depth.clone();
4163 if inlined {
4164 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4165 inner_offset = next_offset;
4166 } else {
4167 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4168 inner_depth.increment()?;
4169 }
4170 let val_ref = self
4171 .mirror_url
4172 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4173 fidl::decode!(
4174 fidl::encoding::UnboundedString,
4175 D,
4176 val_ref,
4177 decoder,
4178 inner_offset,
4179 inner_depth
4180 )?;
4181 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4182 {
4183 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4184 }
4185 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4186 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4187 }
4188 }
4189
4190 next_offset += envelope_size;
4191 _next_ordinal_to_read += 1;
4192 if next_offset >= end_offset {
4193 return Ok(());
4194 }
4195
4196 while _next_ordinal_to_read < 2 {
4198 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4199 _next_ordinal_to_read += 1;
4200 next_offset += envelope_size;
4201 }
4202
4203 let next_out_of_line = decoder.next_out_of_line();
4204 let handles_before = decoder.remaining_handles();
4205 if let Some((inlined, num_bytes, num_handles)) =
4206 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4207 {
4208 let member_inline_size =
4209 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4210 if inlined != (member_inline_size <= 4) {
4211 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4212 }
4213 let inner_offset;
4214 let mut inner_depth = depth.clone();
4215 if inlined {
4216 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4217 inner_offset = next_offset;
4218 } else {
4219 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4220 inner_depth.increment()?;
4221 }
4222 let val_ref = self.subscribe.get_or_insert_with(|| fidl::new_empty!(bool, D));
4223 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4225 {
4226 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4227 }
4228 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4229 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4230 }
4231 }
4232
4233 next_offset += envelope_size;
4234 _next_ordinal_to_read += 1;
4235 if next_offset >= end_offset {
4236 return Ok(());
4237 }
4238
4239 while _next_ordinal_to_read < 4 {
4241 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4242 _next_ordinal_to_read += 1;
4243 next_offset += envelope_size;
4244 }
4245
4246 let next_out_of_line = decoder.next_out_of_line();
4247 let handles_before = decoder.remaining_handles();
4248 if let Some((inlined, num_bytes, num_handles)) =
4249 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4250 {
4251 let member_inline_size =
4252 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4253 decoder.context,
4254 );
4255 if inlined != (member_inline_size <= 4) {
4256 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4257 }
4258 let inner_offset;
4259 let mut inner_depth = depth.clone();
4260 if inlined {
4261 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4262 inner_offset = next_offset;
4263 } else {
4264 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4265 inner_depth.increment()?;
4266 }
4267 let val_ref = self
4268 .blob_mirror_url
4269 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4270 fidl::decode!(
4271 fidl::encoding::UnboundedString,
4272 D,
4273 val_ref,
4274 decoder,
4275 inner_offset,
4276 inner_depth
4277 )?;
4278 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4279 {
4280 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4281 }
4282 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4283 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4284 }
4285 }
4286
4287 next_offset += envelope_size;
4288
4289 while next_offset < end_offset {
4291 _next_ordinal_to_read += 1;
4292 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4293 next_offset += envelope_size;
4294 }
4295
4296 Ok(())
4297 }
4298 }
4299
4300 impl RepositoryConfig {
4301 #[inline(always)]
4302 fn max_ordinal_present(&self) -> u64 {
4303 if let Some(_) = self.storage_type {
4304 return 8;
4305 }
4306 if let Some(_) = self.use_local_mirror {
4307 return 7;
4308 }
4309 if let Some(_) = self.root_threshold {
4310 return 6;
4311 }
4312 if let Some(_) = self.root_version {
4313 return 5;
4314 }
4315 if let Some(_) = self.mirrors {
4316 return 3;
4317 }
4318 if let Some(_) = self.root_keys {
4319 return 2;
4320 }
4321 if let Some(_) = self.repo_url {
4322 return 1;
4323 }
4324 0
4325 }
4326 }
4327
4328 impl fidl::encoding::ValueTypeMarker for RepositoryConfig {
4329 type Borrowed<'a> = &'a Self;
4330 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4331 value
4332 }
4333 }
4334
4335 unsafe impl fidl::encoding::TypeMarker for RepositoryConfig {
4336 type Owned = Self;
4337
4338 #[inline(always)]
4339 fn inline_align(_context: fidl::encoding::Context) -> usize {
4340 8
4341 }
4342
4343 #[inline(always)]
4344 fn inline_size(_context: fidl::encoding::Context) -> usize {
4345 16
4346 }
4347 }
4348
4349 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RepositoryConfig, D>
4350 for &RepositoryConfig
4351 {
4352 unsafe fn encode(
4353 self,
4354 encoder: &mut fidl::encoding::Encoder<'_, D>,
4355 offset: usize,
4356 mut depth: fidl::encoding::Depth,
4357 ) -> fidl::Result<()> {
4358 encoder.debug_check_bounds::<RepositoryConfig>(offset);
4359 let max_ordinal: u64 = self.max_ordinal_present();
4361 encoder.write_num(max_ordinal, offset);
4362 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4363 if max_ordinal == 0 {
4365 return Ok(());
4366 }
4367 depth.increment()?;
4368 let envelope_size = 8;
4369 let bytes_len = max_ordinal as usize * envelope_size;
4370 #[allow(unused_variables)]
4371 let offset = encoder.out_of_line_offset(bytes_len);
4372 let mut _prev_end_offset: usize = 0;
4373 if 1 > max_ordinal {
4374 return Ok(());
4375 }
4376
4377 let cur_offset: usize = (1 - 1) * envelope_size;
4380
4381 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4383
4384 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4389 self.repo_url.as_ref().map(
4390 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4391 ),
4392 encoder,
4393 offset + cur_offset,
4394 depth,
4395 )?;
4396
4397 _prev_end_offset = cur_offset + envelope_size;
4398 if 2 > max_ordinal {
4399 return Ok(());
4400 }
4401
4402 let cur_offset: usize = (2 - 1) * envelope_size;
4405
4406 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4408
4409 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<RepositoryKeyConfig>, D>(
4414 self.root_keys.as_ref().map(<fidl::encoding::UnboundedVector<RepositoryKeyConfig> as fidl::encoding::ValueTypeMarker>::borrow),
4415 encoder, offset + cur_offset, depth
4416 )?;
4417
4418 _prev_end_offset = cur_offset + envelope_size;
4419 if 3 > max_ordinal {
4420 return Ok(());
4421 }
4422
4423 let cur_offset: usize = (3 - 1) * envelope_size;
4426
4427 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4429
4430 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<MirrorConfig>, D>(
4435 self.mirrors.as_ref().map(<fidl::encoding::UnboundedVector<MirrorConfig> as fidl::encoding::ValueTypeMarker>::borrow),
4436 encoder, offset + cur_offset, depth
4437 )?;
4438
4439 _prev_end_offset = cur_offset + envelope_size;
4440 if 5 > max_ordinal {
4441 return Ok(());
4442 }
4443
4444 let cur_offset: usize = (5 - 1) * envelope_size;
4447
4448 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4450
4451 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4456 self.root_version.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4457 encoder,
4458 offset + cur_offset,
4459 depth,
4460 )?;
4461
4462 _prev_end_offset = cur_offset + envelope_size;
4463 if 6 > max_ordinal {
4464 return Ok(());
4465 }
4466
4467 let cur_offset: usize = (6 - 1) * envelope_size;
4470
4471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4473
4474 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4479 self.root_threshold.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4480 encoder,
4481 offset + cur_offset,
4482 depth,
4483 )?;
4484
4485 _prev_end_offset = cur_offset + envelope_size;
4486 if 7 > max_ordinal {
4487 return Ok(());
4488 }
4489
4490 let cur_offset: usize = (7 - 1) * envelope_size;
4493
4494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4496
4497 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4502 self.use_local_mirror
4503 .as_ref()
4504 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4505 encoder,
4506 offset + cur_offset,
4507 depth,
4508 )?;
4509
4510 _prev_end_offset = cur_offset + envelope_size;
4511 if 8 > max_ordinal {
4512 return Ok(());
4513 }
4514
4515 let cur_offset: usize = (8 - 1) * envelope_size;
4518
4519 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4521
4522 fidl::encoding::encode_in_envelope_optional::<RepositoryStorageType, D>(
4527 self.storage_type
4528 .as_ref()
4529 .map(<RepositoryStorageType as fidl::encoding::ValueTypeMarker>::borrow),
4530 encoder,
4531 offset + cur_offset,
4532 depth,
4533 )?;
4534
4535 _prev_end_offset = cur_offset + envelope_size;
4536
4537 Ok(())
4538 }
4539 }
4540
4541 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryConfig {
4542 #[inline(always)]
4543 fn new_empty() -> Self {
4544 Self::default()
4545 }
4546
4547 unsafe fn decode(
4548 &mut self,
4549 decoder: &mut fidl::encoding::Decoder<'_, D>,
4550 offset: usize,
4551 mut depth: fidl::encoding::Depth,
4552 ) -> fidl::Result<()> {
4553 decoder.debug_check_bounds::<Self>(offset);
4554 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4555 None => return Err(fidl::Error::NotNullable),
4556 Some(len) => len,
4557 };
4558 if len == 0 {
4560 return Ok(());
4561 };
4562 depth.increment()?;
4563 let envelope_size = 8;
4564 let bytes_len = len * envelope_size;
4565 let offset = decoder.out_of_line_offset(bytes_len)?;
4566 let mut _next_ordinal_to_read = 0;
4568 let mut next_offset = offset;
4569 let end_offset = offset + bytes_len;
4570 _next_ordinal_to_read += 1;
4571 if next_offset >= end_offset {
4572 return Ok(());
4573 }
4574
4575 while _next_ordinal_to_read < 1 {
4577 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4578 _next_ordinal_to_read += 1;
4579 next_offset += envelope_size;
4580 }
4581
4582 let next_out_of_line = decoder.next_out_of_line();
4583 let handles_before = decoder.remaining_handles();
4584 if let Some((inlined, num_bytes, num_handles)) =
4585 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4586 {
4587 let member_inline_size =
4588 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4589 decoder.context,
4590 );
4591 if inlined != (member_inline_size <= 4) {
4592 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4593 }
4594 let inner_offset;
4595 let mut inner_depth = depth.clone();
4596 if inlined {
4597 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4598 inner_offset = next_offset;
4599 } else {
4600 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4601 inner_depth.increment()?;
4602 }
4603 let val_ref = self
4604 .repo_url
4605 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4606 fidl::decode!(
4607 fidl::encoding::UnboundedString,
4608 D,
4609 val_ref,
4610 decoder,
4611 inner_offset,
4612 inner_depth
4613 )?;
4614 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4615 {
4616 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4617 }
4618 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4619 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4620 }
4621 }
4622
4623 next_offset += envelope_size;
4624 _next_ordinal_to_read += 1;
4625 if next_offset >= end_offset {
4626 return Ok(());
4627 }
4628
4629 while _next_ordinal_to_read < 2 {
4631 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4632 _next_ordinal_to_read += 1;
4633 next_offset += envelope_size;
4634 }
4635
4636 let next_out_of_line = decoder.next_out_of_line();
4637 let handles_before = decoder.remaining_handles();
4638 if let Some((inlined, num_bytes, num_handles)) =
4639 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4640 {
4641 let member_inline_size = <fidl::encoding::UnboundedVector<RepositoryKeyConfig> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4642 if inlined != (member_inline_size <= 4) {
4643 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4644 }
4645 let inner_offset;
4646 let mut inner_depth = depth.clone();
4647 if inlined {
4648 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4649 inner_offset = next_offset;
4650 } else {
4651 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4652 inner_depth.increment()?;
4653 }
4654 let val_ref = self.root_keys.get_or_insert_with(|| {
4655 fidl::new_empty!(fidl::encoding::UnboundedVector<RepositoryKeyConfig>, D)
4656 });
4657 fidl::decode!(
4658 fidl::encoding::UnboundedVector<RepositoryKeyConfig>,
4659 D,
4660 val_ref,
4661 decoder,
4662 inner_offset,
4663 inner_depth
4664 )?;
4665 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4666 {
4667 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4668 }
4669 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4670 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4671 }
4672 }
4673
4674 next_offset += envelope_size;
4675 _next_ordinal_to_read += 1;
4676 if next_offset >= end_offset {
4677 return Ok(());
4678 }
4679
4680 while _next_ordinal_to_read < 3 {
4682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4683 _next_ordinal_to_read += 1;
4684 next_offset += envelope_size;
4685 }
4686
4687 let next_out_of_line = decoder.next_out_of_line();
4688 let handles_before = decoder.remaining_handles();
4689 if let Some((inlined, num_bytes, num_handles)) =
4690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4691 {
4692 let member_inline_size = <fidl::encoding::UnboundedVector<MirrorConfig> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4693 if inlined != (member_inline_size <= 4) {
4694 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4695 }
4696 let inner_offset;
4697 let mut inner_depth = depth.clone();
4698 if inlined {
4699 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4700 inner_offset = next_offset;
4701 } else {
4702 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4703 inner_depth.increment()?;
4704 }
4705 let val_ref = self.mirrors.get_or_insert_with(|| {
4706 fidl::new_empty!(fidl::encoding::UnboundedVector<MirrorConfig>, D)
4707 });
4708 fidl::decode!(
4709 fidl::encoding::UnboundedVector<MirrorConfig>,
4710 D,
4711 val_ref,
4712 decoder,
4713 inner_offset,
4714 inner_depth
4715 )?;
4716 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4717 {
4718 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4719 }
4720 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4721 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4722 }
4723 }
4724
4725 next_offset += envelope_size;
4726 _next_ordinal_to_read += 1;
4727 if next_offset >= end_offset {
4728 return Ok(());
4729 }
4730
4731 while _next_ordinal_to_read < 5 {
4733 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4734 _next_ordinal_to_read += 1;
4735 next_offset += envelope_size;
4736 }
4737
4738 let next_out_of_line = decoder.next_out_of_line();
4739 let handles_before = decoder.remaining_handles();
4740 if let Some((inlined, num_bytes, num_handles)) =
4741 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4742 {
4743 let member_inline_size =
4744 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4745 if inlined != (member_inline_size <= 4) {
4746 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4747 }
4748 let inner_offset;
4749 let mut inner_depth = depth.clone();
4750 if inlined {
4751 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4752 inner_offset = next_offset;
4753 } else {
4754 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4755 inner_depth.increment()?;
4756 }
4757 let val_ref = self.root_version.get_or_insert_with(|| fidl::new_empty!(u32, D));
4758 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4760 {
4761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4762 }
4763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4765 }
4766 }
4767
4768 next_offset += envelope_size;
4769 _next_ordinal_to_read += 1;
4770 if next_offset >= end_offset {
4771 return Ok(());
4772 }
4773
4774 while _next_ordinal_to_read < 6 {
4776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4777 _next_ordinal_to_read += 1;
4778 next_offset += envelope_size;
4779 }
4780
4781 let next_out_of_line = decoder.next_out_of_line();
4782 let handles_before = decoder.remaining_handles();
4783 if let Some((inlined, num_bytes, num_handles)) =
4784 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4785 {
4786 let member_inline_size =
4787 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4788 if inlined != (member_inline_size <= 4) {
4789 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4790 }
4791 let inner_offset;
4792 let mut inner_depth = depth.clone();
4793 if inlined {
4794 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4795 inner_offset = next_offset;
4796 } else {
4797 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4798 inner_depth.increment()?;
4799 }
4800 let val_ref = self.root_threshold.get_or_insert_with(|| fidl::new_empty!(u32, D));
4801 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4802 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4803 {
4804 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4805 }
4806 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4807 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4808 }
4809 }
4810
4811 next_offset += envelope_size;
4812 _next_ordinal_to_read += 1;
4813 if next_offset >= end_offset {
4814 return Ok(());
4815 }
4816
4817 while _next_ordinal_to_read < 7 {
4819 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4820 _next_ordinal_to_read += 1;
4821 next_offset += envelope_size;
4822 }
4823
4824 let next_out_of_line = decoder.next_out_of_line();
4825 let handles_before = decoder.remaining_handles();
4826 if let Some((inlined, num_bytes, num_handles)) =
4827 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4828 {
4829 let member_inline_size =
4830 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4831 if inlined != (member_inline_size <= 4) {
4832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4833 }
4834 let inner_offset;
4835 let mut inner_depth = depth.clone();
4836 if inlined {
4837 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4838 inner_offset = next_offset;
4839 } else {
4840 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4841 inner_depth.increment()?;
4842 }
4843 let val_ref =
4844 self.use_local_mirror.get_or_insert_with(|| fidl::new_empty!(bool, D));
4845 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4846 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4847 {
4848 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4849 }
4850 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4851 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4852 }
4853 }
4854
4855 next_offset += envelope_size;
4856 _next_ordinal_to_read += 1;
4857 if next_offset >= end_offset {
4858 return Ok(());
4859 }
4860
4861 while _next_ordinal_to_read < 8 {
4863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4864 _next_ordinal_to_read += 1;
4865 next_offset += envelope_size;
4866 }
4867
4868 let next_out_of_line = decoder.next_out_of_line();
4869 let handles_before = decoder.remaining_handles();
4870 if let Some((inlined, num_bytes, num_handles)) =
4871 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4872 {
4873 let member_inline_size =
4874 <RepositoryStorageType as fidl::encoding::TypeMarker>::inline_size(
4875 decoder.context,
4876 );
4877 if inlined != (member_inline_size <= 4) {
4878 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4879 }
4880 let inner_offset;
4881 let mut inner_depth = depth.clone();
4882 if inlined {
4883 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4884 inner_offset = next_offset;
4885 } else {
4886 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4887 inner_depth.increment()?;
4888 }
4889 let val_ref = self
4890 .storage_type
4891 .get_or_insert_with(|| fidl::new_empty!(RepositoryStorageType, D));
4892 fidl::decode!(
4893 RepositoryStorageType,
4894 D,
4895 val_ref,
4896 decoder,
4897 inner_offset,
4898 inner_depth
4899 )?;
4900 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4901 {
4902 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4903 }
4904 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4905 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4906 }
4907 }
4908
4909 next_offset += envelope_size;
4910
4911 while next_offset < end_offset {
4913 _next_ordinal_to_read += 1;
4914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4915 next_offset += envelope_size;
4916 }
4917
4918 Ok(())
4919 }
4920 }
4921
4922 impl fidl::encoding::ValueTypeMarker for RepositoryKeyConfig {
4923 type Borrowed<'a> = &'a Self;
4924 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4925 value
4926 }
4927 }
4928
4929 unsafe impl fidl::encoding::TypeMarker for RepositoryKeyConfig {
4930 type Owned = Self;
4931
4932 #[inline(always)]
4933 fn inline_align(_context: fidl::encoding::Context) -> usize {
4934 8
4935 }
4936
4937 #[inline(always)]
4938 fn inline_size(_context: fidl::encoding::Context) -> usize {
4939 16
4940 }
4941 }
4942
4943 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RepositoryKeyConfig, D>
4944 for &RepositoryKeyConfig
4945 {
4946 #[inline]
4947 unsafe fn encode(
4948 self,
4949 encoder: &mut fidl::encoding::Encoder<'_, D>,
4950 offset: usize,
4951 _depth: fidl::encoding::Depth,
4952 ) -> fidl::Result<()> {
4953 encoder.debug_check_bounds::<RepositoryKeyConfig>(offset);
4954 encoder.write_num::<u64>(self.ordinal(), offset);
4955 match self {
4956 RepositoryKeyConfig::Ed25519Key(ref val) => {
4957 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
4958 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
4959 encoder, offset + 8, _depth
4960 )
4961 }
4962 RepositoryKeyConfig::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4963 }
4964 }
4965 }
4966
4967 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryKeyConfig {
4968 #[inline(always)]
4969 fn new_empty() -> Self {
4970 Self::__SourceBreaking { unknown_ordinal: 0 }
4971 }
4972
4973 #[inline]
4974 unsafe fn decode(
4975 &mut self,
4976 decoder: &mut fidl::encoding::Decoder<'_, D>,
4977 offset: usize,
4978 mut depth: fidl::encoding::Depth,
4979 ) -> fidl::Result<()> {
4980 decoder.debug_check_bounds::<Self>(offset);
4981 #[allow(unused_variables)]
4982 let next_out_of_line = decoder.next_out_of_line();
4983 let handles_before = decoder.remaining_handles();
4984 let (ordinal, inlined, num_bytes, num_handles) =
4985 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4986
4987 let member_inline_size = match ordinal {
4988 1 => {
4989 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(
4990 decoder.context,
4991 )
4992 }
4993 0 => return Err(fidl::Error::UnknownUnionTag),
4994 _ => num_bytes as usize,
4995 };
4996
4997 if inlined != (member_inline_size <= 4) {
4998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4999 }
5000 let _inner_offset;
5001 if inlined {
5002 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5003 _inner_offset = offset + 8;
5004 } else {
5005 depth.increment()?;
5006 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5007 }
5008 match ordinal {
5009 1 => {
5010 #[allow(irrefutable_let_patterns)]
5011 if let RepositoryKeyConfig::Ed25519Key(_) = self {
5012 } else {
5014 *self = RepositoryKeyConfig::Ed25519Key(fidl::new_empty!(
5016 fidl::encoding::UnboundedVector<u8>,
5017 D
5018 ));
5019 }
5020 #[allow(irrefutable_let_patterns)]
5021 if let RepositoryKeyConfig::Ed25519Key(ref mut val) = self {
5022 fidl::decode!(
5023 fidl::encoding::UnboundedVector<u8>,
5024 D,
5025 val,
5026 decoder,
5027 _inner_offset,
5028 depth
5029 )?;
5030 } else {
5031 unreachable!()
5032 }
5033 }
5034 #[allow(deprecated)]
5035 ordinal => {
5036 for _ in 0..num_handles {
5037 decoder.drop_next_handle()?;
5038 }
5039 *self = RepositoryKeyConfig::__SourceBreaking { unknown_ordinal: ordinal };
5040 }
5041 }
5042 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5043 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5044 }
5045 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5046 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5047 }
5048 Ok(())
5049 }
5050 }
5051}