fidl_fuchsia_starnix_psi__common/
fidl_fuchsia_starnix_psi__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Clone, Debug, Default, PartialEq)]
12pub struct PsiProviderWatchMemoryStallRequest {
13    pub kind: Option<u32>,
14    pub threshold: Option<i64>,
15    pub window: Option<i64>,
16    #[doc(hidden)]
17    pub __source_breaking: fidl::marker::SourceBreaking,
18}
19
20impl fidl::Persistable for PsiProviderWatchMemoryStallRequest {}
21
22#[derive(Clone, Debug, Default, PartialEq)]
23pub struct PsiProviderGetMemoryPressureStatsResponse {
24    /// Stats about time spent with at least one thread stalling.
25    pub some: Option<PsiStats>,
26    /// Stats about time spent with all threads stalling.
27    pub full: Option<PsiStats>,
28    #[doc(hidden)]
29    pub __source_breaking: fidl::marker::SourceBreaking,
30}
31
32impl fidl::Persistable for PsiProviderGetMemoryPressureStatsResponse {}
33
34#[derive(Clone, Debug, Default, PartialEq)]
35pub struct PsiStats {
36    /// Average fraction of time spent stalling in the last 10 seconds (0-1).
37    pub avg10: Option<f64>,
38    /// Average fraction of time spent stalling in the last 60 seconds (0-1).
39    pub avg60: Option<f64>,
40    /// Average fraction of time spent stalling in the last 300 seconds (0-1).
41    pub avg300: Option<f64>,
42    /// Cumulative time spent stalling since boot (using the monotonic clock as
43    /// the time base).
44    pub total: Option<i64>,
45    #[doc(hidden)]
46    pub __source_breaking: fidl::marker::SourceBreaking,
47}
48
49impl fidl::Persistable for PsiStats {}
50
51pub mod psi_provider_ordinals {
52    pub const GET_MEMORY_PRESSURE_STATS: u64 = 0x2122b26519bc6d20;
53    pub const WATCH_MEMORY_STALL: u64 = 0x1c45c961cce60400;
54}
55
56mod internal {
57    use super::*;
58
59    impl PsiProviderWatchMemoryStallRequest {
60        #[inline(always)]
61        fn max_ordinal_present(&self) -> u64 {
62            if let Some(_) = self.window {
63                return 3;
64            }
65            if let Some(_) = self.threshold {
66                return 2;
67            }
68            if let Some(_) = self.kind {
69                return 1;
70            }
71            0
72        }
73    }
74
75    impl fidl::encoding::ValueTypeMarker for PsiProviderWatchMemoryStallRequest {
76        type Borrowed<'a> = &'a Self;
77        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
78            value
79        }
80    }
81
82    unsafe impl fidl::encoding::TypeMarker for PsiProviderWatchMemoryStallRequest {
83        type Owned = Self;
84
85        #[inline(always)]
86        fn inline_align(_context: fidl::encoding::Context) -> usize {
87            8
88        }
89
90        #[inline(always)]
91        fn inline_size(_context: fidl::encoding::Context) -> usize {
92            16
93        }
94    }
95
96    unsafe impl<D: fidl::encoding::ResourceDialect>
97        fidl::encoding::Encode<PsiProviderWatchMemoryStallRequest, D>
98        for &PsiProviderWatchMemoryStallRequest
99    {
100        unsafe fn encode(
101            self,
102            encoder: &mut fidl::encoding::Encoder<'_, D>,
103            offset: usize,
104            mut depth: fidl::encoding::Depth,
105        ) -> fidl::Result<()> {
106            encoder.debug_check_bounds::<PsiProviderWatchMemoryStallRequest>(offset);
107            // Vector header
108            let max_ordinal: u64 = self.max_ordinal_present();
109            encoder.write_num(max_ordinal, offset);
110            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
111            // Calling encoder.out_of_line_offset(0) is not allowed.
112            if max_ordinal == 0 {
113                return Ok(());
114            }
115            depth.increment()?;
116            let envelope_size = 8;
117            let bytes_len = max_ordinal as usize * envelope_size;
118            #[allow(unused_variables)]
119            let offset = encoder.out_of_line_offset(bytes_len);
120            let mut _prev_end_offset: usize = 0;
121            if 1 > max_ordinal {
122                return Ok(());
123            }
124
125            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
126            // are envelope_size bytes.
127            let cur_offset: usize = (1 - 1) * envelope_size;
128
129            // Zero reserved fields.
130            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
131
132            // Safety:
133            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
134            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
135            //   envelope_size bytes, there is always sufficient room.
136            fidl::encoding::encode_in_envelope_optional::<u32, D>(
137                self.kind.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
138                encoder,
139                offset + cur_offset,
140                depth,
141            )?;
142
143            _prev_end_offset = cur_offset + envelope_size;
144            if 2 > max_ordinal {
145                return Ok(());
146            }
147
148            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
149            // are envelope_size bytes.
150            let cur_offset: usize = (2 - 1) * envelope_size;
151
152            // Zero reserved fields.
153            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
154
155            // Safety:
156            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
157            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
158            //   envelope_size bytes, there is always sufficient room.
159            fidl::encoding::encode_in_envelope_optional::<i64, D>(
160                self.threshold.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
161                encoder,
162                offset + cur_offset,
163                depth,
164            )?;
165
166            _prev_end_offset = cur_offset + envelope_size;
167            if 3 > max_ordinal {
168                return Ok(());
169            }
170
171            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
172            // are envelope_size bytes.
173            let cur_offset: usize = (3 - 1) * envelope_size;
174
175            // Zero reserved fields.
176            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
177
178            // Safety:
179            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
180            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
181            //   envelope_size bytes, there is always sufficient room.
182            fidl::encoding::encode_in_envelope_optional::<i64, D>(
183                self.window.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
184                encoder,
185                offset + cur_offset,
186                depth,
187            )?;
188
189            _prev_end_offset = cur_offset + envelope_size;
190
191            Ok(())
192        }
193    }
194
195    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
196        for PsiProviderWatchMemoryStallRequest
197    {
198        #[inline(always)]
199        fn new_empty() -> Self {
200            Self::default()
201        }
202
203        unsafe fn decode(
204            &mut self,
205            decoder: &mut fidl::encoding::Decoder<'_, D>,
206            offset: usize,
207            mut depth: fidl::encoding::Depth,
208        ) -> fidl::Result<()> {
209            decoder.debug_check_bounds::<Self>(offset);
210            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
211                None => return Err(fidl::Error::NotNullable),
212                Some(len) => len,
213            };
214            // Calling decoder.out_of_line_offset(0) is not allowed.
215            if len == 0 {
216                return Ok(());
217            };
218            depth.increment()?;
219            let envelope_size = 8;
220            let bytes_len = len * envelope_size;
221            let offset = decoder.out_of_line_offset(bytes_len)?;
222            // Decode the envelope for each type.
223            let mut _next_ordinal_to_read = 0;
224            let mut next_offset = offset;
225            let end_offset = offset + bytes_len;
226            _next_ordinal_to_read += 1;
227            if next_offset >= end_offset {
228                return Ok(());
229            }
230
231            // Decode unknown envelopes for gaps in ordinals.
232            while _next_ordinal_to_read < 1 {
233                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
234                _next_ordinal_to_read += 1;
235                next_offset += envelope_size;
236            }
237
238            let next_out_of_line = decoder.next_out_of_line();
239            let handles_before = decoder.remaining_handles();
240            if let Some((inlined, num_bytes, num_handles)) =
241                fidl::encoding::decode_envelope_header(decoder, next_offset)?
242            {
243                let member_inline_size =
244                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
245                if inlined != (member_inline_size <= 4) {
246                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
247                }
248                let inner_offset;
249                let mut inner_depth = depth.clone();
250                if inlined {
251                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
252                    inner_offset = next_offset;
253                } else {
254                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
255                    inner_depth.increment()?;
256                }
257                let val_ref = self.kind.get_or_insert_with(|| fidl::new_empty!(u32, D));
258                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
259                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
260                {
261                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
262                }
263                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
264                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
265                }
266            }
267
268            next_offset += envelope_size;
269            _next_ordinal_to_read += 1;
270            if next_offset >= end_offset {
271                return Ok(());
272            }
273
274            // Decode unknown envelopes for gaps in ordinals.
275            while _next_ordinal_to_read < 2 {
276                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
277                _next_ordinal_to_read += 1;
278                next_offset += envelope_size;
279            }
280
281            let next_out_of_line = decoder.next_out_of_line();
282            let handles_before = decoder.remaining_handles();
283            if let Some((inlined, num_bytes, num_handles)) =
284                fidl::encoding::decode_envelope_header(decoder, next_offset)?
285            {
286                let member_inline_size =
287                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
288                if inlined != (member_inline_size <= 4) {
289                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
290                }
291                let inner_offset;
292                let mut inner_depth = depth.clone();
293                if inlined {
294                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
295                    inner_offset = next_offset;
296                } else {
297                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
298                    inner_depth.increment()?;
299                }
300                let val_ref = self.threshold.get_or_insert_with(|| fidl::new_empty!(i64, D));
301                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
302                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
303                {
304                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
305                }
306                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
307                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
308                }
309            }
310
311            next_offset += envelope_size;
312            _next_ordinal_to_read += 1;
313            if next_offset >= end_offset {
314                return Ok(());
315            }
316
317            // Decode unknown envelopes for gaps in ordinals.
318            while _next_ordinal_to_read < 3 {
319                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
320                _next_ordinal_to_read += 1;
321                next_offset += envelope_size;
322            }
323
324            let next_out_of_line = decoder.next_out_of_line();
325            let handles_before = decoder.remaining_handles();
326            if let Some((inlined, num_bytes, num_handles)) =
327                fidl::encoding::decode_envelope_header(decoder, next_offset)?
328            {
329                let member_inline_size =
330                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
331                if inlined != (member_inline_size <= 4) {
332                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
333                }
334                let inner_offset;
335                let mut inner_depth = depth.clone();
336                if inlined {
337                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
338                    inner_offset = next_offset;
339                } else {
340                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
341                    inner_depth.increment()?;
342                }
343                let val_ref = self.window.get_or_insert_with(|| fidl::new_empty!(i64, D));
344                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
345                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
346                {
347                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
348                }
349                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
350                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
351                }
352            }
353
354            next_offset += envelope_size;
355
356            // Decode the remaining unknown envelopes.
357            while next_offset < end_offset {
358                _next_ordinal_to_read += 1;
359                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
360                next_offset += envelope_size;
361            }
362
363            Ok(())
364        }
365    }
366
367    impl PsiProviderGetMemoryPressureStatsResponse {
368        #[inline(always)]
369        fn max_ordinal_present(&self) -> u64 {
370            if let Some(_) = self.full {
371                return 2;
372            }
373            if let Some(_) = self.some {
374                return 1;
375            }
376            0
377        }
378    }
379
380    impl fidl::encoding::ValueTypeMarker for PsiProviderGetMemoryPressureStatsResponse {
381        type Borrowed<'a> = &'a Self;
382        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
383            value
384        }
385    }
386
387    unsafe impl fidl::encoding::TypeMarker for PsiProviderGetMemoryPressureStatsResponse {
388        type Owned = Self;
389
390        #[inline(always)]
391        fn inline_align(_context: fidl::encoding::Context) -> usize {
392            8
393        }
394
395        #[inline(always)]
396        fn inline_size(_context: fidl::encoding::Context) -> usize {
397            16
398        }
399    }
400
401    unsafe impl<D: fidl::encoding::ResourceDialect>
402        fidl::encoding::Encode<PsiProviderGetMemoryPressureStatsResponse, D>
403        for &PsiProviderGetMemoryPressureStatsResponse
404    {
405        unsafe fn encode(
406            self,
407            encoder: &mut fidl::encoding::Encoder<'_, D>,
408            offset: usize,
409            mut depth: fidl::encoding::Depth,
410        ) -> fidl::Result<()> {
411            encoder.debug_check_bounds::<PsiProviderGetMemoryPressureStatsResponse>(offset);
412            // Vector header
413            let max_ordinal: u64 = self.max_ordinal_present();
414            encoder.write_num(max_ordinal, offset);
415            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
416            // Calling encoder.out_of_line_offset(0) is not allowed.
417            if max_ordinal == 0 {
418                return Ok(());
419            }
420            depth.increment()?;
421            let envelope_size = 8;
422            let bytes_len = max_ordinal as usize * envelope_size;
423            #[allow(unused_variables)]
424            let offset = encoder.out_of_line_offset(bytes_len);
425            let mut _prev_end_offset: usize = 0;
426            if 1 > max_ordinal {
427                return Ok(());
428            }
429
430            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
431            // are envelope_size bytes.
432            let cur_offset: usize = (1 - 1) * envelope_size;
433
434            // Zero reserved fields.
435            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
436
437            // Safety:
438            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
439            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
440            //   envelope_size bytes, there is always sufficient room.
441            fidl::encoding::encode_in_envelope_optional::<PsiStats, D>(
442                self.some.as_ref().map(<PsiStats as fidl::encoding::ValueTypeMarker>::borrow),
443                encoder,
444                offset + cur_offset,
445                depth,
446            )?;
447
448            _prev_end_offset = cur_offset + envelope_size;
449            if 2 > max_ordinal {
450                return Ok(());
451            }
452
453            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
454            // are envelope_size bytes.
455            let cur_offset: usize = (2 - 1) * envelope_size;
456
457            // Zero reserved fields.
458            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
459
460            // Safety:
461            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
462            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
463            //   envelope_size bytes, there is always sufficient room.
464            fidl::encoding::encode_in_envelope_optional::<PsiStats, D>(
465                self.full.as_ref().map(<PsiStats as fidl::encoding::ValueTypeMarker>::borrow),
466                encoder,
467                offset + cur_offset,
468                depth,
469            )?;
470
471            _prev_end_offset = cur_offset + envelope_size;
472
473            Ok(())
474        }
475    }
476
477    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
478        for PsiProviderGetMemoryPressureStatsResponse
479    {
480        #[inline(always)]
481        fn new_empty() -> Self {
482            Self::default()
483        }
484
485        unsafe fn decode(
486            &mut self,
487            decoder: &mut fidl::encoding::Decoder<'_, D>,
488            offset: usize,
489            mut depth: fidl::encoding::Depth,
490        ) -> fidl::Result<()> {
491            decoder.debug_check_bounds::<Self>(offset);
492            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
493                None => return Err(fidl::Error::NotNullable),
494                Some(len) => len,
495            };
496            // Calling decoder.out_of_line_offset(0) is not allowed.
497            if len == 0 {
498                return Ok(());
499            };
500            depth.increment()?;
501            let envelope_size = 8;
502            let bytes_len = len * envelope_size;
503            let offset = decoder.out_of_line_offset(bytes_len)?;
504            // Decode the envelope for each type.
505            let mut _next_ordinal_to_read = 0;
506            let mut next_offset = offset;
507            let end_offset = offset + bytes_len;
508            _next_ordinal_to_read += 1;
509            if next_offset >= end_offset {
510                return Ok(());
511            }
512
513            // Decode unknown envelopes for gaps in ordinals.
514            while _next_ordinal_to_read < 1 {
515                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
516                _next_ordinal_to_read += 1;
517                next_offset += envelope_size;
518            }
519
520            let next_out_of_line = decoder.next_out_of_line();
521            let handles_before = decoder.remaining_handles();
522            if let Some((inlined, num_bytes, num_handles)) =
523                fidl::encoding::decode_envelope_header(decoder, next_offset)?
524            {
525                let member_inline_size =
526                    <PsiStats as fidl::encoding::TypeMarker>::inline_size(decoder.context);
527                if inlined != (member_inline_size <= 4) {
528                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
529                }
530                let inner_offset;
531                let mut inner_depth = depth.clone();
532                if inlined {
533                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
534                    inner_offset = next_offset;
535                } else {
536                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
537                    inner_depth.increment()?;
538                }
539                let val_ref = self.some.get_or_insert_with(|| fidl::new_empty!(PsiStats, D));
540                fidl::decode!(PsiStats, D, val_ref, decoder, inner_offset, inner_depth)?;
541                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
542                {
543                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
544                }
545                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
546                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
547                }
548            }
549
550            next_offset += envelope_size;
551            _next_ordinal_to_read += 1;
552            if next_offset >= end_offset {
553                return Ok(());
554            }
555
556            // Decode unknown envelopes for gaps in ordinals.
557            while _next_ordinal_to_read < 2 {
558                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
559                _next_ordinal_to_read += 1;
560                next_offset += envelope_size;
561            }
562
563            let next_out_of_line = decoder.next_out_of_line();
564            let handles_before = decoder.remaining_handles();
565            if let Some((inlined, num_bytes, num_handles)) =
566                fidl::encoding::decode_envelope_header(decoder, next_offset)?
567            {
568                let member_inline_size =
569                    <PsiStats as fidl::encoding::TypeMarker>::inline_size(decoder.context);
570                if inlined != (member_inline_size <= 4) {
571                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
572                }
573                let inner_offset;
574                let mut inner_depth = depth.clone();
575                if inlined {
576                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
577                    inner_offset = next_offset;
578                } else {
579                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
580                    inner_depth.increment()?;
581                }
582                let val_ref = self.full.get_or_insert_with(|| fidl::new_empty!(PsiStats, D));
583                fidl::decode!(PsiStats, D, val_ref, decoder, inner_offset, inner_depth)?;
584                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
585                {
586                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
587                }
588                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
589                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
590                }
591            }
592
593            next_offset += envelope_size;
594
595            // Decode the remaining unknown envelopes.
596            while next_offset < end_offset {
597                _next_ordinal_to_read += 1;
598                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
599                next_offset += envelope_size;
600            }
601
602            Ok(())
603        }
604    }
605
606    impl PsiStats {
607        #[inline(always)]
608        fn max_ordinal_present(&self) -> u64 {
609            if let Some(_) = self.total {
610                return 4;
611            }
612            if let Some(_) = self.avg300 {
613                return 3;
614            }
615            if let Some(_) = self.avg60 {
616                return 2;
617            }
618            if let Some(_) = self.avg10 {
619                return 1;
620            }
621            0
622        }
623    }
624
625    impl fidl::encoding::ValueTypeMarker for PsiStats {
626        type Borrowed<'a> = &'a Self;
627        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
628            value
629        }
630    }
631
632    unsafe impl fidl::encoding::TypeMarker for PsiStats {
633        type Owned = Self;
634
635        #[inline(always)]
636        fn inline_align(_context: fidl::encoding::Context) -> usize {
637            8
638        }
639
640        #[inline(always)]
641        fn inline_size(_context: fidl::encoding::Context) -> usize {
642            16
643        }
644    }
645
646    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PsiStats, D> for &PsiStats {
647        unsafe fn encode(
648            self,
649            encoder: &mut fidl::encoding::Encoder<'_, D>,
650            offset: usize,
651            mut depth: fidl::encoding::Depth,
652        ) -> fidl::Result<()> {
653            encoder.debug_check_bounds::<PsiStats>(offset);
654            // Vector header
655            let max_ordinal: u64 = self.max_ordinal_present();
656            encoder.write_num(max_ordinal, offset);
657            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
658            // Calling encoder.out_of_line_offset(0) is not allowed.
659            if max_ordinal == 0 {
660                return Ok(());
661            }
662            depth.increment()?;
663            let envelope_size = 8;
664            let bytes_len = max_ordinal as usize * envelope_size;
665            #[allow(unused_variables)]
666            let offset = encoder.out_of_line_offset(bytes_len);
667            let mut _prev_end_offset: usize = 0;
668            if 1 > max_ordinal {
669                return Ok(());
670            }
671
672            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
673            // are envelope_size bytes.
674            let cur_offset: usize = (1 - 1) * envelope_size;
675
676            // Zero reserved fields.
677            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
678
679            // Safety:
680            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
681            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
682            //   envelope_size bytes, there is always sufficient room.
683            fidl::encoding::encode_in_envelope_optional::<f64, D>(
684                self.avg10.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
685                encoder,
686                offset + cur_offset,
687                depth,
688            )?;
689
690            _prev_end_offset = cur_offset + envelope_size;
691            if 2 > max_ordinal {
692                return Ok(());
693            }
694
695            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
696            // are envelope_size bytes.
697            let cur_offset: usize = (2 - 1) * envelope_size;
698
699            // Zero reserved fields.
700            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
701
702            // Safety:
703            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
704            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
705            //   envelope_size bytes, there is always sufficient room.
706            fidl::encoding::encode_in_envelope_optional::<f64, D>(
707                self.avg60.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
708                encoder,
709                offset + cur_offset,
710                depth,
711            )?;
712
713            _prev_end_offset = cur_offset + envelope_size;
714            if 3 > max_ordinal {
715                return Ok(());
716            }
717
718            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
719            // are envelope_size bytes.
720            let cur_offset: usize = (3 - 1) * envelope_size;
721
722            // Zero reserved fields.
723            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
724
725            // Safety:
726            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
727            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
728            //   envelope_size bytes, there is always sufficient room.
729            fidl::encoding::encode_in_envelope_optional::<f64, D>(
730                self.avg300.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
731                encoder,
732                offset + cur_offset,
733                depth,
734            )?;
735
736            _prev_end_offset = cur_offset + envelope_size;
737            if 4 > max_ordinal {
738                return Ok(());
739            }
740
741            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
742            // are envelope_size bytes.
743            let cur_offset: usize = (4 - 1) * envelope_size;
744
745            // Zero reserved fields.
746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
747
748            // Safety:
749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
751            //   envelope_size bytes, there is always sufficient room.
752            fidl::encoding::encode_in_envelope_optional::<i64, D>(
753                self.total.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
754                encoder,
755                offset + cur_offset,
756                depth,
757            )?;
758
759            _prev_end_offset = cur_offset + envelope_size;
760
761            Ok(())
762        }
763    }
764
765    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PsiStats {
766        #[inline(always)]
767        fn new_empty() -> Self {
768            Self::default()
769        }
770
771        unsafe fn decode(
772            &mut self,
773            decoder: &mut fidl::encoding::Decoder<'_, D>,
774            offset: usize,
775            mut depth: fidl::encoding::Depth,
776        ) -> fidl::Result<()> {
777            decoder.debug_check_bounds::<Self>(offset);
778            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
779                None => return Err(fidl::Error::NotNullable),
780                Some(len) => len,
781            };
782            // Calling decoder.out_of_line_offset(0) is not allowed.
783            if len == 0 {
784                return Ok(());
785            };
786            depth.increment()?;
787            let envelope_size = 8;
788            let bytes_len = len * envelope_size;
789            let offset = decoder.out_of_line_offset(bytes_len)?;
790            // Decode the envelope for each type.
791            let mut _next_ordinal_to_read = 0;
792            let mut next_offset = offset;
793            let end_offset = offset + bytes_len;
794            _next_ordinal_to_read += 1;
795            if next_offset >= end_offset {
796                return Ok(());
797            }
798
799            // Decode unknown envelopes for gaps in ordinals.
800            while _next_ordinal_to_read < 1 {
801                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
802                _next_ordinal_to_read += 1;
803                next_offset += envelope_size;
804            }
805
806            let next_out_of_line = decoder.next_out_of_line();
807            let handles_before = decoder.remaining_handles();
808            if let Some((inlined, num_bytes, num_handles)) =
809                fidl::encoding::decode_envelope_header(decoder, next_offset)?
810            {
811                let member_inline_size =
812                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
813                if inlined != (member_inline_size <= 4) {
814                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
815                }
816                let inner_offset;
817                let mut inner_depth = depth.clone();
818                if inlined {
819                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
820                    inner_offset = next_offset;
821                } else {
822                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
823                    inner_depth.increment()?;
824                }
825                let val_ref = self.avg10.get_or_insert_with(|| fidl::new_empty!(f64, D));
826                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
827                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
828                {
829                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
830                }
831                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
832                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
833                }
834            }
835
836            next_offset += envelope_size;
837            _next_ordinal_to_read += 1;
838            if next_offset >= end_offset {
839                return Ok(());
840            }
841
842            // Decode unknown envelopes for gaps in ordinals.
843            while _next_ordinal_to_read < 2 {
844                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
845                _next_ordinal_to_read += 1;
846                next_offset += envelope_size;
847            }
848
849            let next_out_of_line = decoder.next_out_of_line();
850            let handles_before = decoder.remaining_handles();
851            if let Some((inlined, num_bytes, num_handles)) =
852                fidl::encoding::decode_envelope_header(decoder, next_offset)?
853            {
854                let member_inline_size =
855                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
856                if inlined != (member_inline_size <= 4) {
857                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
858                }
859                let inner_offset;
860                let mut inner_depth = depth.clone();
861                if inlined {
862                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
863                    inner_offset = next_offset;
864                } else {
865                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
866                    inner_depth.increment()?;
867                }
868                let val_ref = self.avg60.get_or_insert_with(|| fidl::new_empty!(f64, D));
869                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
870                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
871                {
872                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
873                }
874                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
875                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
876                }
877            }
878
879            next_offset += envelope_size;
880            _next_ordinal_to_read += 1;
881            if next_offset >= end_offset {
882                return Ok(());
883            }
884
885            // Decode unknown envelopes for gaps in ordinals.
886            while _next_ordinal_to_read < 3 {
887                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
888                _next_ordinal_to_read += 1;
889                next_offset += envelope_size;
890            }
891
892            let next_out_of_line = decoder.next_out_of_line();
893            let handles_before = decoder.remaining_handles();
894            if let Some((inlined, num_bytes, num_handles)) =
895                fidl::encoding::decode_envelope_header(decoder, next_offset)?
896            {
897                let member_inline_size =
898                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
899                if inlined != (member_inline_size <= 4) {
900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
901                }
902                let inner_offset;
903                let mut inner_depth = depth.clone();
904                if inlined {
905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
906                    inner_offset = next_offset;
907                } else {
908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
909                    inner_depth.increment()?;
910                }
911                let val_ref = self.avg300.get_or_insert_with(|| fidl::new_empty!(f64, D));
912                fidl::decode!(f64, D, val_ref, decoder, inner_offset, inner_depth)?;
913                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
914                {
915                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
916                }
917                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
918                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
919                }
920            }
921
922            next_offset += envelope_size;
923            _next_ordinal_to_read += 1;
924            if next_offset >= end_offset {
925                return Ok(());
926            }
927
928            // Decode unknown envelopes for gaps in ordinals.
929            while _next_ordinal_to_read < 4 {
930                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
931                _next_ordinal_to_read += 1;
932                next_offset += envelope_size;
933            }
934
935            let next_out_of_line = decoder.next_out_of_line();
936            let handles_before = decoder.remaining_handles();
937            if let Some((inlined, num_bytes, num_handles)) =
938                fidl::encoding::decode_envelope_header(decoder, next_offset)?
939            {
940                let member_inline_size =
941                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
942                if inlined != (member_inline_size <= 4) {
943                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
944                }
945                let inner_offset;
946                let mut inner_depth = depth.clone();
947                if inlined {
948                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
949                    inner_offset = next_offset;
950                } else {
951                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
952                    inner_depth.increment()?;
953                }
954                let val_ref = self.total.get_or_insert_with(|| fidl::new_empty!(i64, D));
955                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
956                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
957                {
958                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
959                }
960                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
961                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
962                }
963            }
964
965            next_offset += envelope_size;
966
967            // Decode the remaining unknown envelopes.
968            while next_offset < end_offset {
969                _next_ordinal_to_read += 1;
970                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
971                next_offset += envelope_size;
972            }
973
974            Ok(())
975        }
976    }
977}
fidl_fuchsia_starnix_psi__common/fidl_fuchsia_starnix_psi__common.rs

fidl_fuchsia_starnix_psi__common/
fidl_fuchsia_starnix_psi__common.rs
