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 DONE_MARKER: &str =
24 "DONE: A long-running `fuchsia.fuzzer.Controller` workflow is complete.";
25
26pub const FUZZ_MODE: &str = "--fuzz";
35
36pub const MAX_COVERAGE_DATA: u64 = 4096;
40
41pub const MAX_PARAMETERS: u16 = 128;
42
43pub const MAX_PARAMETER_LEN: u16 = 256;
44
45pub const MAX_PROCESS_STATS: u16 = 256;
48
49pub const MAX_SANITIZER_OPTIONS_NAME_SIZE: u16 = 32;
55
56pub const MAX_SANITIZER_OPTIONS_VALUE_SIZE: u16 = 8192;
64
65bitflags! {
66 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
72 pub struct OutputFlags: u32 {
73 const CLOSE_STDOUT = 1;
76 const CLOSE_STDERR = 2;
80 const VERBOSE = 4;
84 const LIBFUZZER = 8;
88 }
89}
90
91impl OutputFlags {}
92
93#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
95pub enum Corpus {
96 Seed,
99 Live,
102 #[doc(hidden)]
103 __SourceBreaking { unknown_ordinal: u8 },
104}
105
106#[macro_export]
108macro_rules! CorpusUnknown {
109 () => {
110 _
111 };
112}
113
114impl Corpus {
115 #[inline]
116 pub fn from_primitive(prim: u8) -> Option<Self> {
117 match prim {
118 1 => Some(Self::Seed),
119 2 => Some(Self::Live),
120 _ => None,
121 }
122 }
123
124 #[inline]
125 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
126 match prim {
127 1 => Self::Seed,
128 2 => Self::Live,
129 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
130 }
131 }
132
133 #[inline]
134 pub fn unknown() -> Self {
135 Self::__SourceBreaking { unknown_ordinal: 0xff }
136 }
137
138 #[inline]
139 pub const fn into_primitive(self) -> u8 {
140 match self {
141 Self::Seed => 1,
142 Self::Live => 2,
143 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
144 }
145 }
146
147 #[inline]
148 pub fn is_unknown(&self) -> bool {
149 match self {
150 Self::__SourceBreaking { unknown_ordinal: _ } => true,
151 _ => false,
152 }
153 }
154}
155
156#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
170pub enum Result_ {
171 NoErrors,
173 BadMalloc,
178 Crash,
181 Death,
184 Exit,
188 Leak,
191 Oom,
194 Timeout,
196 Minimized,
199 Cleansed,
203 Merged,
207 #[doc(hidden)]
208 __SourceBreaking { unknown_ordinal: u32 },
209}
210
211#[macro_export]
213macro_rules! Result_Unknown {
214 () => {
215 _
216 };
217}
218
219impl Result_ {
220 #[inline]
221 pub fn from_primitive(prim: u32) -> Option<Self> {
222 match prim {
223 1 => Some(Self::NoErrors),
224 2 => Some(Self::BadMalloc),
225 3 => Some(Self::Crash),
226 4 => Some(Self::Death),
227 5 => Some(Self::Exit),
228 6 => Some(Self::Leak),
229 7 => Some(Self::Oom),
230 8 => Some(Self::Timeout),
231 9 => Some(Self::Minimized),
232 10 => Some(Self::Cleansed),
233 11 => Some(Self::Merged),
234 _ => None,
235 }
236 }
237
238 #[inline]
239 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
240 match prim {
241 1 => Self::NoErrors,
242 2 => Self::BadMalloc,
243 3 => Self::Crash,
244 4 => Self::Death,
245 5 => Self::Exit,
246 6 => Self::Leak,
247 7 => Self::Oom,
248 8 => Self::Timeout,
249 9 => Self::Minimized,
250 10 => Self::Cleansed,
251 11 => Self::Merged,
252 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
253 }
254 }
255
256 #[inline]
257 pub fn unknown() -> Self {
258 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
259 }
260
261 #[inline]
262 pub const fn into_primitive(self) -> u32 {
263 match self {
264 Self::NoErrors => 1,
265 Self::BadMalloc => 2,
266 Self::Crash => 3,
267 Self::Death => 4,
268 Self::Exit => 5,
269 Self::Leak => 6,
270 Self::Oom => 7,
271 Self::Timeout => 8,
272 Self::Minimized => 9,
273 Self::Cleansed => 10,
274 Self::Merged => 11,
275 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
276 }
277 }
278
279 #[inline]
280 pub fn is_unknown(&self) -> bool {
281 match self {
282 Self::__SourceBreaking { unknown_ordinal: _ } => true,
283 _ => false,
284 }
285 }
286}
287
288#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
294pub enum TestOutput {
295 Stdout,
297 Stderr,
299 Syslog,
301 #[doc(hidden)]
302 __SourceBreaking { unknown_ordinal: u32 },
303}
304
305#[macro_export]
307macro_rules! TestOutputUnknown {
308 () => {
309 _
310 };
311}
312
313impl TestOutput {
314 #[inline]
315 pub fn from_primitive(prim: u32) -> Option<Self> {
316 match prim {
317 1 => Some(Self::Stdout),
318 2 => Some(Self::Stderr),
319 3 => Some(Self::Syslog),
320 _ => None,
321 }
322 }
323
324 #[inline]
325 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
326 match prim {
327 1 => Self::Stdout,
328 2 => Self::Stderr,
329 3 => Self::Syslog,
330 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
331 }
332 }
333
334 #[inline]
335 pub fn unknown() -> Self {
336 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
337 }
338
339 #[inline]
340 pub const fn into_primitive(self) -> u32 {
341 match self {
342 Self::Stdout => 1,
343 Self::Stderr => 2,
344 Self::Syslog => 3,
345 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
346 }
347 }
348
349 #[inline]
350 pub fn is_unknown(&self) -> bool {
351 match self {
352 Self::__SourceBreaking { unknown_ordinal: _ } => true,
353 _ => false,
354 }
355 }
356}
357
358#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
360pub enum UpdateReason {
361 Misc,
364 Init,
367 New,
369 Pulse,
371 Reduce,
373 Done,
375 #[doc(hidden)]
376 __SourceBreaking { unknown_ordinal: u8 },
377}
378
379#[macro_export]
381macro_rules! UpdateReasonUnknown {
382 () => {
383 _
384 };
385}
386
387impl UpdateReason {
388 #[inline]
389 pub fn from_primitive(prim: u8) -> Option<Self> {
390 match prim {
391 1 => Some(Self::Misc),
392 2 => Some(Self::Init),
393 3 => Some(Self::New),
394 4 => Some(Self::Pulse),
395 5 => Some(Self::Reduce),
396 6 => Some(Self::Done),
397 _ => None,
398 }
399 }
400
401 #[inline]
402 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
403 match prim {
404 1 => Self::Misc,
405 2 => Self::Init,
406 3 => Self::New,
407 4 => Self::Pulse,
408 5 => Self::Reduce,
409 6 => Self::Done,
410 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
411 }
412 }
413
414 #[inline]
415 pub fn unknown() -> Self {
416 Self::__SourceBreaking { unknown_ordinal: 0xff }
417 }
418
419 #[inline]
420 pub const fn into_primitive(self) -> u8 {
421 match self {
422 Self::Misc => 1,
423 Self::Init => 2,
424 Self::New => 3,
425 Self::Pulse => 4,
426 Self::Reduce => 5,
427 Self::Done => 6,
428 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
429 }
430 }
431
432 #[inline]
433 pub fn is_unknown(&self) -> bool {
434 match self {
435 Self::__SourceBreaking { unknown_ordinal: _ } => true,
436 _ => false,
437 }
438 }
439}
440
441#[derive(Clone, Debug, PartialEq)]
442pub struct ControllerConfigureRequest {
443 pub options: Options,
444}
445
446impl fidl::Persistable for ControllerConfigureRequest {}
447
448#[derive(Clone, Debug, PartialEq)]
449pub struct ControllerGetOptionsResponse {
450 pub options: Options,
451}
452
453impl fidl::Persistable for ControllerGetOptionsResponse {}
454
455#[derive(Clone, Debug, PartialEq)]
456pub struct ControllerGetStatusResponse {
457 pub status: Status,
458}
459
460impl fidl::Persistable for ControllerGetStatusResponse {}
461
462#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
463#[repr(C)]
464pub struct CorpusReaderNextResponse {
465 pub result: i32,
466}
467
468impl fidl::Persistable for CorpusReaderNextResponse {}
469
470#[derive(Clone, Debug, PartialEq)]
471pub struct CoverageDataCollectorInitializeResponse {
472 pub options: Options,
473}
474
475impl fidl::Persistable for CoverageDataCollectorInitializeResponse {}
476
477#[derive(Clone, Debug, PartialEq)]
478pub struct CoverageDataProviderSetOptionsRequest {
479 pub options: Options,
480}
481
482impl fidl::Persistable for CoverageDataProviderSetOptionsRequest {}
483
484#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
485pub struct ManagerStopRequest {
486 pub fuzzer_url: String,
487}
488
489impl fidl::Persistable for ManagerStopRequest {}
490
491#[derive(Clone, Debug, PartialEq)]
492pub struct MonitorUpdateRequest {
493 pub reason: UpdateReason,
494 pub status: Status,
495}
496
497impl fidl::Persistable for MonitorUpdateRequest {}
498
499#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
506#[repr(C)]
507pub struct ProcessStats {
508 pub koid: u64,
510 pub mem_mapped_bytes: u64,
512 pub mem_private_bytes: u64,
514 pub mem_shared_bytes: u64,
517 pub mem_scaled_shared_bytes: u64,
519 pub cpu_time: i64,
522 pub queue_time: i64,
525 pub page_fault_time: i64,
527 pub lock_contention_time: i64,
530}
531
532impl fidl::Persistable for ProcessStats {}
533
534#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
535pub struct RegistryDisconnectRequest {
536 pub fuzzer_url: String,
537}
538
539impl fidl::Persistable for RegistryDisconnectRequest {}
540
541#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
552pub struct SanitizerOptions {
553 pub name: String,
554 pub value: String,
555}
556
557impl fidl::Persistable for SanitizerOptions {}
558
559#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
560pub struct TargetAdapterGetParametersResponse {
561 pub parameters: Vec<String>,
562}
563
564impl fidl::Persistable for TargetAdapterGetParametersResponse {}
565
566#[derive(Clone, Debug, Default, PartialEq)]
568pub struct Options {
569 pub runs: Option<u32>,
572 pub max_total_time: Option<i64>,
575 pub seed: Option<u32>,
579 pub max_input_size: Option<u64>,
582 pub mutation_depth: Option<u16>,
585 pub dictionary_level: Option<u16>,
589 pub detect_exits: Option<bool>,
592 pub detect_leaks: Option<bool>,
597 pub run_limit: Option<i64>,
600 pub malloc_limit: Option<u64>,
603 pub oom_limit: Option<u64>,
607 pub purge_interval: Option<i64>,
611 pub malloc_exitcode: Option<i32>,
615 pub death_exitcode: Option<i32>,
619 pub leak_exitcode: Option<i32>,
623 pub oom_exitcode: Option<i32>,
627 pub pulse_interval: Option<i64>,
630 pub debug: Option<bool>,
636 pub print_final_stats: Option<bool>,
639 pub use_value_profile: Option<bool>,
643 pub sanitizer_options: Option<SanitizerOptions>,
645 pub output_flags: Option<OutputFlags>,
647 #[doc(hidden)]
648 pub __source_breaking: fidl::marker::SourceBreaking,
649}
650
651impl fidl::Persistable for Options {}
652
653#[derive(Clone, Debug, Default, PartialEq)]
655pub struct Status {
656 pub running: Option<bool>,
658 pub runs: Option<u32>,
660 pub elapsed: Option<i64>,
662 pub covered_pcs: Option<u64>,
664 pub covered_features: Option<u64>,
666 pub corpus_num_inputs: Option<u64>,
668 pub corpus_total_size: Option<u64>,
670 pub process_stats: Option<Vec<ProcessStats>>,
672 #[doc(hidden)]
673 pub __source_breaking: fidl::marker::SourceBreaking,
674}
675
676impl fidl::Persistable for Status {}
677
678pub mod controller_ordinals {
679 pub const CONFIGURE: u64 = 0x35c8cba7fa3d32e4;
680 pub const GET_OPTIONS: u64 = 0x683d93332504b9cd;
681 pub const ADD_TO_CORPUS: u64 = 0x7bdf8336ab534cee;
682 pub const READ_CORPUS: u64 = 0x501279b430b34514;
683 pub const WRITE_DICTIONARY: u64 = 0x4ecfc1274fe4a70b;
684 pub const READ_DICTIONARY: u64 = 0x1be6724c87b51c37;
685 pub const ADD_MONITOR: u64 = 0x2efbf7d3dc21438e;
686 pub const FUZZ: u64 = 0x62fe3684ea23af62;
687 pub const TRY_ONE: u64 = 0x368dc762d8e16d46;
688 pub const MINIMIZE: u64 = 0x105a242ee0552794;
689 pub const CLEANSE: u64 = 0x6d7892f62735f3e0;
690 pub const MERGE: u64 = 0x3614e5c39413b5eb;
691 pub const GET_STATUS: u64 = 0x51db4975d93ce768;
692 pub const WATCH_ARTIFACT: u64 = 0x6cfca3730944a414;
693}
694
695pub mod controller_provider_ordinals {
696 pub const CONNECT: u64 = 0xc0325f0732defcb;
697 pub const STOP: u64 = 0x6cd6a98fc38bcbf2;
698}
699
700pub mod corpus_reader_ordinals {
701 pub const NEXT: u64 = 0x68d19e55ea635356;
702}
703
704pub mod coverage_data_collector_ordinals {
705 pub const INITIALIZE: u64 = 0x51d6f91d6f02d9d6;
706 pub const ADD_INLINE8BIT_COUNTERS: u64 = 0x75f87cadfc94d1be;
707}
708
709pub mod coverage_data_provider_ordinals {
710 pub const SET_OPTIONS: u64 = 0x4873c4a5c7683384;
711 pub const WATCH_COVERAGE_DATA: u64 = 0x34a92fc9c73bea5a;
712}
713
714pub mod manager_ordinals {
715 pub const CONNECT: u64 = 0x1620cd742a89f064;
716 pub const GET_OUTPUT: u64 = 0x755c28eecf20a88d;
717 pub const STOP: u64 = 0x27e53d86badd21f3;
718}
719
720pub mod monitor_ordinals {
721 pub const UPDATE: u64 = 0x7c773b93c1e6080f;
722}
723
724pub mod registrar_ordinals {
725 pub const REGISTER: u64 = 0x1716ac38e74b2840;
726}
727
728pub mod registry_ordinals {
729 pub const CONNECT: u64 = 0x5128cb31967a446f;
730 pub const DISCONNECT: u64 = 0x7bb4b7591146d4cb;
731}
732
733pub mod target_adapter_ordinals {
734 pub const GET_PARAMETERS: u64 = 0x5c7e40a47f753e3e;
735 pub const CONNECT: u64 = 0x7ea603a119866618;
736}
737
738mod internal {
739 use super::*;
740 unsafe impl fidl::encoding::TypeMarker for OutputFlags {
741 type Owned = Self;
742
743 #[inline(always)]
744 fn inline_align(_context: fidl::encoding::Context) -> usize {
745 4
746 }
747
748 #[inline(always)]
749 fn inline_size(_context: fidl::encoding::Context) -> usize {
750 4
751 }
752 }
753
754 impl fidl::encoding::ValueTypeMarker for OutputFlags {
755 type Borrowed<'a> = Self;
756 #[inline(always)]
757 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
758 *value
759 }
760 }
761
762 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OutputFlags {
763 #[inline]
764 unsafe fn encode(
765 self,
766 encoder: &mut fidl::encoding::Encoder<'_, D>,
767 offset: usize,
768 _depth: fidl::encoding::Depth,
769 ) -> fidl::Result<()> {
770 encoder.debug_check_bounds::<Self>(offset);
771 if self.bits() & Self::all().bits() != self.bits() {
772 return Err(fidl::Error::InvalidBitsValue);
773 }
774 encoder.write_num(self.bits(), offset);
775 Ok(())
776 }
777 }
778
779 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OutputFlags {
780 #[inline(always)]
781 fn new_empty() -> Self {
782 Self::empty()
783 }
784
785 #[inline]
786 unsafe fn decode(
787 &mut self,
788 decoder: &mut fidl::encoding::Decoder<'_, D>,
789 offset: usize,
790 _depth: fidl::encoding::Depth,
791 ) -> fidl::Result<()> {
792 decoder.debug_check_bounds::<Self>(offset);
793 let prim = decoder.read_num::<u32>(offset);
794 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
795 Ok(())
796 }
797 }
798 unsafe impl fidl::encoding::TypeMarker for Corpus {
799 type Owned = Self;
800
801 #[inline(always)]
802 fn inline_align(_context: fidl::encoding::Context) -> usize {
803 std::mem::align_of::<u8>()
804 }
805
806 #[inline(always)]
807 fn inline_size(_context: fidl::encoding::Context) -> usize {
808 std::mem::size_of::<u8>()
809 }
810
811 #[inline(always)]
812 fn encode_is_copy() -> bool {
813 false
814 }
815
816 #[inline(always)]
817 fn decode_is_copy() -> bool {
818 false
819 }
820 }
821
822 impl fidl::encoding::ValueTypeMarker for Corpus {
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 Corpus {
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 Corpus {
845 #[inline(always)]
846 fn new_empty() -> Self {
847 Self::unknown()
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::<u8>(offset);
859
860 *self = Self::from_primitive_allow_unknown(prim);
861 Ok(())
862 }
863 }
864 unsafe impl fidl::encoding::TypeMarker for Result_ {
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 false
880 }
881
882 #[inline(always)]
883 fn decode_is_copy() -> bool {
884 false
885 }
886 }
887
888 impl fidl::encoding::ValueTypeMarker for Result_ {
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> for Result_ {
897 #[inline]
898 unsafe fn encode(
899 self,
900 encoder: &mut fidl::encoding::Encoder<'_, D>,
901 offset: usize,
902 _depth: fidl::encoding::Depth,
903 ) -> fidl::Result<()> {
904 encoder.debug_check_bounds::<Self>(offset);
905 encoder.write_num(self.into_primitive(), offset);
906 Ok(())
907 }
908 }
909
910 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Result_ {
911 #[inline(always)]
912 fn new_empty() -> Self {
913 Self::unknown()
914 }
915
916 #[inline]
917 unsafe fn decode(
918 &mut self,
919 decoder: &mut fidl::encoding::Decoder<'_, D>,
920 offset: usize,
921 _depth: fidl::encoding::Depth,
922 ) -> fidl::Result<()> {
923 decoder.debug_check_bounds::<Self>(offset);
924 let prim = decoder.read_num::<u32>(offset);
925
926 *self = Self::from_primitive_allow_unknown(prim);
927 Ok(())
928 }
929 }
930 unsafe impl fidl::encoding::TypeMarker for TestOutput {
931 type Owned = Self;
932
933 #[inline(always)]
934 fn inline_align(_context: fidl::encoding::Context) -> usize {
935 std::mem::align_of::<u32>()
936 }
937
938 #[inline(always)]
939 fn inline_size(_context: fidl::encoding::Context) -> usize {
940 std::mem::size_of::<u32>()
941 }
942
943 #[inline(always)]
944 fn encode_is_copy() -> bool {
945 false
946 }
947
948 #[inline(always)]
949 fn decode_is_copy() -> bool {
950 false
951 }
952 }
953
954 impl fidl::encoding::ValueTypeMarker for TestOutput {
955 type Borrowed<'a> = Self;
956 #[inline(always)]
957 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
958 *value
959 }
960 }
961
962 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TestOutput {
963 #[inline]
964 unsafe fn encode(
965 self,
966 encoder: &mut fidl::encoding::Encoder<'_, D>,
967 offset: usize,
968 _depth: fidl::encoding::Depth,
969 ) -> fidl::Result<()> {
970 encoder.debug_check_bounds::<Self>(offset);
971 encoder.write_num(self.into_primitive(), offset);
972 Ok(())
973 }
974 }
975
976 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TestOutput {
977 #[inline(always)]
978 fn new_empty() -> Self {
979 Self::unknown()
980 }
981
982 #[inline]
983 unsafe fn decode(
984 &mut self,
985 decoder: &mut fidl::encoding::Decoder<'_, D>,
986 offset: usize,
987 _depth: fidl::encoding::Depth,
988 ) -> fidl::Result<()> {
989 decoder.debug_check_bounds::<Self>(offset);
990 let prim = decoder.read_num::<u32>(offset);
991
992 *self = Self::from_primitive_allow_unknown(prim);
993 Ok(())
994 }
995 }
996 unsafe impl fidl::encoding::TypeMarker for UpdateReason {
997 type Owned = Self;
998
999 #[inline(always)]
1000 fn inline_align(_context: fidl::encoding::Context) -> usize {
1001 std::mem::align_of::<u8>()
1002 }
1003
1004 #[inline(always)]
1005 fn inline_size(_context: fidl::encoding::Context) -> usize {
1006 std::mem::size_of::<u8>()
1007 }
1008
1009 #[inline(always)]
1010 fn encode_is_copy() -> bool {
1011 false
1012 }
1013
1014 #[inline(always)]
1015 fn decode_is_copy() -> bool {
1016 false
1017 }
1018 }
1019
1020 impl fidl::encoding::ValueTypeMarker for UpdateReason {
1021 type Borrowed<'a> = Self;
1022 #[inline(always)]
1023 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1024 *value
1025 }
1026 }
1027
1028 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for UpdateReason {
1029 #[inline]
1030 unsafe fn encode(
1031 self,
1032 encoder: &mut fidl::encoding::Encoder<'_, D>,
1033 offset: usize,
1034 _depth: fidl::encoding::Depth,
1035 ) -> fidl::Result<()> {
1036 encoder.debug_check_bounds::<Self>(offset);
1037 encoder.write_num(self.into_primitive(), offset);
1038 Ok(())
1039 }
1040 }
1041
1042 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpdateReason {
1043 #[inline(always)]
1044 fn new_empty() -> Self {
1045 Self::unknown()
1046 }
1047
1048 #[inline]
1049 unsafe fn decode(
1050 &mut self,
1051 decoder: &mut fidl::encoding::Decoder<'_, D>,
1052 offset: usize,
1053 _depth: fidl::encoding::Depth,
1054 ) -> fidl::Result<()> {
1055 decoder.debug_check_bounds::<Self>(offset);
1056 let prim = decoder.read_num::<u8>(offset);
1057
1058 *self = Self::from_primitive_allow_unknown(prim);
1059 Ok(())
1060 }
1061 }
1062
1063 impl fidl::encoding::ValueTypeMarker for ControllerConfigureRequest {
1064 type Borrowed<'a> = &'a Self;
1065 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1066 value
1067 }
1068 }
1069
1070 unsafe impl fidl::encoding::TypeMarker for ControllerConfigureRequest {
1071 type Owned = Self;
1072
1073 #[inline(always)]
1074 fn inline_align(_context: fidl::encoding::Context) -> usize {
1075 8
1076 }
1077
1078 #[inline(always)]
1079 fn inline_size(_context: fidl::encoding::Context) -> usize {
1080 16
1081 }
1082 }
1083
1084 unsafe impl<D: fidl::encoding::ResourceDialect>
1085 fidl::encoding::Encode<ControllerConfigureRequest, D> for &ControllerConfigureRequest
1086 {
1087 #[inline]
1088 unsafe fn encode(
1089 self,
1090 encoder: &mut fidl::encoding::Encoder<'_, D>,
1091 offset: usize,
1092 _depth: fidl::encoding::Depth,
1093 ) -> fidl::Result<()> {
1094 encoder.debug_check_bounds::<ControllerConfigureRequest>(offset);
1095 fidl::encoding::Encode::<ControllerConfigureRequest, D>::encode(
1097 (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1098 encoder,
1099 offset,
1100 _depth,
1101 )
1102 }
1103 }
1104 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1105 fidl::encoding::Encode<ControllerConfigureRequest, D> for (T0,)
1106 {
1107 #[inline]
1108 unsafe fn encode(
1109 self,
1110 encoder: &mut fidl::encoding::Encoder<'_, D>,
1111 offset: usize,
1112 depth: fidl::encoding::Depth,
1113 ) -> fidl::Result<()> {
1114 encoder.debug_check_bounds::<ControllerConfigureRequest>(offset);
1115 self.0.encode(encoder, offset + 0, depth)?;
1119 Ok(())
1120 }
1121 }
1122
1123 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1124 for ControllerConfigureRequest
1125 {
1126 #[inline(always)]
1127 fn new_empty() -> Self {
1128 Self { options: fidl::new_empty!(Options, D) }
1129 }
1130
1131 #[inline]
1132 unsafe fn decode(
1133 &mut self,
1134 decoder: &mut fidl::encoding::Decoder<'_, D>,
1135 offset: usize,
1136 _depth: fidl::encoding::Depth,
1137 ) -> fidl::Result<()> {
1138 decoder.debug_check_bounds::<Self>(offset);
1139 fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1141 Ok(())
1142 }
1143 }
1144
1145 impl fidl::encoding::ValueTypeMarker for ControllerGetOptionsResponse {
1146 type Borrowed<'a> = &'a Self;
1147 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1148 value
1149 }
1150 }
1151
1152 unsafe impl fidl::encoding::TypeMarker for ControllerGetOptionsResponse {
1153 type Owned = Self;
1154
1155 #[inline(always)]
1156 fn inline_align(_context: fidl::encoding::Context) -> usize {
1157 8
1158 }
1159
1160 #[inline(always)]
1161 fn inline_size(_context: fidl::encoding::Context) -> usize {
1162 16
1163 }
1164 }
1165
1166 unsafe impl<D: fidl::encoding::ResourceDialect>
1167 fidl::encoding::Encode<ControllerGetOptionsResponse, D> for &ControllerGetOptionsResponse
1168 {
1169 #[inline]
1170 unsafe fn encode(
1171 self,
1172 encoder: &mut fidl::encoding::Encoder<'_, D>,
1173 offset: usize,
1174 _depth: fidl::encoding::Depth,
1175 ) -> fidl::Result<()> {
1176 encoder.debug_check_bounds::<ControllerGetOptionsResponse>(offset);
1177 fidl::encoding::Encode::<ControllerGetOptionsResponse, D>::encode(
1179 (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1180 encoder,
1181 offset,
1182 _depth,
1183 )
1184 }
1185 }
1186 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1187 fidl::encoding::Encode<ControllerGetOptionsResponse, D> for (T0,)
1188 {
1189 #[inline]
1190 unsafe fn encode(
1191 self,
1192 encoder: &mut fidl::encoding::Encoder<'_, D>,
1193 offset: usize,
1194 depth: fidl::encoding::Depth,
1195 ) -> fidl::Result<()> {
1196 encoder.debug_check_bounds::<ControllerGetOptionsResponse>(offset);
1197 self.0.encode(encoder, offset + 0, depth)?;
1201 Ok(())
1202 }
1203 }
1204
1205 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1206 for ControllerGetOptionsResponse
1207 {
1208 #[inline(always)]
1209 fn new_empty() -> Self {
1210 Self { options: fidl::new_empty!(Options, D) }
1211 }
1212
1213 #[inline]
1214 unsafe fn decode(
1215 &mut self,
1216 decoder: &mut fidl::encoding::Decoder<'_, D>,
1217 offset: usize,
1218 _depth: fidl::encoding::Depth,
1219 ) -> fidl::Result<()> {
1220 decoder.debug_check_bounds::<Self>(offset);
1221 fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1223 Ok(())
1224 }
1225 }
1226
1227 impl fidl::encoding::ValueTypeMarker for ControllerGetStatusResponse {
1228 type Borrowed<'a> = &'a Self;
1229 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1230 value
1231 }
1232 }
1233
1234 unsafe impl fidl::encoding::TypeMarker for ControllerGetStatusResponse {
1235 type Owned = Self;
1236
1237 #[inline(always)]
1238 fn inline_align(_context: fidl::encoding::Context) -> usize {
1239 8
1240 }
1241
1242 #[inline(always)]
1243 fn inline_size(_context: fidl::encoding::Context) -> usize {
1244 16
1245 }
1246 }
1247
1248 unsafe impl<D: fidl::encoding::ResourceDialect>
1249 fidl::encoding::Encode<ControllerGetStatusResponse, D> for &ControllerGetStatusResponse
1250 {
1251 #[inline]
1252 unsafe fn encode(
1253 self,
1254 encoder: &mut fidl::encoding::Encoder<'_, D>,
1255 offset: usize,
1256 _depth: fidl::encoding::Depth,
1257 ) -> fidl::Result<()> {
1258 encoder.debug_check_bounds::<ControllerGetStatusResponse>(offset);
1259 fidl::encoding::Encode::<ControllerGetStatusResponse, D>::encode(
1261 (<Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
1262 encoder,
1263 offset,
1264 _depth,
1265 )
1266 }
1267 }
1268 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Status, D>>
1269 fidl::encoding::Encode<ControllerGetStatusResponse, D> for (T0,)
1270 {
1271 #[inline]
1272 unsafe fn encode(
1273 self,
1274 encoder: &mut fidl::encoding::Encoder<'_, D>,
1275 offset: usize,
1276 depth: fidl::encoding::Depth,
1277 ) -> fidl::Result<()> {
1278 encoder.debug_check_bounds::<ControllerGetStatusResponse>(offset);
1279 self.0.encode(encoder, offset + 0, depth)?;
1283 Ok(())
1284 }
1285 }
1286
1287 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1288 for ControllerGetStatusResponse
1289 {
1290 #[inline(always)]
1291 fn new_empty() -> Self {
1292 Self { status: fidl::new_empty!(Status, D) }
1293 }
1294
1295 #[inline]
1296 unsafe fn decode(
1297 &mut self,
1298 decoder: &mut fidl::encoding::Decoder<'_, D>,
1299 offset: usize,
1300 _depth: fidl::encoding::Depth,
1301 ) -> fidl::Result<()> {
1302 decoder.debug_check_bounds::<Self>(offset);
1303 fidl::decode!(Status, D, &mut self.status, decoder, offset + 0, _depth)?;
1305 Ok(())
1306 }
1307 }
1308
1309 impl fidl::encoding::ValueTypeMarker for CorpusReaderNextResponse {
1310 type Borrowed<'a> = &'a Self;
1311 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1312 value
1313 }
1314 }
1315
1316 unsafe impl fidl::encoding::TypeMarker for CorpusReaderNextResponse {
1317 type Owned = Self;
1318
1319 #[inline(always)]
1320 fn inline_align(_context: fidl::encoding::Context) -> usize {
1321 4
1322 }
1323
1324 #[inline(always)]
1325 fn inline_size(_context: fidl::encoding::Context) -> usize {
1326 4
1327 }
1328 #[inline(always)]
1329 fn encode_is_copy() -> bool {
1330 true
1331 }
1332
1333 #[inline(always)]
1334 fn decode_is_copy() -> bool {
1335 true
1336 }
1337 }
1338
1339 unsafe impl<D: fidl::encoding::ResourceDialect>
1340 fidl::encoding::Encode<CorpusReaderNextResponse, D> for &CorpusReaderNextResponse
1341 {
1342 #[inline]
1343 unsafe fn encode(
1344 self,
1345 encoder: &mut fidl::encoding::Encoder<'_, D>,
1346 offset: usize,
1347 _depth: fidl::encoding::Depth,
1348 ) -> fidl::Result<()> {
1349 encoder.debug_check_bounds::<CorpusReaderNextResponse>(offset);
1350 unsafe {
1351 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1353 (buf_ptr as *mut CorpusReaderNextResponse)
1354 .write_unaligned((self as *const CorpusReaderNextResponse).read());
1355 }
1358 Ok(())
1359 }
1360 }
1361 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
1362 fidl::encoding::Encode<CorpusReaderNextResponse, D> for (T0,)
1363 {
1364 #[inline]
1365 unsafe fn encode(
1366 self,
1367 encoder: &mut fidl::encoding::Encoder<'_, D>,
1368 offset: usize,
1369 depth: fidl::encoding::Depth,
1370 ) -> fidl::Result<()> {
1371 encoder.debug_check_bounds::<CorpusReaderNextResponse>(offset);
1372 self.0.encode(encoder, offset + 0, depth)?;
1376 Ok(())
1377 }
1378 }
1379
1380 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1381 for CorpusReaderNextResponse
1382 {
1383 #[inline(always)]
1384 fn new_empty() -> Self {
1385 Self { result: fidl::new_empty!(i32, D) }
1386 }
1387
1388 #[inline]
1389 unsafe fn decode(
1390 &mut self,
1391 decoder: &mut fidl::encoding::Decoder<'_, D>,
1392 offset: usize,
1393 _depth: fidl::encoding::Depth,
1394 ) -> fidl::Result<()> {
1395 decoder.debug_check_bounds::<Self>(offset);
1396 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1397 unsafe {
1400 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1401 }
1402 Ok(())
1403 }
1404 }
1405
1406 impl fidl::encoding::ValueTypeMarker for CoverageDataCollectorInitializeResponse {
1407 type Borrowed<'a> = &'a Self;
1408 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1409 value
1410 }
1411 }
1412
1413 unsafe impl fidl::encoding::TypeMarker for CoverageDataCollectorInitializeResponse {
1414 type Owned = Self;
1415
1416 #[inline(always)]
1417 fn inline_align(_context: fidl::encoding::Context) -> usize {
1418 8
1419 }
1420
1421 #[inline(always)]
1422 fn inline_size(_context: fidl::encoding::Context) -> usize {
1423 16
1424 }
1425 }
1426
1427 unsafe impl<D: fidl::encoding::ResourceDialect>
1428 fidl::encoding::Encode<CoverageDataCollectorInitializeResponse, D>
1429 for &CoverageDataCollectorInitializeResponse
1430 {
1431 #[inline]
1432 unsafe fn encode(
1433 self,
1434 encoder: &mut fidl::encoding::Encoder<'_, D>,
1435 offset: usize,
1436 _depth: fidl::encoding::Depth,
1437 ) -> fidl::Result<()> {
1438 encoder.debug_check_bounds::<CoverageDataCollectorInitializeResponse>(offset);
1439 fidl::encoding::Encode::<CoverageDataCollectorInitializeResponse, D>::encode(
1441 (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1442 encoder,
1443 offset,
1444 _depth,
1445 )
1446 }
1447 }
1448 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1449 fidl::encoding::Encode<CoverageDataCollectorInitializeResponse, D> for (T0,)
1450 {
1451 #[inline]
1452 unsafe fn encode(
1453 self,
1454 encoder: &mut fidl::encoding::Encoder<'_, D>,
1455 offset: usize,
1456 depth: fidl::encoding::Depth,
1457 ) -> fidl::Result<()> {
1458 encoder.debug_check_bounds::<CoverageDataCollectorInitializeResponse>(offset);
1459 self.0.encode(encoder, offset + 0, depth)?;
1463 Ok(())
1464 }
1465 }
1466
1467 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1468 for CoverageDataCollectorInitializeResponse
1469 {
1470 #[inline(always)]
1471 fn new_empty() -> Self {
1472 Self { options: fidl::new_empty!(Options, D) }
1473 }
1474
1475 #[inline]
1476 unsafe fn decode(
1477 &mut self,
1478 decoder: &mut fidl::encoding::Decoder<'_, D>,
1479 offset: usize,
1480 _depth: fidl::encoding::Depth,
1481 ) -> fidl::Result<()> {
1482 decoder.debug_check_bounds::<Self>(offset);
1483 fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1485 Ok(())
1486 }
1487 }
1488
1489 impl fidl::encoding::ValueTypeMarker for CoverageDataProviderSetOptionsRequest {
1490 type Borrowed<'a> = &'a Self;
1491 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1492 value
1493 }
1494 }
1495
1496 unsafe impl fidl::encoding::TypeMarker for CoverageDataProviderSetOptionsRequest {
1497 type Owned = Self;
1498
1499 #[inline(always)]
1500 fn inline_align(_context: fidl::encoding::Context) -> usize {
1501 8
1502 }
1503
1504 #[inline(always)]
1505 fn inline_size(_context: fidl::encoding::Context) -> usize {
1506 16
1507 }
1508 }
1509
1510 unsafe impl<D: fidl::encoding::ResourceDialect>
1511 fidl::encoding::Encode<CoverageDataProviderSetOptionsRequest, D>
1512 for &CoverageDataProviderSetOptionsRequest
1513 {
1514 #[inline]
1515 unsafe fn encode(
1516 self,
1517 encoder: &mut fidl::encoding::Encoder<'_, D>,
1518 offset: usize,
1519 _depth: fidl::encoding::Depth,
1520 ) -> fidl::Result<()> {
1521 encoder.debug_check_bounds::<CoverageDataProviderSetOptionsRequest>(offset);
1522 fidl::encoding::Encode::<CoverageDataProviderSetOptionsRequest, D>::encode(
1524 (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
1525 encoder,
1526 offset,
1527 _depth,
1528 )
1529 }
1530 }
1531 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
1532 fidl::encoding::Encode<CoverageDataProviderSetOptionsRequest, D> for (T0,)
1533 {
1534 #[inline]
1535 unsafe fn encode(
1536 self,
1537 encoder: &mut fidl::encoding::Encoder<'_, D>,
1538 offset: usize,
1539 depth: fidl::encoding::Depth,
1540 ) -> fidl::Result<()> {
1541 encoder.debug_check_bounds::<CoverageDataProviderSetOptionsRequest>(offset);
1542 self.0.encode(encoder, offset + 0, depth)?;
1546 Ok(())
1547 }
1548 }
1549
1550 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1551 for CoverageDataProviderSetOptionsRequest
1552 {
1553 #[inline(always)]
1554 fn new_empty() -> Self {
1555 Self { options: fidl::new_empty!(Options, D) }
1556 }
1557
1558 #[inline]
1559 unsafe fn decode(
1560 &mut self,
1561 decoder: &mut fidl::encoding::Decoder<'_, D>,
1562 offset: usize,
1563 _depth: fidl::encoding::Depth,
1564 ) -> fidl::Result<()> {
1565 decoder.debug_check_bounds::<Self>(offset);
1566 fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _depth)?;
1568 Ok(())
1569 }
1570 }
1571
1572 impl fidl::encoding::ValueTypeMarker for ManagerStopRequest {
1573 type Borrowed<'a> = &'a Self;
1574 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1575 value
1576 }
1577 }
1578
1579 unsafe impl fidl::encoding::TypeMarker for ManagerStopRequest {
1580 type Owned = Self;
1581
1582 #[inline(always)]
1583 fn inline_align(_context: fidl::encoding::Context) -> usize {
1584 8
1585 }
1586
1587 #[inline(always)]
1588 fn inline_size(_context: fidl::encoding::Context) -> usize {
1589 16
1590 }
1591 }
1592
1593 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManagerStopRequest, D>
1594 for &ManagerStopRequest
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::<ManagerStopRequest>(offset);
1604 fidl::encoding::Encode::<ManagerStopRequest, D>::encode(
1606 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1607 &self.fuzzer_url,
1608 ),),
1609 encoder,
1610 offset,
1611 _depth,
1612 )
1613 }
1614 }
1615 unsafe impl<
1616 D: fidl::encoding::ResourceDialect,
1617 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1618 > fidl::encoding::Encode<ManagerStopRequest, D> for (T0,)
1619 {
1620 #[inline]
1621 unsafe fn encode(
1622 self,
1623 encoder: &mut fidl::encoding::Encoder<'_, D>,
1624 offset: usize,
1625 depth: fidl::encoding::Depth,
1626 ) -> fidl::Result<()> {
1627 encoder.debug_check_bounds::<ManagerStopRequest>(offset);
1628 self.0.encode(encoder, offset + 0, depth)?;
1632 Ok(())
1633 }
1634 }
1635
1636 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManagerStopRequest {
1637 #[inline(always)]
1638 fn new_empty() -> Self {
1639 Self { fuzzer_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1640 }
1641
1642 #[inline]
1643 unsafe fn decode(
1644 &mut self,
1645 decoder: &mut fidl::encoding::Decoder<'_, D>,
1646 offset: usize,
1647 _depth: fidl::encoding::Depth,
1648 ) -> fidl::Result<()> {
1649 decoder.debug_check_bounds::<Self>(offset);
1650 fidl::decode!(
1652 fidl::encoding::BoundedString<4096>,
1653 D,
1654 &mut self.fuzzer_url,
1655 decoder,
1656 offset + 0,
1657 _depth
1658 )?;
1659 Ok(())
1660 }
1661 }
1662
1663 impl fidl::encoding::ValueTypeMarker for MonitorUpdateRequest {
1664 type Borrowed<'a> = &'a Self;
1665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1666 value
1667 }
1668 }
1669
1670 unsafe impl fidl::encoding::TypeMarker for MonitorUpdateRequest {
1671 type Owned = Self;
1672
1673 #[inline(always)]
1674 fn inline_align(_context: fidl::encoding::Context) -> usize {
1675 8
1676 }
1677
1678 #[inline(always)]
1679 fn inline_size(_context: fidl::encoding::Context) -> usize {
1680 24
1681 }
1682 }
1683
1684 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MonitorUpdateRequest, D>
1685 for &MonitorUpdateRequest
1686 {
1687 #[inline]
1688 unsafe fn encode(
1689 self,
1690 encoder: &mut fidl::encoding::Encoder<'_, D>,
1691 offset: usize,
1692 _depth: fidl::encoding::Depth,
1693 ) -> fidl::Result<()> {
1694 encoder.debug_check_bounds::<MonitorUpdateRequest>(offset);
1695 fidl::encoding::Encode::<MonitorUpdateRequest, D>::encode(
1697 (
1698 <UpdateReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),
1699 <Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
1700 ),
1701 encoder,
1702 offset,
1703 _depth,
1704 )
1705 }
1706 }
1707 unsafe impl<
1708 D: fidl::encoding::ResourceDialect,
1709 T0: fidl::encoding::Encode<UpdateReason, D>,
1710 T1: fidl::encoding::Encode<Status, D>,
1711 > fidl::encoding::Encode<MonitorUpdateRequest, D> for (T0, T1)
1712 {
1713 #[inline]
1714 unsafe fn encode(
1715 self,
1716 encoder: &mut fidl::encoding::Encoder<'_, D>,
1717 offset: usize,
1718 depth: fidl::encoding::Depth,
1719 ) -> fidl::Result<()> {
1720 encoder.debug_check_bounds::<MonitorUpdateRequest>(offset);
1721 unsafe {
1724 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1725 (ptr as *mut u64).write_unaligned(0);
1726 }
1727 self.0.encode(encoder, offset + 0, depth)?;
1729 self.1.encode(encoder, offset + 8, depth)?;
1730 Ok(())
1731 }
1732 }
1733
1734 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MonitorUpdateRequest {
1735 #[inline(always)]
1736 fn new_empty() -> Self {
1737 Self { reason: fidl::new_empty!(UpdateReason, D), status: fidl::new_empty!(Status, D) }
1738 }
1739
1740 #[inline]
1741 unsafe fn decode(
1742 &mut self,
1743 decoder: &mut fidl::encoding::Decoder<'_, D>,
1744 offset: usize,
1745 _depth: fidl::encoding::Depth,
1746 ) -> fidl::Result<()> {
1747 decoder.debug_check_bounds::<Self>(offset);
1748 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1750 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1751 let mask = 0xffffffffffffff00u64;
1752 let maskedval = padval & mask;
1753 if maskedval != 0 {
1754 return Err(fidl::Error::NonZeroPadding {
1755 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1756 });
1757 }
1758 fidl::decode!(UpdateReason, D, &mut self.reason, decoder, offset + 0, _depth)?;
1759 fidl::decode!(Status, D, &mut self.status, decoder, offset + 8, _depth)?;
1760 Ok(())
1761 }
1762 }
1763
1764 impl fidl::encoding::ValueTypeMarker for ProcessStats {
1765 type Borrowed<'a> = &'a Self;
1766 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1767 value
1768 }
1769 }
1770
1771 unsafe impl fidl::encoding::TypeMarker for ProcessStats {
1772 type Owned = Self;
1773
1774 #[inline(always)]
1775 fn inline_align(_context: fidl::encoding::Context) -> usize {
1776 8
1777 }
1778
1779 #[inline(always)]
1780 fn inline_size(_context: fidl::encoding::Context) -> usize {
1781 72
1782 }
1783 #[inline(always)]
1784 fn encode_is_copy() -> bool {
1785 true
1786 }
1787
1788 #[inline(always)]
1789 fn decode_is_copy() -> bool {
1790 true
1791 }
1792 }
1793
1794 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProcessStats, D>
1795 for &ProcessStats
1796 {
1797 #[inline]
1798 unsafe fn encode(
1799 self,
1800 encoder: &mut fidl::encoding::Encoder<'_, D>,
1801 offset: usize,
1802 _depth: fidl::encoding::Depth,
1803 ) -> fidl::Result<()> {
1804 encoder.debug_check_bounds::<ProcessStats>(offset);
1805 unsafe {
1806 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1808 (buf_ptr as *mut ProcessStats)
1809 .write_unaligned((self as *const ProcessStats).read());
1810 }
1813 Ok(())
1814 }
1815 }
1816 unsafe impl<
1817 D: fidl::encoding::ResourceDialect,
1818 T0: fidl::encoding::Encode<u64, D>,
1819 T1: fidl::encoding::Encode<u64, D>,
1820 T2: fidl::encoding::Encode<u64, D>,
1821 T3: fidl::encoding::Encode<u64, D>,
1822 T4: fidl::encoding::Encode<u64, D>,
1823 T5: fidl::encoding::Encode<i64, D>,
1824 T6: fidl::encoding::Encode<i64, D>,
1825 T7: fidl::encoding::Encode<i64, D>,
1826 T8: fidl::encoding::Encode<i64, D>,
1827 > fidl::encoding::Encode<ProcessStats, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
1828 {
1829 #[inline]
1830 unsafe fn encode(
1831 self,
1832 encoder: &mut fidl::encoding::Encoder<'_, D>,
1833 offset: usize,
1834 depth: fidl::encoding::Depth,
1835 ) -> fidl::Result<()> {
1836 encoder.debug_check_bounds::<ProcessStats>(offset);
1837 self.0.encode(encoder, offset + 0, depth)?;
1841 self.1.encode(encoder, offset + 8, depth)?;
1842 self.2.encode(encoder, offset + 16, depth)?;
1843 self.3.encode(encoder, offset + 24, depth)?;
1844 self.4.encode(encoder, offset + 32, depth)?;
1845 self.5.encode(encoder, offset + 40, depth)?;
1846 self.6.encode(encoder, offset + 48, depth)?;
1847 self.7.encode(encoder, offset + 56, depth)?;
1848 self.8.encode(encoder, offset + 64, depth)?;
1849 Ok(())
1850 }
1851 }
1852
1853 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProcessStats {
1854 #[inline(always)]
1855 fn new_empty() -> Self {
1856 Self {
1857 koid: fidl::new_empty!(u64, D),
1858 mem_mapped_bytes: fidl::new_empty!(u64, D),
1859 mem_private_bytes: fidl::new_empty!(u64, D),
1860 mem_shared_bytes: fidl::new_empty!(u64, D),
1861 mem_scaled_shared_bytes: fidl::new_empty!(u64, D),
1862 cpu_time: fidl::new_empty!(i64, D),
1863 queue_time: fidl::new_empty!(i64, D),
1864 page_fault_time: fidl::new_empty!(i64, D),
1865 lock_contention_time: fidl::new_empty!(i64, D),
1866 }
1867 }
1868
1869 #[inline]
1870 unsafe fn decode(
1871 &mut self,
1872 decoder: &mut fidl::encoding::Decoder<'_, D>,
1873 offset: usize,
1874 _depth: fidl::encoding::Depth,
1875 ) -> fidl::Result<()> {
1876 decoder.debug_check_bounds::<Self>(offset);
1877 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1878 unsafe {
1881 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 72);
1882 }
1883 Ok(())
1884 }
1885 }
1886
1887 impl fidl::encoding::ValueTypeMarker for RegistryDisconnectRequest {
1888 type Borrowed<'a> = &'a Self;
1889 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1890 value
1891 }
1892 }
1893
1894 unsafe impl fidl::encoding::TypeMarker for RegistryDisconnectRequest {
1895 type Owned = Self;
1896
1897 #[inline(always)]
1898 fn inline_align(_context: fidl::encoding::Context) -> usize {
1899 8
1900 }
1901
1902 #[inline(always)]
1903 fn inline_size(_context: fidl::encoding::Context) -> usize {
1904 16
1905 }
1906 }
1907
1908 unsafe impl<D: fidl::encoding::ResourceDialect>
1909 fidl::encoding::Encode<RegistryDisconnectRequest, D> for &RegistryDisconnectRequest
1910 {
1911 #[inline]
1912 unsafe fn encode(
1913 self,
1914 encoder: &mut fidl::encoding::Encoder<'_, D>,
1915 offset: usize,
1916 _depth: fidl::encoding::Depth,
1917 ) -> fidl::Result<()> {
1918 encoder.debug_check_bounds::<RegistryDisconnectRequest>(offset);
1919 fidl::encoding::Encode::<RegistryDisconnectRequest, D>::encode(
1921 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
1922 &self.fuzzer_url,
1923 ),),
1924 encoder,
1925 offset,
1926 _depth,
1927 )
1928 }
1929 }
1930 unsafe impl<
1931 D: fidl::encoding::ResourceDialect,
1932 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1933 > fidl::encoding::Encode<RegistryDisconnectRequest, D> for (T0,)
1934 {
1935 #[inline]
1936 unsafe fn encode(
1937 self,
1938 encoder: &mut fidl::encoding::Encoder<'_, D>,
1939 offset: usize,
1940 depth: fidl::encoding::Depth,
1941 ) -> fidl::Result<()> {
1942 encoder.debug_check_bounds::<RegistryDisconnectRequest>(offset);
1943 self.0.encode(encoder, offset + 0, depth)?;
1947 Ok(())
1948 }
1949 }
1950
1951 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1952 for RegistryDisconnectRequest
1953 {
1954 #[inline(always)]
1955 fn new_empty() -> Self {
1956 Self { fuzzer_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
1957 }
1958
1959 #[inline]
1960 unsafe fn decode(
1961 &mut self,
1962 decoder: &mut fidl::encoding::Decoder<'_, D>,
1963 offset: usize,
1964 _depth: fidl::encoding::Depth,
1965 ) -> fidl::Result<()> {
1966 decoder.debug_check_bounds::<Self>(offset);
1967 fidl::decode!(
1969 fidl::encoding::BoundedString<4096>,
1970 D,
1971 &mut self.fuzzer_url,
1972 decoder,
1973 offset + 0,
1974 _depth
1975 )?;
1976 Ok(())
1977 }
1978 }
1979
1980 impl fidl::encoding::ValueTypeMarker for SanitizerOptions {
1981 type Borrowed<'a> = &'a Self;
1982 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1983 value
1984 }
1985 }
1986
1987 unsafe impl fidl::encoding::TypeMarker for SanitizerOptions {
1988 type Owned = Self;
1989
1990 #[inline(always)]
1991 fn inline_align(_context: fidl::encoding::Context) -> usize {
1992 8
1993 }
1994
1995 #[inline(always)]
1996 fn inline_size(_context: fidl::encoding::Context) -> usize {
1997 32
1998 }
1999 }
2000
2001 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SanitizerOptions, D>
2002 for &SanitizerOptions
2003 {
2004 #[inline]
2005 unsafe fn encode(
2006 self,
2007 encoder: &mut fidl::encoding::Encoder<'_, D>,
2008 offset: usize,
2009 _depth: fidl::encoding::Depth,
2010 ) -> fidl::Result<()> {
2011 encoder.debug_check_bounds::<SanitizerOptions>(offset);
2012 fidl::encoding::Encode::<SanitizerOptions, D>::encode(
2014 (
2015 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
2016 <fidl::encoding::BoundedString<8192> as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
2017 ),
2018 encoder, offset, _depth
2019 )
2020 }
2021 }
2022 unsafe impl<
2023 D: fidl::encoding::ResourceDialect,
2024 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<32>, D>,
2025 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<8192>, D>,
2026 > fidl::encoding::Encode<SanitizerOptions, D> for (T0, T1)
2027 {
2028 #[inline]
2029 unsafe fn encode(
2030 self,
2031 encoder: &mut fidl::encoding::Encoder<'_, D>,
2032 offset: usize,
2033 depth: fidl::encoding::Depth,
2034 ) -> fidl::Result<()> {
2035 encoder.debug_check_bounds::<SanitizerOptions>(offset);
2036 self.0.encode(encoder, offset + 0, depth)?;
2040 self.1.encode(encoder, offset + 16, depth)?;
2041 Ok(())
2042 }
2043 }
2044
2045 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SanitizerOptions {
2046 #[inline(always)]
2047 fn new_empty() -> Self {
2048 Self {
2049 name: fidl::new_empty!(fidl::encoding::BoundedString<32>, D),
2050 value: fidl::new_empty!(fidl::encoding::BoundedString<8192>, D),
2051 }
2052 }
2053
2054 #[inline]
2055 unsafe fn decode(
2056 &mut self,
2057 decoder: &mut fidl::encoding::Decoder<'_, D>,
2058 offset: usize,
2059 _depth: fidl::encoding::Depth,
2060 ) -> fidl::Result<()> {
2061 decoder.debug_check_bounds::<Self>(offset);
2062 fidl::decode!(
2064 fidl::encoding::BoundedString<32>,
2065 D,
2066 &mut self.name,
2067 decoder,
2068 offset + 0,
2069 _depth
2070 )?;
2071 fidl::decode!(
2072 fidl::encoding::BoundedString<8192>,
2073 D,
2074 &mut self.value,
2075 decoder,
2076 offset + 16,
2077 _depth
2078 )?;
2079 Ok(())
2080 }
2081 }
2082
2083 impl fidl::encoding::ValueTypeMarker for TargetAdapterGetParametersResponse {
2084 type Borrowed<'a> = &'a Self;
2085 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2086 value
2087 }
2088 }
2089
2090 unsafe impl fidl::encoding::TypeMarker for TargetAdapterGetParametersResponse {
2091 type Owned = Self;
2092
2093 #[inline(always)]
2094 fn inline_align(_context: fidl::encoding::Context) -> usize {
2095 8
2096 }
2097
2098 #[inline(always)]
2099 fn inline_size(_context: fidl::encoding::Context) -> usize {
2100 16
2101 }
2102 }
2103
2104 unsafe impl<D: fidl::encoding::ResourceDialect>
2105 fidl::encoding::Encode<TargetAdapterGetParametersResponse, D>
2106 for &TargetAdapterGetParametersResponse
2107 {
2108 #[inline]
2109 unsafe fn encode(
2110 self,
2111 encoder: &mut fidl::encoding::Encoder<'_, D>,
2112 offset: usize,
2113 _depth: fidl::encoding::Depth,
2114 ) -> fidl::Result<()> {
2115 encoder.debug_check_bounds::<TargetAdapterGetParametersResponse>(offset);
2116 fidl::encoding::Encode::<TargetAdapterGetParametersResponse, D>::encode(
2118 (
2119 <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
2120 ),
2121 encoder, offset, _depth
2122 )
2123 }
2124 }
2125 unsafe impl<
2126 D: fidl::encoding::ResourceDialect,
2127 T0: fidl::encoding::Encode<
2128 fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
2129 D,
2130 >,
2131 > fidl::encoding::Encode<TargetAdapterGetParametersResponse, D> for (T0,)
2132 {
2133 #[inline]
2134 unsafe fn encode(
2135 self,
2136 encoder: &mut fidl::encoding::Encoder<'_, D>,
2137 offset: usize,
2138 depth: fidl::encoding::Depth,
2139 ) -> fidl::Result<()> {
2140 encoder.debug_check_bounds::<TargetAdapterGetParametersResponse>(offset);
2141 self.0.encode(encoder, offset + 0, depth)?;
2145 Ok(())
2146 }
2147 }
2148
2149 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2150 for TargetAdapterGetParametersResponse
2151 {
2152 #[inline(always)]
2153 fn new_empty() -> Self {
2154 Self {
2155 parameters: fidl::new_empty!(
2156 fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
2157 D
2158 ),
2159 }
2160 }
2161
2162 #[inline]
2163 unsafe fn decode(
2164 &mut self,
2165 decoder: &mut fidl::encoding::Decoder<'_, D>,
2166 offset: usize,
2167 _depth: fidl::encoding::Depth,
2168 ) -> fidl::Result<()> {
2169 decoder.debug_check_bounds::<Self>(offset);
2170 fidl::decode!(
2172 fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
2173 D,
2174 &mut self.parameters,
2175 decoder,
2176 offset + 0,
2177 _depth
2178 )?;
2179 Ok(())
2180 }
2181 }
2182
2183 impl Options {
2184 #[inline(always)]
2185 fn max_ordinal_present(&self) -> u64 {
2186 if let Some(_) = self.output_flags {
2187 return 22;
2188 }
2189 if let Some(_) = self.sanitizer_options {
2190 return 21;
2191 }
2192 if let Some(_) = self.use_value_profile {
2193 return 20;
2194 }
2195 if let Some(_) = self.print_final_stats {
2196 return 19;
2197 }
2198 if let Some(_) = self.debug {
2199 return 18;
2200 }
2201 if let Some(_) = self.pulse_interval {
2202 return 17;
2203 }
2204 if let Some(_) = self.oom_exitcode {
2205 return 16;
2206 }
2207 if let Some(_) = self.leak_exitcode {
2208 return 15;
2209 }
2210 if let Some(_) = self.death_exitcode {
2211 return 14;
2212 }
2213 if let Some(_) = self.malloc_exitcode {
2214 return 13;
2215 }
2216 if let Some(_) = self.purge_interval {
2217 return 12;
2218 }
2219 if let Some(_) = self.oom_limit {
2220 return 11;
2221 }
2222 if let Some(_) = self.malloc_limit {
2223 return 10;
2224 }
2225 if let Some(_) = self.run_limit {
2226 return 9;
2227 }
2228 if let Some(_) = self.detect_leaks {
2229 return 8;
2230 }
2231 if let Some(_) = self.detect_exits {
2232 return 7;
2233 }
2234 if let Some(_) = self.dictionary_level {
2235 return 6;
2236 }
2237 if let Some(_) = self.mutation_depth {
2238 return 5;
2239 }
2240 if let Some(_) = self.max_input_size {
2241 return 4;
2242 }
2243 if let Some(_) = self.seed {
2244 return 3;
2245 }
2246 if let Some(_) = self.max_total_time {
2247 return 2;
2248 }
2249 if let Some(_) = self.runs {
2250 return 1;
2251 }
2252 0
2253 }
2254 }
2255
2256 impl fidl::encoding::ValueTypeMarker for Options {
2257 type Borrowed<'a> = &'a Self;
2258 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2259 value
2260 }
2261 }
2262
2263 unsafe impl fidl::encoding::TypeMarker for Options {
2264 type Owned = Self;
2265
2266 #[inline(always)]
2267 fn inline_align(_context: fidl::encoding::Context) -> usize {
2268 8
2269 }
2270
2271 #[inline(always)]
2272 fn inline_size(_context: fidl::encoding::Context) -> usize {
2273 16
2274 }
2275 }
2276
2277 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
2278 unsafe fn encode(
2279 self,
2280 encoder: &mut fidl::encoding::Encoder<'_, D>,
2281 offset: usize,
2282 mut depth: fidl::encoding::Depth,
2283 ) -> fidl::Result<()> {
2284 encoder.debug_check_bounds::<Options>(offset);
2285 let max_ordinal: u64 = self.max_ordinal_present();
2287 encoder.write_num(max_ordinal, offset);
2288 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2289 if max_ordinal == 0 {
2291 return Ok(());
2292 }
2293 depth.increment()?;
2294 let envelope_size = 8;
2295 let bytes_len = max_ordinal as usize * envelope_size;
2296 #[allow(unused_variables)]
2297 let offset = encoder.out_of_line_offset(bytes_len);
2298 let mut _prev_end_offset: usize = 0;
2299 if 1 > max_ordinal {
2300 return Ok(());
2301 }
2302
2303 let cur_offset: usize = (1 - 1) * envelope_size;
2306
2307 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2309
2310 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2315 self.runs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2316 encoder,
2317 offset + cur_offset,
2318 depth,
2319 )?;
2320
2321 _prev_end_offset = cur_offset + envelope_size;
2322 if 2 > max_ordinal {
2323 return Ok(());
2324 }
2325
2326 let cur_offset: usize = (2 - 1) * envelope_size;
2329
2330 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2332
2333 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2338 self.max_total_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2339 encoder,
2340 offset + cur_offset,
2341 depth,
2342 )?;
2343
2344 _prev_end_offset = cur_offset + envelope_size;
2345 if 3 > max_ordinal {
2346 return Ok(());
2347 }
2348
2349 let cur_offset: usize = (3 - 1) * envelope_size;
2352
2353 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2355
2356 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2361 self.seed.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2362 encoder,
2363 offset + cur_offset,
2364 depth,
2365 )?;
2366
2367 _prev_end_offset = cur_offset + envelope_size;
2368 if 4 > max_ordinal {
2369 return Ok(());
2370 }
2371
2372 let cur_offset: usize = (4 - 1) * envelope_size;
2375
2376 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2378
2379 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2384 self.max_input_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2385 encoder,
2386 offset + cur_offset,
2387 depth,
2388 )?;
2389
2390 _prev_end_offset = cur_offset + envelope_size;
2391 if 5 > max_ordinal {
2392 return Ok(());
2393 }
2394
2395 let cur_offset: usize = (5 - 1) * envelope_size;
2398
2399 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2401
2402 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2407 self.mutation_depth.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2408 encoder,
2409 offset + cur_offset,
2410 depth,
2411 )?;
2412
2413 _prev_end_offset = cur_offset + envelope_size;
2414 if 6 > max_ordinal {
2415 return Ok(());
2416 }
2417
2418 let cur_offset: usize = (6 - 1) * envelope_size;
2421
2422 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2424
2425 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2430 self.dictionary_level
2431 .as_ref()
2432 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2433 encoder,
2434 offset + cur_offset,
2435 depth,
2436 )?;
2437
2438 _prev_end_offset = cur_offset + envelope_size;
2439 if 7 > max_ordinal {
2440 return Ok(());
2441 }
2442
2443 let cur_offset: usize = (7 - 1) * envelope_size;
2446
2447 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2449
2450 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2455 self.detect_exits.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2456 encoder,
2457 offset + cur_offset,
2458 depth,
2459 )?;
2460
2461 _prev_end_offset = cur_offset + envelope_size;
2462 if 8 > max_ordinal {
2463 return Ok(());
2464 }
2465
2466 let cur_offset: usize = (8 - 1) * envelope_size;
2469
2470 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2472
2473 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2478 self.detect_leaks.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2479 encoder,
2480 offset + cur_offset,
2481 depth,
2482 )?;
2483
2484 _prev_end_offset = cur_offset + envelope_size;
2485 if 9 > max_ordinal {
2486 return Ok(());
2487 }
2488
2489 let cur_offset: usize = (9 - 1) * envelope_size;
2492
2493 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2495
2496 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2501 self.run_limit.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2502 encoder,
2503 offset + cur_offset,
2504 depth,
2505 )?;
2506
2507 _prev_end_offset = cur_offset + envelope_size;
2508 if 10 > max_ordinal {
2509 return Ok(());
2510 }
2511
2512 let cur_offset: usize = (10 - 1) * envelope_size;
2515
2516 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2518
2519 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2524 self.malloc_limit.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2525 encoder,
2526 offset + cur_offset,
2527 depth,
2528 )?;
2529
2530 _prev_end_offset = cur_offset + envelope_size;
2531 if 11 > max_ordinal {
2532 return Ok(());
2533 }
2534
2535 let cur_offset: usize = (11 - 1) * envelope_size;
2538
2539 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2541
2542 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2547 self.oom_limit.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2548 encoder,
2549 offset + cur_offset,
2550 depth,
2551 )?;
2552
2553 _prev_end_offset = cur_offset + envelope_size;
2554 if 12 > max_ordinal {
2555 return Ok(());
2556 }
2557
2558 let cur_offset: usize = (12 - 1) * envelope_size;
2561
2562 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2564
2565 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2570 self.purge_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2571 encoder,
2572 offset + cur_offset,
2573 depth,
2574 )?;
2575
2576 _prev_end_offset = cur_offset + envelope_size;
2577 if 13 > max_ordinal {
2578 return Ok(());
2579 }
2580
2581 let cur_offset: usize = (13 - 1) * envelope_size;
2584
2585 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2587
2588 fidl::encoding::encode_in_envelope_optional::<i32, D>(
2593 self.malloc_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2594 encoder,
2595 offset + cur_offset,
2596 depth,
2597 )?;
2598
2599 _prev_end_offset = cur_offset + envelope_size;
2600 if 14 > max_ordinal {
2601 return Ok(());
2602 }
2603
2604 let cur_offset: usize = (14 - 1) * envelope_size;
2607
2608 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2610
2611 fidl::encoding::encode_in_envelope_optional::<i32, D>(
2616 self.death_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2617 encoder,
2618 offset + cur_offset,
2619 depth,
2620 )?;
2621
2622 _prev_end_offset = cur_offset + envelope_size;
2623 if 15 > max_ordinal {
2624 return Ok(());
2625 }
2626
2627 let cur_offset: usize = (15 - 1) * envelope_size;
2630
2631 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2633
2634 fidl::encoding::encode_in_envelope_optional::<i32, D>(
2639 self.leak_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2640 encoder,
2641 offset + cur_offset,
2642 depth,
2643 )?;
2644
2645 _prev_end_offset = cur_offset + envelope_size;
2646 if 16 > max_ordinal {
2647 return Ok(());
2648 }
2649
2650 let cur_offset: usize = (16 - 1) * envelope_size;
2653
2654 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2656
2657 fidl::encoding::encode_in_envelope_optional::<i32, D>(
2662 self.oom_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2663 encoder,
2664 offset + cur_offset,
2665 depth,
2666 )?;
2667
2668 _prev_end_offset = cur_offset + envelope_size;
2669 if 17 > max_ordinal {
2670 return Ok(());
2671 }
2672
2673 let cur_offset: usize = (17 - 1) * envelope_size;
2676
2677 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2679
2680 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2685 self.pulse_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2686 encoder,
2687 offset + cur_offset,
2688 depth,
2689 )?;
2690
2691 _prev_end_offset = cur_offset + envelope_size;
2692 if 18 > max_ordinal {
2693 return Ok(());
2694 }
2695
2696 let cur_offset: usize = (18 - 1) * envelope_size;
2699
2700 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2702
2703 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2708 self.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2709 encoder,
2710 offset + cur_offset,
2711 depth,
2712 )?;
2713
2714 _prev_end_offset = cur_offset + envelope_size;
2715 if 19 > max_ordinal {
2716 return Ok(());
2717 }
2718
2719 let cur_offset: usize = (19 - 1) * envelope_size;
2722
2723 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2725
2726 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2731 self.print_final_stats
2732 .as_ref()
2733 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2734 encoder,
2735 offset + cur_offset,
2736 depth,
2737 )?;
2738
2739 _prev_end_offset = cur_offset + envelope_size;
2740 if 20 > max_ordinal {
2741 return Ok(());
2742 }
2743
2744 let cur_offset: usize = (20 - 1) * envelope_size;
2747
2748 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2750
2751 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2756 self.use_value_profile
2757 .as_ref()
2758 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2759 encoder,
2760 offset + cur_offset,
2761 depth,
2762 )?;
2763
2764 _prev_end_offset = cur_offset + envelope_size;
2765 if 21 > max_ordinal {
2766 return Ok(());
2767 }
2768
2769 let cur_offset: usize = (21 - 1) * envelope_size;
2772
2773 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2775
2776 fidl::encoding::encode_in_envelope_optional::<SanitizerOptions, D>(
2781 self.sanitizer_options
2782 .as_ref()
2783 .map(<SanitizerOptions as fidl::encoding::ValueTypeMarker>::borrow),
2784 encoder,
2785 offset + cur_offset,
2786 depth,
2787 )?;
2788
2789 _prev_end_offset = cur_offset + envelope_size;
2790 if 22 > max_ordinal {
2791 return Ok(());
2792 }
2793
2794 let cur_offset: usize = (22 - 1) * envelope_size;
2797
2798 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2800
2801 fidl::encoding::encode_in_envelope_optional::<OutputFlags, D>(
2806 self.output_flags
2807 .as_ref()
2808 .map(<OutputFlags as fidl::encoding::ValueTypeMarker>::borrow),
2809 encoder,
2810 offset + cur_offset,
2811 depth,
2812 )?;
2813
2814 _prev_end_offset = cur_offset + envelope_size;
2815
2816 Ok(())
2817 }
2818 }
2819
2820 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
2821 #[inline(always)]
2822 fn new_empty() -> Self {
2823 Self::default()
2824 }
2825
2826 unsafe fn decode(
2827 &mut self,
2828 decoder: &mut fidl::encoding::Decoder<'_, D>,
2829 offset: usize,
2830 mut depth: fidl::encoding::Depth,
2831 ) -> fidl::Result<()> {
2832 decoder.debug_check_bounds::<Self>(offset);
2833 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2834 None => return Err(fidl::Error::NotNullable),
2835 Some(len) => len,
2836 };
2837 if len == 0 {
2839 return Ok(());
2840 };
2841 depth.increment()?;
2842 let envelope_size = 8;
2843 let bytes_len = len * envelope_size;
2844 let offset = decoder.out_of_line_offset(bytes_len)?;
2845 let mut _next_ordinal_to_read = 0;
2847 let mut next_offset = offset;
2848 let end_offset = offset + bytes_len;
2849 _next_ordinal_to_read += 1;
2850 if next_offset >= end_offset {
2851 return Ok(());
2852 }
2853
2854 while _next_ordinal_to_read < 1 {
2856 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2857 _next_ordinal_to_read += 1;
2858 next_offset += envelope_size;
2859 }
2860
2861 let next_out_of_line = decoder.next_out_of_line();
2862 let handles_before = decoder.remaining_handles();
2863 if let Some((inlined, num_bytes, num_handles)) =
2864 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2865 {
2866 let member_inline_size =
2867 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2868 if inlined != (member_inline_size <= 4) {
2869 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2870 }
2871 let inner_offset;
2872 let mut inner_depth = depth.clone();
2873 if inlined {
2874 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2875 inner_offset = next_offset;
2876 } else {
2877 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2878 inner_depth.increment()?;
2879 }
2880 let val_ref = self.runs.get_or_insert_with(|| fidl::new_empty!(u32, D));
2881 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2882 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2883 {
2884 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2885 }
2886 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2887 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2888 }
2889 }
2890
2891 next_offset += envelope_size;
2892 _next_ordinal_to_read += 1;
2893 if next_offset >= end_offset {
2894 return Ok(());
2895 }
2896
2897 while _next_ordinal_to_read < 2 {
2899 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2900 _next_ordinal_to_read += 1;
2901 next_offset += envelope_size;
2902 }
2903
2904 let next_out_of_line = decoder.next_out_of_line();
2905 let handles_before = decoder.remaining_handles();
2906 if let Some((inlined, num_bytes, num_handles)) =
2907 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2908 {
2909 let member_inline_size =
2910 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2911 if inlined != (member_inline_size <= 4) {
2912 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2913 }
2914 let inner_offset;
2915 let mut inner_depth = depth.clone();
2916 if inlined {
2917 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2918 inner_offset = next_offset;
2919 } else {
2920 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2921 inner_depth.increment()?;
2922 }
2923 let val_ref = self.max_total_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
2924 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2925 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2926 {
2927 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2928 }
2929 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2930 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2931 }
2932 }
2933
2934 next_offset += envelope_size;
2935 _next_ordinal_to_read += 1;
2936 if next_offset >= end_offset {
2937 return Ok(());
2938 }
2939
2940 while _next_ordinal_to_read < 3 {
2942 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2943 _next_ordinal_to_read += 1;
2944 next_offset += envelope_size;
2945 }
2946
2947 let next_out_of_line = decoder.next_out_of_line();
2948 let handles_before = decoder.remaining_handles();
2949 if let Some((inlined, num_bytes, num_handles)) =
2950 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2951 {
2952 let member_inline_size =
2953 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2954 if inlined != (member_inline_size <= 4) {
2955 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2956 }
2957 let inner_offset;
2958 let mut inner_depth = depth.clone();
2959 if inlined {
2960 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2961 inner_offset = next_offset;
2962 } else {
2963 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2964 inner_depth.increment()?;
2965 }
2966 let val_ref = self.seed.get_or_insert_with(|| fidl::new_empty!(u32, D));
2967 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2968 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2969 {
2970 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2971 }
2972 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2973 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2974 }
2975 }
2976
2977 next_offset += envelope_size;
2978 _next_ordinal_to_read += 1;
2979 if next_offset >= end_offset {
2980 return Ok(());
2981 }
2982
2983 while _next_ordinal_to_read < 4 {
2985 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2986 _next_ordinal_to_read += 1;
2987 next_offset += envelope_size;
2988 }
2989
2990 let next_out_of_line = decoder.next_out_of_line();
2991 let handles_before = decoder.remaining_handles();
2992 if let Some((inlined, num_bytes, num_handles)) =
2993 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2994 {
2995 let member_inline_size =
2996 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2997 if inlined != (member_inline_size <= 4) {
2998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2999 }
3000 let inner_offset;
3001 let mut inner_depth = depth.clone();
3002 if inlined {
3003 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3004 inner_offset = next_offset;
3005 } else {
3006 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3007 inner_depth.increment()?;
3008 }
3009 let val_ref = self.max_input_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
3010 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3011 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3012 {
3013 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3014 }
3015 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3016 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3017 }
3018 }
3019
3020 next_offset += envelope_size;
3021 _next_ordinal_to_read += 1;
3022 if next_offset >= end_offset {
3023 return Ok(());
3024 }
3025
3026 while _next_ordinal_to_read < 5 {
3028 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3029 _next_ordinal_to_read += 1;
3030 next_offset += envelope_size;
3031 }
3032
3033 let next_out_of_line = decoder.next_out_of_line();
3034 let handles_before = decoder.remaining_handles();
3035 if let Some((inlined, num_bytes, num_handles)) =
3036 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3037 {
3038 let member_inline_size =
3039 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3040 if inlined != (member_inline_size <= 4) {
3041 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3042 }
3043 let inner_offset;
3044 let mut inner_depth = depth.clone();
3045 if inlined {
3046 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3047 inner_offset = next_offset;
3048 } else {
3049 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3050 inner_depth.increment()?;
3051 }
3052 let val_ref = self.mutation_depth.get_or_insert_with(|| fidl::new_empty!(u16, D));
3053 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3054 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3055 {
3056 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3057 }
3058 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3059 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3060 }
3061 }
3062
3063 next_offset += envelope_size;
3064 _next_ordinal_to_read += 1;
3065 if next_offset >= end_offset {
3066 return Ok(());
3067 }
3068
3069 while _next_ordinal_to_read < 6 {
3071 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3072 _next_ordinal_to_read += 1;
3073 next_offset += envelope_size;
3074 }
3075
3076 let next_out_of_line = decoder.next_out_of_line();
3077 let handles_before = decoder.remaining_handles();
3078 if let Some((inlined, num_bytes, num_handles)) =
3079 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3080 {
3081 let member_inline_size =
3082 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3083 if inlined != (member_inline_size <= 4) {
3084 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3085 }
3086 let inner_offset;
3087 let mut inner_depth = depth.clone();
3088 if inlined {
3089 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3090 inner_offset = next_offset;
3091 } else {
3092 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3093 inner_depth.increment()?;
3094 }
3095 let val_ref = self.dictionary_level.get_or_insert_with(|| fidl::new_empty!(u16, D));
3096 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3097 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3098 {
3099 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3100 }
3101 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3102 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3103 }
3104 }
3105
3106 next_offset += envelope_size;
3107 _next_ordinal_to_read += 1;
3108 if next_offset >= end_offset {
3109 return Ok(());
3110 }
3111
3112 while _next_ordinal_to_read < 7 {
3114 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3115 _next_ordinal_to_read += 1;
3116 next_offset += envelope_size;
3117 }
3118
3119 let next_out_of_line = decoder.next_out_of_line();
3120 let handles_before = decoder.remaining_handles();
3121 if let Some((inlined, num_bytes, num_handles)) =
3122 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3123 {
3124 let member_inline_size =
3125 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3126 if inlined != (member_inline_size <= 4) {
3127 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3128 }
3129 let inner_offset;
3130 let mut inner_depth = depth.clone();
3131 if inlined {
3132 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3133 inner_offset = next_offset;
3134 } else {
3135 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3136 inner_depth.increment()?;
3137 }
3138 let val_ref = self.detect_exits.get_or_insert_with(|| fidl::new_empty!(bool, D));
3139 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3140 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3141 {
3142 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3143 }
3144 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3145 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3146 }
3147 }
3148
3149 next_offset += envelope_size;
3150 _next_ordinal_to_read += 1;
3151 if next_offset >= end_offset {
3152 return Ok(());
3153 }
3154
3155 while _next_ordinal_to_read < 8 {
3157 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3158 _next_ordinal_to_read += 1;
3159 next_offset += envelope_size;
3160 }
3161
3162 let next_out_of_line = decoder.next_out_of_line();
3163 let handles_before = decoder.remaining_handles();
3164 if let Some((inlined, num_bytes, num_handles)) =
3165 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3166 {
3167 let member_inline_size =
3168 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3169 if inlined != (member_inline_size <= 4) {
3170 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3171 }
3172 let inner_offset;
3173 let mut inner_depth = depth.clone();
3174 if inlined {
3175 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3176 inner_offset = next_offset;
3177 } else {
3178 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3179 inner_depth.increment()?;
3180 }
3181 let val_ref = self.detect_leaks.get_or_insert_with(|| fidl::new_empty!(bool, D));
3182 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3183 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3184 {
3185 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3186 }
3187 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3188 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3189 }
3190 }
3191
3192 next_offset += envelope_size;
3193 _next_ordinal_to_read += 1;
3194 if next_offset >= end_offset {
3195 return Ok(());
3196 }
3197
3198 while _next_ordinal_to_read < 9 {
3200 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3201 _next_ordinal_to_read += 1;
3202 next_offset += envelope_size;
3203 }
3204
3205 let next_out_of_line = decoder.next_out_of_line();
3206 let handles_before = decoder.remaining_handles();
3207 if let Some((inlined, num_bytes, num_handles)) =
3208 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3209 {
3210 let member_inline_size =
3211 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3212 if inlined != (member_inline_size <= 4) {
3213 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3214 }
3215 let inner_offset;
3216 let mut inner_depth = depth.clone();
3217 if inlined {
3218 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3219 inner_offset = next_offset;
3220 } else {
3221 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3222 inner_depth.increment()?;
3223 }
3224 let val_ref = self.run_limit.get_or_insert_with(|| fidl::new_empty!(i64, D));
3225 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3226 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3227 {
3228 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3229 }
3230 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3231 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3232 }
3233 }
3234
3235 next_offset += envelope_size;
3236 _next_ordinal_to_read += 1;
3237 if next_offset >= end_offset {
3238 return Ok(());
3239 }
3240
3241 while _next_ordinal_to_read < 10 {
3243 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3244 _next_ordinal_to_read += 1;
3245 next_offset += envelope_size;
3246 }
3247
3248 let next_out_of_line = decoder.next_out_of_line();
3249 let handles_before = decoder.remaining_handles();
3250 if let Some((inlined, num_bytes, num_handles)) =
3251 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3252 {
3253 let member_inline_size =
3254 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3255 if inlined != (member_inline_size <= 4) {
3256 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3257 }
3258 let inner_offset;
3259 let mut inner_depth = depth.clone();
3260 if inlined {
3261 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3262 inner_offset = next_offset;
3263 } else {
3264 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3265 inner_depth.increment()?;
3266 }
3267 let val_ref = self.malloc_limit.get_or_insert_with(|| fidl::new_empty!(u64, D));
3268 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3269 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3270 {
3271 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3272 }
3273 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3274 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3275 }
3276 }
3277
3278 next_offset += envelope_size;
3279 _next_ordinal_to_read += 1;
3280 if next_offset >= end_offset {
3281 return Ok(());
3282 }
3283
3284 while _next_ordinal_to_read < 11 {
3286 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3287 _next_ordinal_to_read += 1;
3288 next_offset += envelope_size;
3289 }
3290
3291 let next_out_of_line = decoder.next_out_of_line();
3292 let handles_before = decoder.remaining_handles();
3293 if let Some((inlined, num_bytes, num_handles)) =
3294 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3295 {
3296 let member_inline_size =
3297 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3298 if inlined != (member_inline_size <= 4) {
3299 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3300 }
3301 let inner_offset;
3302 let mut inner_depth = depth.clone();
3303 if inlined {
3304 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3305 inner_offset = next_offset;
3306 } else {
3307 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3308 inner_depth.increment()?;
3309 }
3310 let val_ref = self.oom_limit.get_or_insert_with(|| fidl::new_empty!(u64, D));
3311 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3312 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3313 {
3314 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3315 }
3316 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3317 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3318 }
3319 }
3320
3321 next_offset += envelope_size;
3322 _next_ordinal_to_read += 1;
3323 if next_offset >= end_offset {
3324 return Ok(());
3325 }
3326
3327 while _next_ordinal_to_read < 12 {
3329 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3330 _next_ordinal_to_read += 1;
3331 next_offset += envelope_size;
3332 }
3333
3334 let next_out_of_line = decoder.next_out_of_line();
3335 let handles_before = decoder.remaining_handles();
3336 if let Some((inlined, num_bytes, num_handles)) =
3337 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3338 {
3339 let member_inline_size =
3340 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3341 if inlined != (member_inline_size <= 4) {
3342 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3343 }
3344 let inner_offset;
3345 let mut inner_depth = depth.clone();
3346 if inlined {
3347 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3348 inner_offset = next_offset;
3349 } else {
3350 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3351 inner_depth.increment()?;
3352 }
3353 let val_ref = self.purge_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
3354 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3355 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3356 {
3357 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3358 }
3359 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3360 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3361 }
3362 }
3363
3364 next_offset += envelope_size;
3365 _next_ordinal_to_read += 1;
3366 if next_offset >= end_offset {
3367 return Ok(());
3368 }
3369
3370 while _next_ordinal_to_read < 13 {
3372 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3373 _next_ordinal_to_read += 1;
3374 next_offset += envelope_size;
3375 }
3376
3377 let next_out_of_line = decoder.next_out_of_line();
3378 let handles_before = decoder.remaining_handles();
3379 if let Some((inlined, num_bytes, num_handles)) =
3380 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3381 {
3382 let member_inline_size =
3383 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3384 if inlined != (member_inline_size <= 4) {
3385 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3386 }
3387 let inner_offset;
3388 let mut inner_depth = depth.clone();
3389 if inlined {
3390 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3391 inner_offset = next_offset;
3392 } else {
3393 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3394 inner_depth.increment()?;
3395 }
3396 let val_ref = self.malloc_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3397 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3398 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3399 {
3400 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3401 }
3402 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3403 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3404 }
3405 }
3406
3407 next_offset += envelope_size;
3408 _next_ordinal_to_read += 1;
3409 if next_offset >= end_offset {
3410 return Ok(());
3411 }
3412
3413 while _next_ordinal_to_read < 14 {
3415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3416 _next_ordinal_to_read += 1;
3417 next_offset += envelope_size;
3418 }
3419
3420 let next_out_of_line = decoder.next_out_of_line();
3421 let handles_before = decoder.remaining_handles();
3422 if let Some((inlined, num_bytes, num_handles)) =
3423 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3424 {
3425 let member_inline_size =
3426 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3427 if inlined != (member_inline_size <= 4) {
3428 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3429 }
3430 let inner_offset;
3431 let mut inner_depth = depth.clone();
3432 if inlined {
3433 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3434 inner_offset = next_offset;
3435 } else {
3436 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3437 inner_depth.increment()?;
3438 }
3439 let val_ref = self.death_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3440 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3441 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3442 {
3443 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3444 }
3445 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3446 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3447 }
3448 }
3449
3450 next_offset += envelope_size;
3451 _next_ordinal_to_read += 1;
3452 if next_offset >= end_offset {
3453 return Ok(());
3454 }
3455
3456 while _next_ordinal_to_read < 15 {
3458 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3459 _next_ordinal_to_read += 1;
3460 next_offset += envelope_size;
3461 }
3462
3463 let next_out_of_line = decoder.next_out_of_line();
3464 let handles_before = decoder.remaining_handles();
3465 if let Some((inlined, num_bytes, num_handles)) =
3466 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3467 {
3468 let member_inline_size =
3469 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3470 if inlined != (member_inline_size <= 4) {
3471 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3472 }
3473 let inner_offset;
3474 let mut inner_depth = depth.clone();
3475 if inlined {
3476 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3477 inner_offset = next_offset;
3478 } else {
3479 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3480 inner_depth.increment()?;
3481 }
3482 let val_ref = self.leak_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3483 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3484 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3485 {
3486 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3487 }
3488 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3489 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3490 }
3491 }
3492
3493 next_offset += envelope_size;
3494 _next_ordinal_to_read += 1;
3495 if next_offset >= end_offset {
3496 return Ok(());
3497 }
3498
3499 while _next_ordinal_to_read < 16 {
3501 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3502 _next_ordinal_to_read += 1;
3503 next_offset += envelope_size;
3504 }
3505
3506 let next_out_of_line = decoder.next_out_of_line();
3507 let handles_before = decoder.remaining_handles();
3508 if let Some((inlined, num_bytes, num_handles)) =
3509 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3510 {
3511 let member_inline_size =
3512 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3513 if inlined != (member_inline_size <= 4) {
3514 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3515 }
3516 let inner_offset;
3517 let mut inner_depth = depth.clone();
3518 if inlined {
3519 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3520 inner_offset = next_offset;
3521 } else {
3522 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3523 inner_depth.increment()?;
3524 }
3525 let val_ref = self.oom_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
3526 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3527 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3528 {
3529 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3530 }
3531 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3532 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3533 }
3534 }
3535
3536 next_offset += envelope_size;
3537 _next_ordinal_to_read += 1;
3538 if next_offset >= end_offset {
3539 return Ok(());
3540 }
3541
3542 while _next_ordinal_to_read < 17 {
3544 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3545 _next_ordinal_to_read += 1;
3546 next_offset += envelope_size;
3547 }
3548
3549 let next_out_of_line = decoder.next_out_of_line();
3550 let handles_before = decoder.remaining_handles();
3551 if let Some((inlined, num_bytes, num_handles)) =
3552 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3553 {
3554 let member_inline_size =
3555 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3556 if inlined != (member_inline_size <= 4) {
3557 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3558 }
3559 let inner_offset;
3560 let mut inner_depth = depth.clone();
3561 if inlined {
3562 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3563 inner_offset = next_offset;
3564 } else {
3565 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3566 inner_depth.increment()?;
3567 }
3568 let val_ref = self.pulse_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
3569 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3570 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3571 {
3572 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3573 }
3574 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3575 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3576 }
3577 }
3578
3579 next_offset += envelope_size;
3580 _next_ordinal_to_read += 1;
3581 if next_offset >= end_offset {
3582 return Ok(());
3583 }
3584
3585 while _next_ordinal_to_read < 18 {
3587 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3588 _next_ordinal_to_read += 1;
3589 next_offset += envelope_size;
3590 }
3591
3592 let next_out_of_line = decoder.next_out_of_line();
3593 let handles_before = decoder.remaining_handles();
3594 if let Some((inlined, num_bytes, num_handles)) =
3595 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3596 {
3597 let member_inline_size =
3598 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3599 if inlined != (member_inline_size <= 4) {
3600 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3601 }
3602 let inner_offset;
3603 let mut inner_depth = depth.clone();
3604 if inlined {
3605 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3606 inner_offset = next_offset;
3607 } else {
3608 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3609 inner_depth.increment()?;
3610 }
3611 let val_ref = self.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
3612 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3613 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3614 {
3615 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3616 }
3617 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3618 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3619 }
3620 }
3621
3622 next_offset += envelope_size;
3623 _next_ordinal_to_read += 1;
3624 if next_offset >= end_offset {
3625 return Ok(());
3626 }
3627
3628 while _next_ordinal_to_read < 19 {
3630 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3631 _next_ordinal_to_read += 1;
3632 next_offset += envelope_size;
3633 }
3634
3635 let next_out_of_line = decoder.next_out_of_line();
3636 let handles_before = decoder.remaining_handles();
3637 if let Some((inlined, num_bytes, num_handles)) =
3638 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3639 {
3640 let member_inline_size =
3641 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3642 if inlined != (member_inline_size <= 4) {
3643 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3644 }
3645 let inner_offset;
3646 let mut inner_depth = depth.clone();
3647 if inlined {
3648 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3649 inner_offset = next_offset;
3650 } else {
3651 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3652 inner_depth.increment()?;
3653 }
3654 let val_ref =
3655 self.print_final_stats.get_or_insert_with(|| fidl::new_empty!(bool, D));
3656 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3657 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3658 {
3659 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3660 }
3661 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3662 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3663 }
3664 }
3665
3666 next_offset += envelope_size;
3667 _next_ordinal_to_read += 1;
3668 if next_offset >= end_offset {
3669 return Ok(());
3670 }
3671
3672 while _next_ordinal_to_read < 20 {
3674 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3675 _next_ordinal_to_read += 1;
3676 next_offset += envelope_size;
3677 }
3678
3679 let next_out_of_line = decoder.next_out_of_line();
3680 let handles_before = decoder.remaining_handles();
3681 if let Some((inlined, num_bytes, num_handles)) =
3682 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3683 {
3684 let member_inline_size =
3685 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3686 if inlined != (member_inline_size <= 4) {
3687 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3688 }
3689 let inner_offset;
3690 let mut inner_depth = depth.clone();
3691 if inlined {
3692 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3693 inner_offset = next_offset;
3694 } else {
3695 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3696 inner_depth.increment()?;
3697 }
3698 let val_ref =
3699 self.use_value_profile.get_or_insert_with(|| fidl::new_empty!(bool, D));
3700 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3701 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3702 {
3703 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3704 }
3705 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3706 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3707 }
3708 }
3709
3710 next_offset += envelope_size;
3711 _next_ordinal_to_read += 1;
3712 if next_offset >= end_offset {
3713 return Ok(());
3714 }
3715
3716 while _next_ordinal_to_read < 21 {
3718 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3719 _next_ordinal_to_read += 1;
3720 next_offset += envelope_size;
3721 }
3722
3723 let next_out_of_line = decoder.next_out_of_line();
3724 let handles_before = decoder.remaining_handles();
3725 if let Some((inlined, num_bytes, num_handles)) =
3726 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3727 {
3728 let member_inline_size =
3729 <SanitizerOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3730 if inlined != (member_inline_size <= 4) {
3731 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3732 }
3733 let inner_offset;
3734 let mut inner_depth = depth.clone();
3735 if inlined {
3736 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3737 inner_offset = next_offset;
3738 } else {
3739 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3740 inner_depth.increment()?;
3741 }
3742 let val_ref = self
3743 .sanitizer_options
3744 .get_or_insert_with(|| fidl::new_empty!(SanitizerOptions, D));
3745 fidl::decode!(SanitizerOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
3746 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3747 {
3748 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3749 }
3750 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3751 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3752 }
3753 }
3754
3755 next_offset += envelope_size;
3756 _next_ordinal_to_read += 1;
3757 if next_offset >= end_offset {
3758 return Ok(());
3759 }
3760
3761 while _next_ordinal_to_read < 22 {
3763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3764 _next_ordinal_to_read += 1;
3765 next_offset += envelope_size;
3766 }
3767
3768 let next_out_of_line = decoder.next_out_of_line();
3769 let handles_before = decoder.remaining_handles();
3770 if let Some((inlined, num_bytes, num_handles)) =
3771 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3772 {
3773 let member_inline_size =
3774 <OutputFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3775 if inlined != (member_inline_size <= 4) {
3776 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3777 }
3778 let inner_offset;
3779 let mut inner_depth = depth.clone();
3780 if inlined {
3781 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3782 inner_offset = next_offset;
3783 } else {
3784 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3785 inner_depth.increment()?;
3786 }
3787 let val_ref =
3788 self.output_flags.get_or_insert_with(|| fidl::new_empty!(OutputFlags, D));
3789 fidl::decode!(OutputFlags, D, val_ref, decoder, inner_offset, inner_depth)?;
3790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3791 {
3792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3793 }
3794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3796 }
3797 }
3798
3799 next_offset += envelope_size;
3800
3801 while next_offset < end_offset {
3803 _next_ordinal_to_read += 1;
3804 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3805 next_offset += envelope_size;
3806 }
3807
3808 Ok(())
3809 }
3810 }
3811
3812 impl Status {
3813 #[inline(always)]
3814 fn max_ordinal_present(&self) -> u64 {
3815 if let Some(_) = self.process_stats {
3816 return 8;
3817 }
3818 if let Some(_) = self.corpus_total_size {
3819 return 7;
3820 }
3821 if let Some(_) = self.corpus_num_inputs {
3822 return 6;
3823 }
3824 if let Some(_) = self.covered_features {
3825 return 5;
3826 }
3827 if let Some(_) = self.covered_pcs {
3828 return 4;
3829 }
3830 if let Some(_) = self.elapsed {
3831 return 3;
3832 }
3833 if let Some(_) = self.runs {
3834 return 2;
3835 }
3836 if let Some(_) = self.running {
3837 return 1;
3838 }
3839 0
3840 }
3841 }
3842
3843 impl fidl::encoding::ValueTypeMarker for Status {
3844 type Borrowed<'a> = &'a Self;
3845 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3846 value
3847 }
3848 }
3849
3850 unsafe impl fidl::encoding::TypeMarker for Status {
3851 type Owned = Self;
3852
3853 #[inline(always)]
3854 fn inline_align(_context: fidl::encoding::Context) -> usize {
3855 8
3856 }
3857
3858 #[inline(always)]
3859 fn inline_size(_context: fidl::encoding::Context) -> usize {
3860 16
3861 }
3862 }
3863
3864 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Status, D> for &Status {
3865 unsafe fn encode(
3866 self,
3867 encoder: &mut fidl::encoding::Encoder<'_, D>,
3868 offset: usize,
3869 mut depth: fidl::encoding::Depth,
3870 ) -> fidl::Result<()> {
3871 encoder.debug_check_bounds::<Status>(offset);
3872 let max_ordinal: u64 = self.max_ordinal_present();
3874 encoder.write_num(max_ordinal, offset);
3875 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3876 if max_ordinal == 0 {
3878 return Ok(());
3879 }
3880 depth.increment()?;
3881 let envelope_size = 8;
3882 let bytes_len = max_ordinal as usize * envelope_size;
3883 #[allow(unused_variables)]
3884 let offset = encoder.out_of_line_offset(bytes_len);
3885 let mut _prev_end_offset: usize = 0;
3886 if 1 > max_ordinal {
3887 return Ok(());
3888 }
3889
3890 let cur_offset: usize = (1 - 1) * envelope_size;
3893
3894 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3896
3897 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3902 self.running.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3903 encoder,
3904 offset + cur_offset,
3905 depth,
3906 )?;
3907
3908 _prev_end_offset = cur_offset + envelope_size;
3909 if 2 > max_ordinal {
3910 return Ok(());
3911 }
3912
3913 let cur_offset: usize = (2 - 1) * envelope_size;
3916
3917 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3919
3920 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3925 self.runs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3926 encoder,
3927 offset + cur_offset,
3928 depth,
3929 )?;
3930
3931 _prev_end_offset = cur_offset + envelope_size;
3932 if 3 > max_ordinal {
3933 return Ok(());
3934 }
3935
3936 let cur_offset: usize = (3 - 1) * envelope_size;
3939
3940 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3942
3943 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3948 self.elapsed.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3949 encoder,
3950 offset + cur_offset,
3951 depth,
3952 )?;
3953
3954 _prev_end_offset = cur_offset + envelope_size;
3955 if 4 > max_ordinal {
3956 return Ok(());
3957 }
3958
3959 let cur_offset: usize = (4 - 1) * envelope_size;
3962
3963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3965
3966 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3971 self.covered_pcs.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3972 encoder,
3973 offset + cur_offset,
3974 depth,
3975 )?;
3976
3977 _prev_end_offset = cur_offset + envelope_size;
3978 if 5 > max_ordinal {
3979 return Ok(());
3980 }
3981
3982 let cur_offset: usize = (5 - 1) * envelope_size;
3985
3986 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3988
3989 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3994 self.covered_features
3995 .as_ref()
3996 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3997 encoder,
3998 offset + cur_offset,
3999 depth,
4000 )?;
4001
4002 _prev_end_offset = cur_offset + envelope_size;
4003 if 6 > max_ordinal {
4004 return Ok(());
4005 }
4006
4007 let cur_offset: usize = (6 - 1) * envelope_size;
4010
4011 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4013
4014 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4019 self.corpus_num_inputs
4020 .as_ref()
4021 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4022 encoder,
4023 offset + cur_offset,
4024 depth,
4025 )?;
4026
4027 _prev_end_offset = cur_offset + envelope_size;
4028 if 7 > max_ordinal {
4029 return Ok(());
4030 }
4031
4032 let cur_offset: usize = (7 - 1) * envelope_size;
4035
4036 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4038
4039 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4044 self.corpus_total_size
4045 .as_ref()
4046 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4047 encoder,
4048 offset + cur_offset,
4049 depth,
4050 )?;
4051
4052 _prev_end_offset = cur_offset + envelope_size;
4053 if 8 > max_ordinal {
4054 return Ok(());
4055 }
4056
4057 let cur_offset: usize = (8 - 1) * envelope_size;
4060
4061 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4063
4064 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProcessStats, 256>, D>(
4069 self.process_stats.as_ref().map(<fidl::encoding::Vector<ProcessStats, 256> as fidl::encoding::ValueTypeMarker>::borrow),
4070 encoder, offset + cur_offset, depth
4071 )?;
4072
4073 _prev_end_offset = cur_offset + envelope_size;
4074
4075 Ok(())
4076 }
4077 }
4078
4079 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Status {
4080 #[inline(always)]
4081 fn new_empty() -> Self {
4082 Self::default()
4083 }
4084
4085 unsafe fn decode(
4086 &mut self,
4087 decoder: &mut fidl::encoding::Decoder<'_, D>,
4088 offset: usize,
4089 mut depth: fidl::encoding::Depth,
4090 ) -> fidl::Result<()> {
4091 decoder.debug_check_bounds::<Self>(offset);
4092 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4093 None => return Err(fidl::Error::NotNullable),
4094 Some(len) => len,
4095 };
4096 if len == 0 {
4098 return Ok(());
4099 };
4100 depth.increment()?;
4101 let envelope_size = 8;
4102 let bytes_len = len * envelope_size;
4103 let offset = decoder.out_of_line_offset(bytes_len)?;
4104 let mut _next_ordinal_to_read = 0;
4106 let mut next_offset = offset;
4107 let end_offset = offset + bytes_len;
4108 _next_ordinal_to_read += 1;
4109 if next_offset >= end_offset {
4110 return Ok(());
4111 }
4112
4113 while _next_ordinal_to_read < 1 {
4115 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4116 _next_ordinal_to_read += 1;
4117 next_offset += envelope_size;
4118 }
4119
4120 let next_out_of_line = decoder.next_out_of_line();
4121 let handles_before = decoder.remaining_handles();
4122 if let Some((inlined, num_bytes, num_handles)) =
4123 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4124 {
4125 let member_inline_size =
4126 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4127 if inlined != (member_inline_size <= 4) {
4128 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4129 }
4130 let inner_offset;
4131 let mut inner_depth = depth.clone();
4132 if inlined {
4133 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4134 inner_offset = next_offset;
4135 } else {
4136 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4137 inner_depth.increment()?;
4138 }
4139 let val_ref = self.running.get_or_insert_with(|| fidl::new_empty!(bool, D));
4140 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4141 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4142 {
4143 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4144 }
4145 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4146 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4147 }
4148 }
4149
4150 next_offset += envelope_size;
4151 _next_ordinal_to_read += 1;
4152 if next_offset >= end_offset {
4153 return Ok(());
4154 }
4155
4156 while _next_ordinal_to_read < 2 {
4158 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4159 _next_ordinal_to_read += 1;
4160 next_offset += envelope_size;
4161 }
4162
4163 let next_out_of_line = decoder.next_out_of_line();
4164 let handles_before = decoder.remaining_handles();
4165 if let Some((inlined, num_bytes, num_handles)) =
4166 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4167 {
4168 let member_inline_size =
4169 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4170 if inlined != (member_inline_size <= 4) {
4171 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4172 }
4173 let inner_offset;
4174 let mut inner_depth = depth.clone();
4175 if inlined {
4176 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4177 inner_offset = next_offset;
4178 } else {
4179 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4180 inner_depth.increment()?;
4181 }
4182 let val_ref = self.runs.get_or_insert_with(|| fidl::new_empty!(u32, D));
4183 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4184 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4185 {
4186 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4187 }
4188 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4189 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4190 }
4191 }
4192
4193 next_offset += envelope_size;
4194 _next_ordinal_to_read += 1;
4195 if next_offset >= end_offset {
4196 return Ok(());
4197 }
4198
4199 while _next_ordinal_to_read < 3 {
4201 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4202 _next_ordinal_to_read += 1;
4203 next_offset += envelope_size;
4204 }
4205
4206 let next_out_of_line = decoder.next_out_of_line();
4207 let handles_before = decoder.remaining_handles();
4208 if let Some((inlined, num_bytes, num_handles)) =
4209 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4210 {
4211 let member_inline_size =
4212 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4213 if inlined != (member_inline_size <= 4) {
4214 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4215 }
4216 let inner_offset;
4217 let mut inner_depth = depth.clone();
4218 if inlined {
4219 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4220 inner_offset = next_offset;
4221 } else {
4222 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4223 inner_depth.increment()?;
4224 }
4225 let val_ref = self.elapsed.get_or_insert_with(|| fidl::new_empty!(i64, D));
4226 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4227 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4228 {
4229 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4230 }
4231 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4232 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4233 }
4234 }
4235
4236 next_offset += envelope_size;
4237 _next_ordinal_to_read += 1;
4238 if next_offset >= end_offset {
4239 return Ok(());
4240 }
4241
4242 while _next_ordinal_to_read < 4 {
4244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4245 _next_ordinal_to_read += 1;
4246 next_offset += envelope_size;
4247 }
4248
4249 let next_out_of_line = decoder.next_out_of_line();
4250 let handles_before = decoder.remaining_handles();
4251 if let Some((inlined, num_bytes, num_handles)) =
4252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4253 {
4254 let member_inline_size =
4255 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4256 if inlined != (member_inline_size <= 4) {
4257 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4258 }
4259 let inner_offset;
4260 let mut inner_depth = depth.clone();
4261 if inlined {
4262 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4263 inner_offset = next_offset;
4264 } else {
4265 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4266 inner_depth.increment()?;
4267 }
4268 let val_ref = self.covered_pcs.get_or_insert_with(|| fidl::new_empty!(u64, D));
4269 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4270 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4271 {
4272 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4273 }
4274 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4275 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4276 }
4277 }
4278
4279 next_offset += envelope_size;
4280 _next_ordinal_to_read += 1;
4281 if next_offset >= end_offset {
4282 return Ok(());
4283 }
4284
4285 while _next_ordinal_to_read < 5 {
4287 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4288 _next_ordinal_to_read += 1;
4289 next_offset += envelope_size;
4290 }
4291
4292 let next_out_of_line = decoder.next_out_of_line();
4293 let handles_before = decoder.remaining_handles();
4294 if let Some((inlined, num_bytes, num_handles)) =
4295 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4296 {
4297 let member_inline_size =
4298 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4299 if inlined != (member_inline_size <= 4) {
4300 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4301 }
4302 let inner_offset;
4303 let mut inner_depth = depth.clone();
4304 if inlined {
4305 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4306 inner_offset = next_offset;
4307 } else {
4308 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4309 inner_depth.increment()?;
4310 }
4311 let val_ref = self.covered_features.get_or_insert_with(|| fidl::new_empty!(u64, D));
4312 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4313 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4314 {
4315 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4316 }
4317 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4318 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4319 }
4320 }
4321
4322 next_offset += envelope_size;
4323 _next_ordinal_to_read += 1;
4324 if next_offset >= end_offset {
4325 return Ok(());
4326 }
4327
4328 while _next_ordinal_to_read < 6 {
4330 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4331 _next_ordinal_to_read += 1;
4332 next_offset += envelope_size;
4333 }
4334
4335 let next_out_of_line = decoder.next_out_of_line();
4336 let handles_before = decoder.remaining_handles();
4337 if let Some((inlined, num_bytes, num_handles)) =
4338 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4339 {
4340 let member_inline_size =
4341 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4342 if inlined != (member_inline_size <= 4) {
4343 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4344 }
4345 let inner_offset;
4346 let mut inner_depth = depth.clone();
4347 if inlined {
4348 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4349 inner_offset = next_offset;
4350 } else {
4351 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4352 inner_depth.increment()?;
4353 }
4354 let val_ref =
4355 self.corpus_num_inputs.get_or_insert_with(|| fidl::new_empty!(u64, D));
4356 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4357 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4358 {
4359 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4360 }
4361 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4362 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4363 }
4364 }
4365
4366 next_offset += envelope_size;
4367 _next_ordinal_to_read += 1;
4368 if next_offset >= end_offset {
4369 return Ok(());
4370 }
4371
4372 while _next_ordinal_to_read < 7 {
4374 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4375 _next_ordinal_to_read += 1;
4376 next_offset += envelope_size;
4377 }
4378
4379 let next_out_of_line = decoder.next_out_of_line();
4380 let handles_before = decoder.remaining_handles();
4381 if let Some((inlined, num_bytes, num_handles)) =
4382 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4383 {
4384 let member_inline_size =
4385 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4386 if inlined != (member_inline_size <= 4) {
4387 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4388 }
4389 let inner_offset;
4390 let mut inner_depth = depth.clone();
4391 if inlined {
4392 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4393 inner_offset = next_offset;
4394 } else {
4395 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4396 inner_depth.increment()?;
4397 }
4398 let val_ref =
4399 self.corpus_total_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
4400 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4401 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4402 {
4403 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4404 }
4405 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4406 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4407 }
4408 }
4409
4410 next_offset += envelope_size;
4411 _next_ordinal_to_read += 1;
4412 if next_offset >= end_offset {
4413 return Ok(());
4414 }
4415
4416 while _next_ordinal_to_read < 8 {
4418 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4419 _next_ordinal_to_read += 1;
4420 next_offset += envelope_size;
4421 }
4422
4423 let next_out_of_line = decoder.next_out_of_line();
4424 let handles_before = decoder.remaining_handles();
4425 if let Some((inlined, num_bytes, num_handles)) =
4426 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4427 {
4428 let member_inline_size = <fidl::encoding::Vector<ProcessStats, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4429 if inlined != (member_inline_size <= 4) {
4430 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4431 }
4432 let inner_offset;
4433 let mut inner_depth = depth.clone();
4434 if inlined {
4435 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4436 inner_offset = next_offset;
4437 } else {
4438 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4439 inner_depth.increment()?;
4440 }
4441 let val_ref = self.process_stats.get_or_insert_with(
4442 || fidl::new_empty!(fidl::encoding::Vector<ProcessStats, 256>, D),
4443 );
4444 fidl::decode!(fidl::encoding::Vector<ProcessStats, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
4445 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4446 {
4447 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4448 }
4449 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4450 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4451 }
4452 }
4453
4454 next_offset += envelope_size;
4455
4456 while next_offset < end_offset {
4458 _next_ordinal_to_read += 1;
4459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4460 next_offset += envelope_size;
4461 }
4462
4463 Ok(())
4464 }
4465 }
4466}