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 COMPONENT_URL_ARG_NAME: &str = "$__url";
12
13pub const MAXIMUM_ENTRIES_PER_BATCH: u16 = 64;
16
17pub const MAXIMUM_RAW_SELECTOR_LENGTH: u16 = 1024;
20
21pub const MAX_DATA_HIERARCHY_DEPTH: u16 = 100;
22
23pub const MAX_LOG_SELECTORS: u8 = 64;
25
26pub const MAX_MONIKER_SEGMENTS: u16 = 25;
27
28pub const MAX_STRING_SELECTOR_LENGTH: u16 = 1024;
29
30pub const MONIKER_ARG_NAME: &str = "$__moniker";
31
32pub const ROLLED_OUT_ARG_NAME: &str = "$__rolled_out";
33
34#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
35#[repr(u8)]
36pub enum DataType {
37 Inspect = 1,
39 Logs = 3,
41}
42
43impl DataType {
44 #[inline]
45 pub fn from_primitive(prim: u8) -> Option<Self> {
46 match prim {
47 1 => Some(Self::Inspect),
48 3 => Some(Self::Logs),
49 _ => None,
50 }
51 }
52
53 #[inline]
54 pub const fn into_primitive(self) -> u8 {
55 self as u8
56 }
57}
58
59#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
62#[repr(u32)]
63pub enum Format {
64 Json = 1,
67 Text = 2,
69 Cbor = 3,
72 Fxt = 4,
76}
77
78impl Format {
79 #[inline]
80 pub fn from_primitive(prim: u32) -> Option<Self> {
81 match prim {
82 1 => Some(Self::Json),
83 2 => Some(Self::Text),
84 3 => Some(Self::Cbor),
85 4 => Some(Self::Fxt),
86 _ => None,
87 }
88 }
89
90 #[inline]
91 pub const fn into_primitive(self) -> u32 {
92 self as u32
93 }
94}
95
96#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
99#[repr(u32)]
100pub enum ReaderError {
101 Io = 1,
102}
103
104impl ReaderError {
105 #[inline]
106 pub fn from_primitive(prim: u32) -> Option<Self> {
107 match prim {
108 1 => Some(Self::Io),
109 _ => None,
110 }
111 }
112
113 #[inline]
114 pub const fn into_primitive(self) -> u32 {
115 self as u32
116 }
117}
118
119#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
121#[repr(u8)]
122pub enum Severity {
123 Trace = 16,
125 Debug = 32,
127 Info = 48,
129 Warn = 64,
131 Error = 80,
133 Fatal = 96,
135}
136
137impl Severity {
138 #[inline]
139 pub fn from_primitive(prim: u8) -> Option<Self> {
140 match prim {
141 16 => Some(Self::Trace),
142 32 => Some(Self::Debug),
143 48 => Some(Self::Info),
144 64 => Some(Self::Warn),
145 80 => Some(Self::Error),
146 96 => Some(Self::Fatal),
147 _ => None,
148 }
149 }
150
151 #[inline]
152 pub const fn into_primitive(self) -> u8 {
153 self as u8
154 }
155}
156
157#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
159#[repr(u8)]
160pub enum StreamMode {
161 Snapshot = 1,
164 SnapshotThenSubscribe = 2,
168 Subscribe = 3,
171}
172
173impl StreamMode {
174 #[inline]
175 pub fn from_primitive(prim: u8) -> Option<Self> {
176 match prim {
177 1 => Some(Self::Snapshot),
178 2 => Some(Self::SnapshotThenSubscribe),
179 3 => Some(Self::Subscribe),
180 _ => None,
181 }
182 }
183
184 #[inline]
185 pub const fn into_primitive(self) -> u8 {
186 self as u8
187 }
188}
189
190#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
191pub struct All;
192
193impl fidl::Persistable for All {}
194
195#[derive(Clone, Debug, PartialEq)]
196pub struct LogInterestSelector {
197 pub selector: ComponentSelector,
199 pub interest: fidl_fuchsia_diagnostics_types__common::Interest,
201}
202
203impl fidl::Persistable for LogInterestSelector {}
204
205#[derive(Clone, Debug, PartialEq)]
206pub struct LogSettingsRegisterInterestRequest {
207 pub selectors: Vec<LogInterestSelector>,
208}
209
210impl fidl::Persistable for LogSettingsRegisterInterestRequest {}
211
212#[derive(Clone, Debug, PartialEq)]
213pub struct LogSettingsSetInterestRequest {
214 pub selectors: Vec<LogInterestSelector>,
215}
216
217impl fidl::Persistable for LogSettingsSetInterestRequest {}
218
219#[derive(Clone, Debug, PartialEq)]
222pub struct PropertySelector {
223 pub node_path: Vec<StringSelector>,
236 pub target_properties: StringSelector,
242}
243
244impl fidl::Persistable for PropertySelector {}
245
246#[derive(Clone, Debug, PartialEq)]
249pub struct SubtreeSelector {
250 pub node_path: Vec<StringSelector>,
263}
264
265impl fidl::Persistable for SubtreeSelector {}
266
267#[derive(Clone, Debug, Default, PartialEq)]
286pub struct ComponentSelector {
287 pub moniker_segments: Option<Vec<StringSelector>>,
295 #[doc(hidden)]
296 pub __source_breaking: fidl::marker::SourceBreaking,
297}
298
299impl fidl::Persistable for ComponentSelector {}
300
301#[derive(Clone, Debug, Default, PartialEq)]
304pub struct Interest {
305 pub min_severity: Option<Severity>,
310 #[doc(hidden)]
311 pub __source_breaking: fidl::marker::SourceBreaking,
312}
313
314impl fidl::Persistable for Interest {}
315
316#[derive(Clone, Debug, Default, PartialEq)]
317pub struct LogSettingsSetComponentInterestRequest {
318 pub selectors: Option<Vec<LogInterestSelector>>,
320 pub persist: Option<bool>,
323 #[doc(hidden)]
324 pub __source_breaking: fidl::marker::SourceBreaking,
325}
326
327impl fidl::Persistable for LogSettingsSetComponentInterestRequest {}
328
329#[derive(Clone, Debug, Default, PartialEq)]
330pub struct LogStreamOptions {
331 pub mode: Option<StreamMode>,
333 pub include_moniker: Option<bool>,
336 pub include_component_url: Option<bool>,
339 pub include_rolled_out: Option<bool>,
343 #[doc(hidden)]
344 pub __source_breaking: fidl::marker::SourceBreaking,
345}
346
347impl fidl::Persistable for LogStreamOptions {}
348
349#[derive(Clone, Debug, Default, PartialEq)]
351pub struct PerformanceConfiguration {
352 pub max_aggregate_content_size_bytes: Option<u64>,
358 pub batch_retrieval_timeout_seconds: Option<i64>,
367 #[doc(hidden)]
368 pub __source_breaking: fidl::marker::SourceBreaking,
369}
370
371impl fidl::Persistable for PerformanceConfiguration {}
372
373#[derive(Clone, Debug, Default, PartialEq)]
387pub struct Selector {
388 pub component_selector: Option<ComponentSelector>,
391 pub tree_selector: Option<TreeSelector>,
395 pub tree_names: Option<TreeNames>,
401 #[doc(hidden)]
402 pub __source_breaking: fidl::marker::SourceBreaking,
403}
404
405impl fidl::Persistable for Selector {}
406
407#[derive(Clone, Debug, Default, PartialEq)]
409pub struct StreamParameters {
410 pub data_type: Option<DataType>,
414 pub stream_mode: Option<StreamMode>,
418 pub format: Option<Format>,
422 pub client_selector_configuration: Option<ClientSelectorConfiguration>,
427 pub batch_retrieval_timeout_seconds: Option<i64>,
436 pub performance_configuration: Option<PerformanceConfiguration>,
439 #[doc(hidden)]
440 pub __source_breaking: fidl::marker::SourceBreaking,
441}
442
443impl fidl::Persistable for StreamParameters {}
444
445#[derive(Clone, Debug)]
446pub enum ClientSelectorConfiguration {
447 Selectors(Vec<SelectorArgument>),
451 SelectAll(bool),
454 #[doc(hidden)]
455 __SourceBreaking { unknown_ordinal: u64 },
456}
457
458#[macro_export]
460macro_rules! ClientSelectorConfigurationUnknown {
461 () => {
462 _
463 };
464}
465
466impl PartialEq for ClientSelectorConfiguration {
468 fn eq(&self, other: &Self) -> bool {
469 match (self, other) {
470 (Self::Selectors(x), Self::Selectors(y)) => *x == *y,
471 (Self::SelectAll(x), Self::SelectAll(y)) => *x == *y,
472 _ => false,
473 }
474 }
475}
476
477impl ClientSelectorConfiguration {
478 #[inline]
479 pub fn ordinal(&self) -> u64 {
480 match *self {
481 Self::Selectors(_) => 1,
482 Self::SelectAll(_) => 2,
483 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
484 }
485 }
486
487 #[inline]
488 pub fn unknown_variant_for_testing() -> Self {
489 Self::__SourceBreaking { unknown_ordinal: 0 }
490 }
491
492 #[inline]
493 pub fn is_unknown(&self) -> bool {
494 match self {
495 Self::__SourceBreaking { .. } => true,
496 _ => false,
497 }
498 }
499}
500
501impl fidl::Persistable for ClientSelectorConfiguration {}
502
503#[derive(Clone, Debug)]
506pub enum SelectorArgument {
507 StructuredSelector(Selector),
510 RawSelector(String),
517 #[doc(hidden)]
518 __SourceBreaking { unknown_ordinal: u64 },
519}
520
521#[macro_export]
523macro_rules! SelectorArgumentUnknown {
524 () => {
525 _
526 };
527}
528
529impl PartialEq for SelectorArgument {
531 fn eq(&self, other: &Self) -> bool {
532 match (self, other) {
533 (Self::StructuredSelector(x), Self::StructuredSelector(y)) => *x == *y,
534 (Self::RawSelector(x), Self::RawSelector(y)) => *x == *y,
535 _ => false,
536 }
537 }
538}
539
540impl SelectorArgument {
541 #[inline]
542 pub fn ordinal(&self) -> u64 {
543 match *self {
544 Self::StructuredSelector(_) => 1,
545 Self::RawSelector(_) => 2,
546 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
547 }
548 }
549
550 #[inline]
551 pub fn unknown_variant_for_testing() -> Self {
552 Self::__SourceBreaking { unknown_ordinal: 0 }
553 }
554
555 #[inline]
556 pub fn is_unknown(&self) -> bool {
557 match self {
558 Self::__SourceBreaking { .. } => true,
559 _ => false,
560 }
561 }
562}
563
564impl fidl::Persistable for SelectorArgument {}
565
566#[derive(Clone, Debug)]
569pub enum StringSelector {
570 StringPattern(String),
590 ExactMatch(String),
591 #[doc(hidden)]
592 __SourceBreaking {
593 unknown_ordinal: u64,
594 },
595}
596
597#[macro_export]
599macro_rules! StringSelectorUnknown {
600 () => {
601 _
602 };
603}
604
605impl PartialEq for StringSelector {
607 fn eq(&self, other: &Self) -> bool {
608 match (self, other) {
609 (Self::StringPattern(x), Self::StringPattern(y)) => *x == *y,
610 (Self::ExactMatch(x), Self::ExactMatch(y)) => *x == *y,
611 _ => false,
612 }
613 }
614}
615
616impl StringSelector {
617 #[inline]
618 pub fn ordinal(&self) -> u64 {
619 match *self {
620 Self::StringPattern(_) => 1,
621 Self::ExactMatch(_) => 2,
622 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
623 }
624 }
625
626 #[inline]
627 pub fn unknown_variant_for_testing() -> Self {
628 Self::__SourceBreaking { unknown_ordinal: 0 }
629 }
630
631 #[inline]
632 pub fn is_unknown(&self) -> bool {
633 match self {
634 Self::__SourceBreaking { .. } => true,
635 _ => false,
636 }
637 }
638}
639
640impl fidl::Persistable for StringSelector {}
641
642#[derive(Clone, Debug)]
646pub enum TreeNames {
647 Some(Vec<String>),
649 All(All),
652 #[doc(hidden)]
653 __SourceBreaking { unknown_ordinal: u64 },
654}
655
656#[macro_export]
658macro_rules! TreeNamesUnknown {
659 () => {
660 _
661 };
662}
663
664impl PartialEq for TreeNames {
666 fn eq(&self, other: &Self) -> bool {
667 match (self, other) {
668 (Self::Some(x), Self::Some(y)) => *x == *y,
669 (Self::All(x), Self::All(y)) => *x == *y,
670 _ => false,
671 }
672 }
673}
674
675impl TreeNames {
676 #[inline]
677 pub fn ordinal(&self) -> u64 {
678 match *self {
679 Self::Some(_) => 1,
680 Self::All(_) => 2,
681 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
682 }
683 }
684
685 #[inline]
686 pub fn unknown_variant_for_testing() -> Self {
687 Self::__SourceBreaking { unknown_ordinal: 0 }
688 }
689
690 #[inline]
691 pub fn is_unknown(&self) -> bool {
692 match self {
693 Self::__SourceBreaking { .. } => true,
694 _ => false,
695 }
696 }
697}
698
699impl fidl::Persistable for TreeNames {}
700
701#[derive(Clone, Debug)]
704pub enum TreeSelector {
705 SubtreeSelector(SubtreeSelector),
708 PropertySelector(PropertySelector),
711 #[doc(hidden)]
712 __SourceBreaking { unknown_ordinal: u64 },
713}
714
715#[macro_export]
717macro_rules! TreeSelectorUnknown {
718 () => {
719 _
720 };
721}
722
723impl PartialEq for TreeSelector {
725 fn eq(&self, other: &Self) -> bool {
726 match (self, other) {
727 (Self::SubtreeSelector(x), Self::SubtreeSelector(y)) => *x == *y,
728 (Self::PropertySelector(x), Self::PropertySelector(y)) => *x == *y,
729 _ => false,
730 }
731 }
732}
733
734impl TreeSelector {
735 #[inline]
736 pub fn ordinal(&self) -> u64 {
737 match *self {
738 Self::SubtreeSelector(_) => 1,
739 Self::PropertySelector(_) => 2,
740 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
741 }
742 }
743
744 #[inline]
745 pub fn unknown_variant_for_testing() -> Self {
746 Self::__SourceBreaking { unknown_ordinal: 0 }
747 }
748
749 #[inline]
750 pub fn is_unknown(&self) -> bool {
751 match self {
752 Self::__SourceBreaking { .. } => true,
753 _ => false,
754 }
755 }
756}
757
758impl fidl::Persistable for TreeSelector {}
759
760pub mod archive_accessor_ordinals {
761 pub const STREAM_DIAGNOSTICS: u64 = 0x20c73e2ecd653c3e;
762 pub const WAIT_FOR_READY: u64 = 0x122963198011bd24;
763}
764
765pub mod batch_iterator_ordinals {
766 pub const GET_NEXT: u64 = 0x781986486c6254a5;
767 pub const WAIT_FOR_READY: u64 = 0x70598ee271597603;
768}
769
770pub mod log_settings_ordinals {
771 pub const REGISTER_INTEREST: u64 = 0x49d7c14eec975fb;
772 pub const SET_INTEREST: u64 = 0x71beced9d2411f90;
773 pub const SET_COMPONENT_INTEREST: u64 = 0x35f7004d2367f6c1;
774}
775
776pub mod log_stream_ordinals {
777 pub const CONNECT: u64 = 0x745eb34f10d51a88;
778}
779
780mod internal {
781 use super::*;
782 unsafe impl fidl::encoding::TypeMarker for DataType {
783 type Owned = Self;
784
785 #[inline(always)]
786 fn inline_align(_context: fidl::encoding::Context) -> usize {
787 std::mem::align_of::<u8>()
788 }
789
790 #[inline(always)]
791 fn inline_size(_context: fidl::encoding::Context) -> usize {
792 std::mem::size_of::<u8>()
793 }
794
795 #[inline(always)]
796 fn encode_is_copy() -> bool {
797 true
798 }
799
800 #[inline(always)]
801 fn decode_is_copy() -> bool {
802 false
803 }
804 }
805
806 impl fidl::encoding::ValueTypeMarker for DataType {
807 type Borrowed<'a> = Self;
808 #[inline(always)]
809 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
810 *value
811 }
812 }
813
814 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DataType {
815 #[inline]
816 unsafe fn encode(
817 self,
818 encoder: &mut fidl::encoding::Encoder<'_, D>,
819 offset: usize,
820 _depth: fidl::encoding::Depth,
821 ) -> fidl::Result<()> {
822 encoder.debug_check_bounds::<Self>(offset);
823 encoder.write_num(self.into_primitive(), offset);
824 Ok(())
825 }
826 }
827
828 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DataType {
829 #[inline(always)]
830 fn new_empty() -> Self {
831 Self::Inspect
832 }
833
834 #[inline]
835 unsafe fn decode(
836 &mut self,
837 decoder: &mut fidl::encoding::Decoder<'_, D>,
838 offset: usize,
839 _depth: fidl::encoding::Depth,
840 ) -> fidl::Result<()> {
841 decoder.debug_check_bounds::<Self>(offset);
842 let prim = decoder.read_num::<u8>(offset);
843
844 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
845 Ok(())
846 }
847 }
848 unsafe impl fidl::encoding::TypeMarker for Format {
849 type Owned = Self;
850
851 #[inline(always)]
852 fn inline_align(_context: fidl::encoding::Context) -> usize {
853 std::mem::align_of::<u32>()
854 }
855
856 #[inline(always)]
857 fn inline_size(_context: fidl::encoding::Context) -> usize {
858 std::mem::size_of::<u32>()
859 }
860
861 #[inline(always)]
862 fn encode_is_copy() -> bool {
863 true
864 }
865
866 #[inline(always)]
867 fn decode_is_copy() -> bool {
868 false
869 }
870 }
871
872 impl fidl::encoding::ValueTypeMarker for Format {
873 type Borrowed<'a> = Self;
874 #[inline(always)]
875 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
876 *value
877 }
878 }
879
880 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Format {
881 #[inline]
882 unsafe fn encode(
883 self,
884 encoder: &mut fidl::encoding::Encoder<'_, D>,
885 offset: usize,
886 _depth: fidl::encoding::Depth,
887 ) -> fidl::Result<()> {
888 encoder.debug_check_bounds::<Self>(offset);
889 encoder.write_num(self.into_primitive(), offset);
890 Ok(())
891 }
892 }
893
894 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Format {
895 #[inline(always)]
896 fn new_empty() -> Self {
897 Self::Json
898 }
899
900 #[inline]
901 unsafe fn decode(
902 &mut self,
903 decoder: &mut fidl::encoding::Decoder<'_, D>,
904 offset: usize,
905 _depth: fidl::encoding::Depth,
906 ) -> fidl::Result<()> {
907 decoder.debug_check_bounds::<Self>(offset);
908 let prim = decoder.read_num::<u32>(offset);
909
910 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
911 Ok(())
912 }
913 }
914 unsafe impl fidl::encoding::TypeMarker for ReaderError {
915 type Owned = Self;
916
917 #[inline(always)]
918 fn inline_align(_context: fidl::encoding::Context) -> usize {
919 std::mem::align_of::<u32>()
920 }
921
922 #[inline(always)]
923 fn inline_size(_context: fidl::encoding::Context) -> usize {
924 std::mem::size_of::<u32>()
925 }
926
927 #[inline(always)]
928 fn encode_is_copy() -> bool {
929 true
930 }
931
932 #[inline(always)]
933 fn decode_is_copy() -> bool {
934 false
935 }
936 }
937
938 impl fidl::encoding::ValueTypeMarker for ReaderError {
939 type Borrowed<'a> = Self;
940 #[inline(always)]
941 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
942 *value
943 }
944 }
945
946 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReaderError {
947 #[inline]
948 unsafe fn encode(
949 self,
950 encoder: &mut fidl::encoding::Encoder<'_, D>,
951 offset: usize,
952 _depth: fidl::encoding::Depth,
953 ) -> fidl::Result<()> {
954 encoder.debug_check_bounds::<Self>(offset);
955 encoder.write_num(self.into_primitive(), offset);
956 Ok(())
957 }
958 }
959
960 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReaderError {
961 #[inline(always)]
962 fn new_empty() -> Self {
963 Self::Io
964 }
965
966 #[inline]
967 unsafe fn decode(
968 &mut self,
969 decoder: &mut fidl::encoding::Decoder<'_, D>,
970 offset: usize,
971 _depth: fidl::encoding::Depth,
972 ) -> fidl::Result<()> {
973 decoder.debug_check_bounds::<Self>(offset);
974 let prim = decoder.read_num::<u32>(offset);
975
976 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
977 Ok(())
978 }
979 }
980 unsafe impl fidl::encoding::TypeMarker for Severity {
981 type Owned = Self;
982
983 #[inline(always)]
984 fn inline_align(_context: fidl::encoding::Context) -> usize {
985 std::mem::align_of::<u8>()
986 }
987
988 #[inline(always)]
989 fn inline_size(_context: fidl::encoding::Context) -> usize {
990 std::mem::size_of::<u8>()
991 }
992
993 #[inline(always)]
994 fn encode_is_copy() -> bool {
995 true
996 }
997
998 #[inline(always)]
999 fn decode_is_copy() -> bool {
1000 false
1001 }
1002 }
1003
1004 impl fidl::encoding::ValueTypeMarker for Severity {
1005 type Borrowed<'a> = Self;
1006 #[inline(always)]
1007 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1008 *value
1009 }
1010 }
1011
1012 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Severity {
1013 #[inline]
1014 unsafe fn encode(
1015 self,
1016 encoder: &mut fidl::encoding::Encoder<'_, D>,
1017 offset: usize,
1018 _depth: fidl::encoding::Depth,
1019 ) -> fidl::Result<()> {
1020 encoder.debug_check_bounds::<Self>(offset);
1021 encoder.write_num(self.into_primitive(), offset);
1022 Ok(())
1023 }
1024 }
1025
1026 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Severity {
1027 #[inline(always)]
1028 fn new_empty() -> Self {
1029 Self::Trace
1030 }
1031
1032 #[inline]
1033 unsafe fn decode(
1034 &mut self,
1035 decoder: &mut fidl::encoding::Decoder<'_, D>,
1036 offset: usize,
1037 _depth: fidl::encoding::Depth,
1038 ) -> fidl::Result<()> {
1039 decoder.debug_check_bounds::<Self>(offset);
1040 let prim = decoder.read_num::<u8>(offset);
1041
1042 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1043 Ok(())
1044 }
1045 }
1046 unsafe impl fidl::encoding::TypeMarker for StreamMode {
1047 type Owned = Self;
1048
1049 #[inline(always)]
1050 fn inline_align(_context: fidl::encoding::Context) -> usize {
1051 std::mem::align_of::<u8>()
1052 }
1053
1054 #[inline(always)]
1055 fn inline_size(_context: fidl::encoding::Context) -> usize {
1056 std::mem::size_of::<u8>()
1057 }
1058
1059 #[inline(always)]
1060 fn encode_is_copy() -> bool {
1061 true
1062 }
1063
1064 #[inline(always)]
1065 fn decode_is_copy() -> bool {
1066 false
1067 }
1068 }
1069
1070 impl fidl::encoding::ValueTypeMarker for StreamMode {
1071 type Borrowed<'a> = Self;
1072 #[inline(always)]
1073 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1074 *value
1075 }
1076 }
1077
1078 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StreamMode {
1079 #[inline]
1080 unsafe fn encode(
1081 self,
1082 encoder: &mut fidl::encoding::Encoder<'_, D>,
1083 offset: usize,
1084 _depth: fidl::encoding::Depth,
1085 ) -> fidl::Result<()> {
1086 encoder.debug_check_bounds::<Self>(offset);
1087 encoder.write_num(self.into_primitive(), offset);
1088 Ok(())
1089 }
1090 }
1091
1092 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamMode {
1093 #[inline(always)]
1094 fn new_empty() -> Self {
1095 Self::Snapshot
1096 }
1097
1098 #[inline]
1099 unsafe fn decode(
1100 &mut self,
1101 decoder: &mut fidl::encoding::Decoder<'_, D>,
1102 offset: usize,
1103 _depth: fidl::encoding::Depth,
1104 ) -> fidl::Result<()> {
1105 decoder.debug_check_bounds::<Self>(offset);
1106 let prim = decoder.read_num::<u8>(offset);
1107
1108 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1109 Ok(())
1110 }
1111 }
1112
1113 impl fidl::encoding::ValueTypeMarker for All {
1114 type Borrowed<'a> = &'a Self;
1115 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1116 value
1117 }
1118 }
1119
1120 unsafe impl fidl::encoding::TypeMarker for All {
1121 type Owned = Self;
1122
1123 #[inline(always)]
1124 fn inline_align(_context: fidl::encoding::Context) -> usize {
1125 1
1126 }
1127
1128 #[inline(always)]
1129 fn inline_size(_context: fidl::encoding::Context) -> usize {
1130 1
1131 }
1132 }
1133
1134 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<All, D> for &All {
1135 #[inline]
1136 unsafe fn encode(
1137 self,
1138 encoder: &mut fidl::encoding::Encoder<'_, D>,
1139 offset: usize,
1140 _depth: fidl::encoding::Depth,
1141 ) -> fidl::Result<()> {
1142 encoder.debug_check_bounds::<All>(offset);
1143 encoder.write_num(0u8, offset);
1144 Ok(())
1145 }
1146 }
1147
1148 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for All {
1149 #[inline(always)]
1150 fn new_empty() -> Self {
1151 Self
1152 }
1153
1154 #[inline]
1155 unsafe fn decode(
1156 &mut self,
1157 decoder: &mut fidl::encoding::Decoder<'_, D>,
1158 offset: usize,
1159 _depth: fidl::encoding::Depth,
1160 ) -> fidl::Result<()> {
1161 decoder.debug_check_bounds::<Self>(offset);
1162 match decoder.read_num::<u8>(offset) {
1163 0 => Ok(()),
1164 _ => Err(fidl::Error::Invalid),
1165 }
1166 }
1167 }
1168
1169 impl fidl::encoding::ValueTypeMarker for LogInterestSelector {
1170 type Borrowed<'a> = &'a Self;
1171 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1172 value
1173 }
1174 }
1175
1176 unsafe impl fidl::encoding::TypeMarker for LogInterestSelector {
1177 type Owned = Self;
1178
1179 #[inline(always)]
1180 fn inline_align(_context: fidl::encoding::Context) -> usize {
1181 8
1182 }
1183
1184 #[inline(always)]
1185 fn inline_size(_context: fidl::encoding::Context) -> usize {
1186 32
1187 }
1188 }
1189
1190 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LogInterestSelector, D>
1191 for &LogInterestSelector
1192 {
1193 #[inline]
1194 unsafe fn encode(
1195 self,
1196 encoder: &mut fidl::encoding::Encoder<'_, D>,
1197 offset: usize,
1198 _depth: fidl::encoding::Depth,
1199 ) -> fidl::Result<()> {
1200 encoder.debug_check_bounds::<LogInterestSelector>(offset);
1201 fidl::encoding::Encode::<LogInterestSelector, D>::encode(
1203 (
1204 <ComponentSelector as fidl::encoding::ValueTypeMarker>::borrow(&self.selector),
1205 <fidl_fuchsia_diagnostics_types__common::Interest as fidl::encoding::ValueTypeMarker>::borrow(&self.interest),
1206 ),
1207 encoder, offset, _depth
1208 )
1209 }
1210 }
1211 unsafe impl<
1212 D: fidl::encoding::ResourceDialect,
1213 T0: fidl::encoding::Encode<ComponentSelector, D>,
1214 T1: fidl::encoding::Encode<fidl_fuchsia_diagnostics_types__common::Interest, D>,
1215 > fidl::encoding::Encode<LogInterestSelector, D> for (T0, T1)
1216 {
1217 #[inline]
1218 unsafe fn encode(
1219 self,
1220 encoder: &mut fidl::encoding::Encoder<'_, D>,
1221 offset: usize,
1222 depth: fidl::encoding::Depth,
1223 ) -> fidl::Result<()> {
1224 encoder.debug_check_bounds::<LogInterestSelector>(offset);
1225 self.0.encode(encoder, offset + 0, depth)?;
1229 self.1.encode(encoder, offset + 16, depth)?;
1230 Ok(())
1231 }
1232 }
1233
1234 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogInterestSelector {
1235 #[inline(always)]
1236 fn new_empty() -> Self {
1237 Self {
1238 selector: fidl::new_empty!(ComponentSelector, D),
1239 interest: fidl::new_empty!(fidl_fuchsia_diagnostics_types__common::Interest, D),
1240 }
1241 }
1242
1243 #[inline]
1244 unsafe fn decode(
1245 &mut self,
1246 decoder: &mut fidl::encoding::Decoder<'_, D>,
1247 offset: usize,
1248 _depth: fidl::encoding::Depth,
1249 ) -> fidl::Result<()> {
1250 decoder.debug_check_bounds::<Self>(offset);
1251 fidl::decode!(ComponentSelector, D, &mut self.selector, decoder, offset + 0, _depth)?;
1253 fidl::decode!(
1254 fidl_fuchsia_diagnostics_types__common::Interest,
1255 D,
1256 &mut self.interest,
1257 decoder,
1258 offset + 16,
1259 _depth
1260 )?;
1261 Ok(())
1262 }
1263 }
1264
1265 impl fidl::encoding::ValueTypeMarker for LogSettingsRegisterInterestRequest {
1266 type Borrowed<'a> = &'a Self;
1267 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1268 value
1269 }
1270 }
1271
1272 unsafe impl fidl::encoding::TypeMarker for LogSettingsRegisterInterestRequest {
1273 type Owned = Self;
1274
1275 #[inline(always)]
1276 fn inline_align(_context: fidl::encoding::Context) -> usize {
1277 8
1278 }
1279
1280 #[inline(always)]
1281 fn inline_size(_context: fidl::encoding::Context) -> usize {
1282 16
1283 }
1284 }
1285
1286 unsafe impl<D: fidl::encoding::ResourceDialect>
1287 fidl::encoding::Encode<LogSettingsRegisterInterestRequest, D>
1288 for &LogSettingsRegisterInterestRequest
1289 {
1290 #[inline]
1291 unsafe fn encode(
1292 self,
1293 encoder: &mut fidl::encoding::Encoder<'_, D>,
1294 offset: usize,
1295 _depth: fidl::encoding::Depth,
1296 ) -> fidl::Result<()> {
1297 encoder.debug_check_bounds::<LogSettingsRegisterInterestRequest>(offset);
1298 fidl::encoding::Encode::<LogSettingsRegisterInterestRequest, D>::encode(
1300 (
1301 <fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.selectors),
1302 ),
1303 encoder, offset, _depth
1304 )
1305 }
1306 }
1307 unsafe impl<
1308 D: fidl::encoding::ResourceDialect,
1309 T0: fidl::encoding::Encode<fidl::encoding::Vector<LogInterestSelector, 64>, D>,
1310 > fidl::encoding::Encode<LogSettingsRegisterInterestRequest, D> for (T0,)
1311 {
1312 #[inline]
1313 unsafe fn encode(
1314 self,
1315 encoder: &mut fidl::encoding::Encoder<'_, D>,
1316 offset: usize,
1317 depth: fidl::encoding::Depth,
1318 ) -> fidl::Result<()> {
1319 encoder.debug_check_bounds::<LogSettingsRegisterInterestRequest>(offset);
1320 self.0.encode(encoder, offset + 0, depth)?;
1324 Ok(())
1325 }
1326 }
1327
1328 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1329 for LogSettingsRegisterInterestRequest
1330 {
1331 #[inline(always)]
1332 fn new_empty() -> Self {
1333 Self { selectors: fidl::new_empty!(fidl::encoding::Vector<LogInterestSelector, 64>, D) }
1334 }
1335
1336 #[inline]
1337 unsafe fn decode(
1338 &mut self,
1339 decoder: &mut fidl::encoding::Decoder<'_, D>,
1340 offset: usize,
1341 _depth: fidl::encoding::Depth,
1342 ) -> fidl::Result<()> {
1343 decoder.debug_check_bounds::<Self>(offset);
1344 fidl::decode!(fidl::encoding::Vector<LogInterestSelector, 64>, D, &mut self.selectors, decoder, offset + 0, _depth)?;
1346 Ok(())
1347 }
1348 }
1349
1350 impl fidl::encoding::ValueTypeMarker for LogSettingsSetInterestRequest {
1351 type Borrowed<'a> = &'a Self;
1352 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1353 value
1354 }
1355 }
1356
1357 unsafe impl fidl::encoding::TypeMarker for LogSettingsSetInterestRequest {
1358 type Owned = Self;
1359
1360 #[inline(always)]
1361 fn inline_align(_context: fidl::encoding::Context) -> usize {
1362 8
1363 }
1364
1365 #[inline(always)]
1366 fn inline_size(_context: fidl::encoding::Context) -> usize {
1367 16
1368 }
1369 }
1370
1371 unsafe impl<D: fidl::encoding::ResourceDialect>
1372 fidl::encoding::Encode<LogSettingsSetInterestRequest, D>
1373 for &LogSettingsSetInterestRequest
1374 {
1375 #[inline]
1376 unsafe fn encode(
1377 self,
1378 encoder: &mut fidl::encoding::Encoder<'_, D>,
1379 offset: usize,
1380 _depth: fidl::encoding::Depth,
1381 ) -> fidl::Result<()> {
1382 encoder.debug_check_bounds::<LogSettingsSetInterestRequest>(offset);
1383 fidl::encoding::Encode::<LogSettingsSetInterestRequest, D>::encode(
1385 (
1386 <fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.selectors),
1387 ),
1388 encoder, offset, _depth
1389 )
1390 }
1391 }
1392 unsafe impl<
1393 D: fidl::encoding::ResourceDialect,
1394 T0: fidl::encoding::Encode<fidl::encoding::Vector<LogInterestSelector, 64>, D>,
1395 > fidl::encoding::Encode<LogSettingsSetInterestRequest, D> for (T0,)
1396 {
1397 #[inline]
1398 unsafe fn encode(
1399 self,
1400 encoder: &mut fidl::encoding::Encoder<'_, D>,
1401 offset: usize,
1402 depth: fidl::encoding::Depth,
1403 ) -> fidl::Result<()> {
1404 encoder.debug_check_bounds::<LogSettingsSetInterestRequest>(offset);
1405 self.0.encode(encoder, offset + 0, depth)?;
1409 Ok(())
1410 }
1411 }
1412
1413 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1414 for LogSettingsSetInterestRequest
1415 {
1416 #[inline(always)]
1417 fn new_empty() -> Self {
1418 Self { selectors: fidl::new_empty!(fidl::encoding::Vector<LogInterestSelector, 64>, D) }
1419 }
1420
1421 #[inline]
1422 unsafe fn decode(
1423 &mut self,
1424 decoder: &mut fidl::encoding::Decoder<'_, D>,
1425 offset: usize,
1426 _depth: fidl::encoding::Depth,
1427 ) -> fidl::Result<()> {
1428 decoder.debug_check_bounds::<Self>(offset);
1429 fidl::decode!(fidl::encoding::Vector<LogInterestSelector, 64>, D, &mut self.selectors, decoder, offset + 0, _depth)?;
1431 Ok(())
1432 }
1433 }
1434
1435 impl fidl::encoding::ValueTypeMarker for PropertySelector {
1436 type Borrowed<'a> = &'a Self;
1437 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1438 value
1439 }
1440 }
1441
1442 unsafe impl fidl::encoding::TypeMarker for PropertySelector {
1443 type Owned = Self;
1444
1445 #[inline(always)]
1446 fn inline_align(_context: fidl::encoding::Context) -> usize {
1447 8
1448 }
1449
1450 #[inline(always)]
1451 fn inline_size(_context: fidl::encoding::Context) -> usize {
1452 32
1453 }
1454 }
1455
1456 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PropertySelector, D>
1457 for &PropertySelector
1458 {
1459 #[inline]
1460 unsafe fn encode(
1461 self,
1462 encoder: &mut fidl::encoding::Encoder<'_, D>,
1463 offset: usize,
1464 _depth: fidl::encoding::Depth,
1465 ) -> fidl::Result<()> {
1466 encoder.debug_check_bounds::<PropertySelector>(offset);
1467 fidl::encoding::Encode::<PropertySelector, D>::encode(
1469 (
1470 <fidl::encoding::Vector<StringSelector, 100> as fidl::encoding::ValueTypeMarker>::borrow(&self.node_path),
1471 <StringSelector as fidl::encoding::ValueTypeMarker>::borrow(&self.target_properties),
1472 ),
1473 encoder, offset, _depth
1474 )
1475 }
1476 }
1477 unsafe impl<
1478 D: fidl::encoding::ResourceDialect,
1479 T0: fidl::encoding::Encode<fidl::encoding::Vector<StringSelector, 100>, D>,
1480 T1: fidl::encoding::Encode<StringSelector, D>,
1481 > fidl::encoding::Encode<PropertySelector, D> for (T0, T1)
1482 {
1483 #[inline]
1484 unsafe fn encode(
1485 self,
1486 encoder: &mut fidl::encoding::Encoder<'_, D>,
1487 offset: usize,
1488 depth: fidl::encoding::Depth,
1489 ) -> fidl::Result<()> {
1490 encoder.debug_check_bounds::<PropertySelector>(offset);
1491 self.0.encode(encoder, offset + 0, depth)?;
1495 self.1.encode(encoder, offset + 16, depth)?;
1496 Ok(())
1497 }
1498 }
1499
1500 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PropertySelector {
1501 #[inline(always)]
1502 fn new_empty() -> Self {
1503 Self {
1504 node_path: fidl::new_empty!(fidl::encoding::Vector<StringSelector, 100>, D),
1505 target_properties: fidl::new_empty!(StringSelector, D),
1506 }
1507 }
1508
1509 #[inline]
1510 unsafe fn decode(
1511 &mut self,
1512 decoder: &mut fidl::encoding::Decoder<'_, D>,
1513 offset: usize,
1514 _depth: fidl::encoding::Depth,
1515 ) -> fidl::Result<()> {
1516 decoder.debug_check_bounds::<Self>(offset);
1517 fidl::decode!(fidl::encoding::Vector<StringSelector, 100>, D, &mut self.node_path, decoder, offset + 0, _depth)?;
1519 fidl::decode!(
1520 StringSelector,
1521 D,
1522 &mut self.target_properties,
1523 decoder,
1524 offset + 16,
1525 _depth
1526 )?;
1527 Ok(())
1528 }
1529 }
1530
1531 impl fidl::encoding::ValueTypeMarker for SubtreeSelector {
1532 type Borrowed<'a> = &'a Self;
1533 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1534 value
1535 }
1536 }
1537
1538 unsafe impl fidl::encoding::TypeMarker for SubtreeSelector {
1539 type Owned = Self;
1540
1541 #[inline(always)]
1542 fn inline_align(_context: fidl::encoding::Context) -> usize {
1543 8
1544 }
1545
1546 #[inline(always)]
1547 fn inline_size(_context: fidl::encoding::Context) -> usize {
1548 16
1549 }
1550 }
1551
1552 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubtreeSelector, D>
1553 for &SubtreeSelector
1554 {
1555 #[inline]
1556 unsafe fn encode(
1557 self,
1558 encoder: &mut fidl::encoding::Encoder<'_, D>,
1559 offset: usize,
1560 _depth: fidl::encoding::Depth,
1561 ) -> fidl::Result<()> {
1562 encoder.debug_check_bounds::<SubtreeSelector>(offset);
1563 fidl::encoding::Encode::<SubtreeSelector, D>::encode(
1565 (
1566 <fidl::encoding::Vector<StringSelector, 100> as fidl::encoding::ValueTypeMarker>::borrow(&self.node_path),
1567 ),
1568 encoder, offset, _depth
1569 )
1570 }
1571 }
1572 unsafe impl<
1573 D: fidl::encoding::ResourceDialect,
1574 T0: fidl::encoding::Encode<fidl::encoding::Vector<StringSelector, 100>, D>,
1575 > fidl::encoding::Encode<SubtreeSelector, D> for (T0,)
1576 {
1577 #[inline]
1578 unsafe fn encode(
1579 self,
1580 encoder: &mut fidl::encoding::Encoder<'_, D>,
1581 offset: usize,
1582 depth: fidl::encoding::Depth,
1583 ) -> fidl::Result<()> {
1584 encoder.debug_check_bounds::<SubtreeSelector>(offset);
1585 self.0.encode(encoder, offset + 0, depth)?;
1589 Ok(())
1590 }
1591 }
1592
1593 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubtreeSelector {
1594 #[inline(always)]
1595 fn new_empty() -> Self {
1596 Self { node_path: fidl::new_empty!(fidl::encoding::Vector<StringSelector, 100>, D) }
1597 }
1598
1599 #[inline]
1600 unsafe fn decode(
1601 &mut self,
1602 decoder: &mut fidl::encoding::Decoder<'_, D>,
1603 offset: usize,
1604 _depth: fidl::encoding::Depth,
1605 ) -> fidl::Result<()> {
1606 decoder.debug_check_bounds::<Self>(offset);
1607 fidl::decode!(fidl::encoding::Vector<StringSelector, 100>, D, &mut self.node_path, decoder, offset + 0, _depth)?;
1609 Ok(())
1610 }
1611 }
1612
1613 impl ComponentSelector {
1614 #[inline(always)]
1615 fn max_ordinal_present(&self) -> u64 {
1616 if let Some(_) = self.moniker_segments {
1617 return 1;
1618 }
1619 0
1620 }
1621 }
1622
1623 impl fidl::encoding::ValueTypeMarker for ComponentSelector {
1624 type Borrowed<'a> = &'a Self;
1625 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1626 value
1627 }
1628 }
1629
1630 unsafe impl fidl::encoding::TypeMarker for ComponentSelector {
1631 type Owned = Self;
1632
1633 #[inline(always)]
1634 fn inline_align(_context: fidl::encoding::Context) -> usize {
1635 8
1636 }
1637
1638 #[inline(always)]
1639 fn inline_size(_context: fidl::encoding::Context) -> usize {
1640 16
1641 }
1642 }
1643
1644 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentSelector, D>
1645 for &ComponentSelector
1646 {
1647 unsafe fn encode(
1648 self,
1649 encoder: &mut fidl::encoding::Encoder<'_, D>,
1650 offset: usize,
1651 mut depth: fidl::encoding::Depth,
1652 ) -> fidl::Result<()> {
1653 encoder.debug_check_bounds::<ComponentSelector>(offset);
1654 let max_ordinal: u64 = self.max_ordinal_present();
1656 encoder.write_num(max_ordinal, offset);
1657 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1658 if max_ordinal == 0 {
1660 return Ok(());
1661 }
1662 depth.increment()?;
1663 let envelope_size = 8;
1664 let bytes_len = max_ordinal as usize * envelope_size;
1665 #[allow(unused_variables)]
1666 let offset = encoder.out_of_line_offset(bytes_len);
1667 let mut _prev_end_offset: usize = 0;
1668 if 1 > max_ordinal {
1669 return Ok(());
1670 }
1671
1672 let cur_offset: usize = (1 - 1) * envelope_size;
1675
1676 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1678
1679 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<StringSelector, 25>, D>(
1684 self.moniker_segments.as_ref().map(<fidl::encoding::Vector<StringSelector, 25> as fidl::encoding::ValueTypeMarker>::borrow),
1685 encoder, offset + cur_offset, depth
1686 )?;
1687
1688 _prev_end_offset = cur_offset + envelope_size;
1689
1690 Ok(())
1691 }
1692 }
1693
1694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentSelector {
1695 #[inline(always)]
1696 fn new_empty() -> Self {
1697 Self::default()
1698 }
1699
1700 unsafe fn decode(
1701 &mut self,
1702 decoder: &mut fidl::encoding::Decoder<'_, D>,
1703 offset: usize,
1704 mut depth: fidl::encoding::Depth,
1705 ) -> fidl::Result<()> {
1706 decoder.debug_check_bounds::<Self>(offset);
1707 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1708 None => return Err(fidl::Error::NotNullable),
1709 Some(len) => len,
1710 };
1711 if len == 0 {
1713 return Ok(());
1714 };
1715 depth.increment()?;
1716 let envelope_size = 8;
1717 let bytes_len = len * envelope_size;
1718 let offset = decoder.out_of_line_offset(bytes_len)?;
1719 let mut _next_ordinal_to_read = 0;
1721 let mut next_offset = offset;
1722 let end_offset = offset + bytes_len;
1723 _next_ordinal_to_read += 1;
1724 if next_offset >= end_offset {
1725 return Ok(());
1726 }
1727
1728 while _next_ordinal_to_read < 1 {
1730 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1731 _next_ordinal_to_read += 1;
1732 next_offset += envelope_size;
1733 }
1734
1735 let next_out_of_line = decoder.next_out_of_line();
1736 let handles_before = decoder.remaining_handles();
1737 if let Some((inlined, num_bytes, num_handles)) =
1738 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1739 {
1740 let member_inline_size = <fidl::encoding::Vector<StringSelector, 25> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1741 if inlined != (member_inline_size <= 4) {
1742 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1743 }
1744 let inner_offset;
1745 let mut inner_depth = depth.clone();
1746 if inlined {
1747 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1748 inner_offset = next_offset;
1749 } else {
1750 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1751 inner_depth.increment()?;
1752 }
1753 let val_ref = self.moniker_segments.get_or_insert_with(
1754 || fidl::new_empty!(fidl::encoding::Vector<StringSelector, 25>, D),
1755 );
1756 fidl::decode!(fidl::encoding::Vector<StringSelector, 25>, D, val_ref, decoder, inner_offset, inner_depth)?;
1757 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1758 {
1759 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1760 }
1761 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1762 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1763 }
1764 }
1765
1766 next_offset += envelope_size;
1767
1768 while next_offset < end_offset {
1770 _next_ordinal_to_read += 1;
1771 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1772 next_offset += envelope_size;
1773 }
1774
1775 Ok(())
1776 }
1777 }
1778
1779 impl Interest {
1780 #[inline(always)]
1781 fn max_ordinal_present(&self) -> u64 {
1782 if let Some(_) = self.min_severity {
1783 return 1;
1784 }
1785 0
1786 }
1787 }
1788
1789 impl fidl::encoding::ValueTypeMarker for Interest {
1790 type Borrowed<'a> = &'a Self;
1791 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1792 value
1793 }
1794 }
1795
1796 unsafe impl fidl::encoding::TypeMarker for Interest {
1797 type Owned = Self;
1798
1799 #[inline(always)]
1800 fn inline_align(_context: fidl::encoding::Context) -> usize {
1801 8
1802 }
1803
1804 #[inline(always)]
1805 fn inline_size(_context: fidl::encoding::Context) -> usize {
1806 16
1807 }
1808 }
1809
1810 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Interest, D> for &Interest {
1811 unsafe fn encode(
1812 self,
1813 encoder: &mut fidl::encoding::Encoder<'_, D>,
1814 offset: usize,
1815 mut depth: fidl::encoding::Depth,
1816 ) -> fidl::Result<()> {
1817 encoder.debug_check_bounds::<Interest>(offset);
1818 let max_ordinal: u64 = self.max_ordinal_present();
1820 encoder.write_num(max_ordinal, offset);
1821 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1822 if max_ordinal == 0 {
1824 return Ok(());
1825 }
1826 depth.increment()?;
1827 let envelope_size = 8;
1828 let bytes_len = max_ordinal as usize * envelope_size;
1829 #[allow(unused_variables)]
1830 let offset = encoder.out_of_line_offset(bytes_len);
1831 let mut _prev_end_offset: usize = 0;
1832 if 1 > max_ordinal {
1833 return Ok(());
1834 }
1835
1836 let cur_offset: usize = (1 - 1) * envelope_size;
1839
1840 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1842
1843 fidl::encoding::encode_in_envelope_optional::<Severity, D>(
1848 self.min_severity
1849 .as_ref()
1850 .map(<Severity as fidl::encoding::ValueTypeMarker>::borrow),
1851 encoder,
1852 offset + cur_offset,
1853 depth,
1854 )?;
1855
1856 _prev_end_offset = cur_offset + envelope_size;
1857
1858 Ok(())
1859 }
1860 }
1861
1862 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Interest {
1863 #[inline(always)]
1864 fn new_empty() -> Self {
1865 Self::default()
1866 }
1867
1868 unsafe fn decode(
1869 &mut self,
1870 decoder: &mut fidl::encoding::Decoder<'_, D>,
1871 offset: usize,
1872 mut depth: fidl::encoding::Depth,
1873 ) -> fidl::Result<()> {
1874 decoder.debug_check_bounds::<Self>(offset);
1875 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1876 None => return Err(fidl::Error::NotNullable),
1877 Some(len) => len,
1878 };
1879 if len == 0 {
1881 return Ok(());
1882 };
1883 depth.increment()?;
1884 let envelope_size = 8;
1885 let bytes_len = len * envelope_size;
1886 let offset = decoder.out_of_line_offset(bytes_len)?;
1887 let mut _next_ordinal_to_read = 0;
1889 let mut next_offset = offset;
1890 let end_offset = offset + bytes_len;
1891 _next_ordinal_to_read += 1;
1892 if next_offset >= end_offset {
1893 return Ok(());
1894 }
1895
1896 while _next_ordinal_to_read < 1 {
1898 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1899 _next_ordinal_to_read += 1;
1900 next_offset += envelope_size;
1901 }
1902
1903 let next_out_of_line = decoder.next_out_of_line();
1904 let handles_before = decoder.remaining_handles();
1905 if let Some((inlined, num_bytes, num_handles)) =
1906 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1907 {
1908 let member_inline_size =
1909 <Severity as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1910 if inlined != (member_inline_size <= 4) {
1911 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1912 }
1913 let inner_offset;
1914 let mut inner_depth = depth.clone();
1915 if inlined {
1916 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1917 inner_offset = next_offset;
1918 } else {
1919 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1920 inner_depth.increment()?;
1921 }
1922 let val_ref =
1923 self.min_severity.get_or_insert_with(|| fidl::new_empty!(Severity, D));
1924 fidl::decode!(Severity, D, val_ref, decoder, inner_offset, inner_depth)?;
1925 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1926 {
1927 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1928 }
1929 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1930 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1931 }
1932 }
1933
1934 next_offset += envelope_size;
1935
1936 while next_offset < end_offset {
1938 _next_ordinal_to_read += 1;
1939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1940 next_offset += envelope_size;
1941 }
1942
1943 Ok(())
1944 }
1945 }
1946
1947 impl LogSettingsSetComponentInterestRequest {
1948 #[inline(always)]
1949 fn max_ordinal_present(&self) -> u64 {
1950 if let Some(_) = self.persist {
1951 return 2;
1952 }
1953 if let Some(_) = self.selectors {
1954 return 1;
1955 }
1956 0
1957 }
1958 }
1959
1960 impl fidl::encoding::ValueTypeMarker for LogSettingsSetComponentInterestRequest {
1961 type Borrowed<'a> = &'a Self;
1962 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1963 value
1964 }
1965 }
1966
1967 unsafe impl fidl::encoding::TypeMarker for LogSettingsSetComponentInterestRequest {
1968 type Owned = Self;
1969
1970 #[inline(always)]
1971 fn inline_align(_context: fidl::encoding::Context) -> usize {
1972 8
1973 }
1974
1975 #[inline(always)]
1976 fn inline_size(_context: fidl::encoding::Context) -> usize {
1977 16
1978 }
1979 }
1980
1981 unsafe impl<D: fidl::encoding::ResourceDialect>
1982 fidl::encoding::Encode<LogSettingsSetComponentInterestRequest, D>
1983 for &LogSettingsSetComponentInterestRequest
1984 {
1985 unsafe fn encode(
1986 self,
1987 encoder: &mut fidl::encoding::Encoder<'_, D>,
1988 offset: usize,
1989 mut depth: fidl::encoding::Depth,
1990 ) -> fidl::Result<()> {
1991 encoder.debug_check_bounds::<LogSettingsSetComponentInterestRequest>(offset);
1992 let max_ordinal: u64 = self.max_ordinal_present();
1994 encoder.write_num(max_ordinal, offset);
1995 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1996 if max_ordinal == 0 {
1998 return Ok(());
1999 }
2000 depth.increment()?;
2001 let envelope_size = 8;
2002 let bytes_len = max_ordinal as usize * envelope_size;
2003 #[allow(unused_variables)]
2004 let offset = encoder.out_of_line_offset(bytes_len);
2005 let mut _prev_end_offset: usize = 0;
2006 if 1 > max_ordinal {
2007 return Ok(());
2008 }
2009
2010 let cur_offset: usize = (1 - 1) * envelope_size;
2013
2014 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2016
2017 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<LogInterestSelector, 64>, D>(
2022 self.selectors.as_ref().map(<fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::ValueTypeMarker>::borrow),
2023 encoder, offset + cur_offset, depth
2024 )?;
2025
2026 _prev_end_offset = cur_offset + envelope_size;
2027 if 2 > max_ordinal {
2028 return Ok(());
2029 }
2030
2031 let cur_offset: usize = (2 - 1) * envelope_size;
2034
2035 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2037
2038 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2043 self.persist.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2044 encoder,
2045 offset + cur_offset,
2046 depth,
2047 )?;
2048
2049 _prev_end_offset = cur_offset + envelope_size;
2050
2051 Ok(())
2052 }
2053 }
2054
2055 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2056 for LogSettingsSetComponentInterestRequest
2057 {
2058 #[inline(always)]
2059 fn new_empty() -> Self {
2060 Self::default()
2061 }
2062
2063 unsafe fn decode(
2064 &mut self,
2065 decoder: &mut fidl::encoding::Decoder<'_, D>,
2066 offset: usize,
2067 mut depth: fidl::encoding::Depth,
2068 ) -> fidl::Result<()> {
2069 decoder.debug_check_bounds::<Self>(offset);
2070 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2071 None => return Err(fidl::Error::NotNullable),
2072 Some(len) => len,
2073 };
2074 if len == 0 {
2076 return Ok(());
2077 };
2078 depth.increment()?;
2079 let envelope_size = 8;
2080 let bytes_len = len * envelope_size;
2081 let offset = decoder.out_of_line_offset(bytes_len)?;
2082 let mut _next_ordinal_to_read = 0;
2084 let mut next_offset = offset;
2085 let end_offset = offset + bytes_len;
2086 _next_ordinal_to_read += 1;
2087 if next_offset >= end_offset {
2088 return Ok(());
2089 }
2090
2091 while _next_ordinal_to_read < 1 {
2093 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2094 _next_ordinal_to_read += 1;
2095 next_offset += envelope_size;
2096 }
2097
2098 let next_out_of_line = decoder.next_out_of_line();
2099 let handles_before = decoder.remaining_handles();
2100 if let Some((inlined, num_bytes, num_handles)) =
2101 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2102 {
2103 let member_inline_size = <fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2104 if inlined != (member_inline_size <= 4) {
2105 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2106 }
2107 let inner_offset;
2108 let mut inner_depth = depth.clone();
2109 if inlined {
2110 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2111 inner_offset = next_offset;
2112 } else {
2113 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2114 inner_depth.increment()?;
2115 }
2116 let val_ref = self.selectors.get_or_insert_with(
2117 || fidl::new_empty!(fidl::encoding::Vector<LogInterestSelector, 64>, D),
2118 );
2119 fidl::decode!(fidl::encoding::Vector<LogInterestSelector, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
2120 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2121 {
2122 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2123 }
2124 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2125 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2126 }
2127 }
2128
2129 next_offset += envelope_size;
2130 _next_ordinal_to_read += 1;
2131 if next_offset >= end_offset {
2132 return Ok(());
2133 }
2134
2135 while _next_ordinal_to_read < 2 {
2137 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2138 _next_ordinal_to_read += 1;
2139 next_offset += envelope_size;
2140 }
2141
2142 let next_out_of_line = decoder.next_out_of_line();
2143 let handles_before = decoder.remaining_handles();
2144 if let Some((inlined, num_bytes, num_handles)) =
2145 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2146 {
2147 let member_inline_size =
2148 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2149 if inlined != (member_inline_size <= 4) {
2150 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2151 }
2152 let inner_offset;
2153 let mut inner_depth = depth.clone();
2154 if inlined {
2155 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2156 inner_offset = next_offset;
2157 } else {
2158 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2159 inner_depth.increment()?;
2160 }
2161 let val_ref = self.persist.get_or_insert_with(|| fidl::new_empty!(bool, D));
2162 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2164 {
2165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2166 }
2167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2169 }
2170 }
2171
2172 next_offset += envelope_size;
2173
2174 while next_offset < end_offset {
2176 _next_ordinal_to_read += 1;
2177 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2178 next_offset += envelope_size;
2179 }
2180
2181 Ok(())
2182 }
2183 }
2184
2185 impl LogStreamOptions {
2186 #[inline(always)]
2187 fn max_ordinal_present(&self) -> u64 {
2188 if let Some(_) = self.include_rolled_out {
2189 return 4;
2190 }
2191 if let Some(_) = self.include_component_url {
2192 return 3;
2193 }
2194 if let Some(_) = self.include_moniker {
2195 return 2;
2196 }
2197 if let Some(_) = self.mode {
2198 return 1;
2199 }
2200 0
2201 }
2202 }
2203
2204 impl fidl::encoding::ValueTypeMarker for LogStreamOptions {
2205 type Borrowed<'a> = &'a Self;
2206 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2207 value
2208 }
2209 }
2210
2211 unsafe impl fidl::encoding::TypeMarker for LogStreamOptions {
2212 type Owned = Self;
2213
2214 #[inline(always)]
2215 fn inline_align(_context: fidl::encoding::Context) -> usize {
2216 8
2217 }
2218
2219 #[inline(always)]
2220 fn inline_size(_context: fidl::encoding::Context) -> usize {
2221 16
2222 }
2223 }
2224
2225 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LogStreamOptions, D>
2226 for &LogStreamOptions
2227 {
2228 unsafe fn encode(
2229 self,
2230 encoder: &mut fidl::encoding::Encoder<'_, D>,
2231 offset: usize,
2232 mut depth: fidl::encoding::Depth,
2233 ) -> fidl::Result<()> {
2234 encoder.debug_check_bounds::<LogStreamOptions>(offset);
2235 let max_ordinal: u64 = self.max_ordinal_present();
2237 encoder.write_num(max_ordinal, offset);
2238 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2239 if max_ordinal == 0 {
2241 return Ok(());
2242 }
2243 depth.increment()?;
2244 let envelope_size = 8;
2245 let bytes_len = max_ordinal as usize * envelope_size;
2246 #[allow(unused_variables)]
2247 let offset = encoder.out_of_line_offset(bytes_len);
2248 let mut _prev_end_offset: usize = 0;
2249 if 1 > max_ordinal {
2250 return Ok(());
2251 }
2252
2253 let cur_offset: usize = (1 - 1) * envelope_size;
2256
2257 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2259
2260 fidl::encoding::encode_in_envelope_optional::<StreamMode, D>(
2265 self.mode.as_ref().map(<StreamMode as fidl::encoding::ValueTypeMarker>::borrow),
2266 encoder,
2267 offset + cur_offset,
2268 depth,
2269 )?;
2270
2271 _prev_end_offset = cur_offset + envelope_size;
2272 if 2 > max_ordinal {
2273 return Ok(());
2274 }
2275
2276 let cur_offset: usize = (2 - 1) * envelope_size;
2279
2280 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2282
2283 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2288 self.include_moniker
2289 .as_ref()
2290 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2291 encoder,
2292 offset + cur_offset,
2293 depth,
2294 )?;
2295
2296 _prev_end_offset = cur_offset + envelope_size;
2297 if 3 > max_ordinal {
2298 return Ok(());
2299 }
2300
2301 let cur_offset: usize = (3 - 1) * envelope_size;
2304
2305 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2307
2308 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2313 self.include_component_url
2314 .as_ref()
2315 .map(<bool 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 4 > max_ordinal {
2323 return Ok(());
2324 }
2325
2326 let cur_offset: usize = (4 - 1) * envelope_size;
2329
2330 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2332
2333 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2338 self.include_rolled_out
2339 .as_ref()
2340 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2341 encoder,
2342 offset + cur_offset,
2343 depth,
2344 )?;
2345
2346 _prev_end_offset = cur_offset + envelope_size;
2347
2348 Ok(())
2349 }
2350 }
2351
2352 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogStreamOptions {
2353 #[inline(always)]
2354 fn new_empty() -> Self {
2355 Self::default()
2356 }
2357
2358 unsafe fn decode(
2359 &mut self,
2360 decoder: &mut fidl::encoding::Decoder<'_, D>,
2361 offset: usize,
2362 mut depth: fidl::encoding::Depth,
2363 ) -> fidl::Result<()> {
2364 decoder.debug_check_bounds::<Self>(offset);
2365 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2366 None => return Err(fidl::Error::NotNullable),
2367 Some(len) => len,
2368 };
2369 if len == 0 {
2371 return Ok(());
2372 };
2373 depth.increment()?;
2374 let envelope_size = 8;
2375 let bytes_len = len * envelope_size;
2376 let offset = decoder.out_of_line_offset(bytes_len)?;
2377 let mut _next_ordinal_to_read = 0;
2379 let mut next_offset = offset;
2380 let end_offset = offset + bytes_len;
2381 _next_ordinal_to_read += 1;
2382 if next_offset >= end_offset {
2383 return Ok(());
2384 }
2385
2386 while _next_ordinal_to_read < 1 {
2388 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2389 _next_ordinal_to_read += 1;
2390 next_offset += envelope_size;
2391 }
2392
2393 let next_out_of_line = decoder.next_out_of_line();
2394 let handles_before = decoder.remaining_handles();
2395 if let Some((inlined, num_bytes, num_handles)) =
2396 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2397 {
2398 let member_inline_size =
2399 <StreamMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2400 if inlined != (member_inline_size <= 4) {
2401 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2402 }
2403 let inner_offset;
2404 let mut inner_depth = depth.clone();
2405 if inlined {
2406 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2407 inner_offset = next_offset;
2408 } else {
2409 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2410 inner_depth.increment()?;
2411 }
2412 let val_ref = self.mode.get_or_insert_with(|| fidl::new_empty!(StreamMode, D));
2413 fidl::decode!(StreamMode, D, val_ref, decoder, inner_offset, inner_depth)?;
2414 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2415 {
2416 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2417 }
2418 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2419 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2420 }
2421 }
2422
2423 next_offset += envelope_size;
2424 _next_ordinal_to_read += 1;
2425 if next_offset >= end_offset {
2426 return Ok(());
2427 }
2428
2429 while _next_ordinal_to_read < 2 {
2431 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2432 _next_ordinal_to_read += 1;
2433 next_offset += envelope_size;
2434 }
2435
2436 let next_out_of_line = decoder.next_out_of_line();
2437 let handles_before = decoder.remaining_handles();
2438 if let Some((inlined, num_bytes, num_handles)) =
2439 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2440 {
2441 let member_inline_size =
2442 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2443 if inlined != (member_inline_size <= 4) {
2444 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2445 }
2446 let inner_offset;
2447 let mut inner_depth = depth.clone();
2448 if inlined {
2449 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2450 inner_offset = next_offset;
2451 } else {
2452 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2453 inner_depth.increment()?;
2454 }
2455 let val_ref = self.include_moniker.get_or_insert_with(|| fidl::new_empty!(bool, D));
2456 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2457 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2458 {
2459 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2460 }
2461 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2462 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2463 }
2464 }
2465
2466 next_offset += envelope_size;
2467 _next_ordinal_to_read += 1;
2468 if next_offset >= end_offset {
2469 return Ok(());
2470 }
2471
2472 while _next_ordinal_to_read < 3 {
2474 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2475 _next_ordinal_to_read += 1;
2476 next_offset += envelope_size;
2477 }
2478
2479 let next_out_of_line = decoder.next_out_of_line();
2480 let handles_before = decoder.remaining_handles();
2481 if let Some((inlined, num_bytes, num_handles)) =
2482 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2483 {
2484 let member_inline_size =
2485 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2486 if inlined != (member_inline_size <= 4) {
2487 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2488 }
2489 let inner_offset;
2490 let mut inner_depth = depth.clone();
2491 if inlined {
2492 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2493 inner_offset = next_offset;
2494 } else {
2495 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2496 inner_depth.increment()?;
2497 }
2498 let val_ref =
2499 self.include_component_url.get_or_insert_with(|| fidl::new_empty!(bool, D));
2500 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2501 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2502 {
2503 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2504 }
2505 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2506 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2507 }
2508 }
2509
2510 next_offset += envelope_size;
2511 _next_ordinal_to_read += 1;
2512 if next_offset >= end_offset {
2513 return Ok(());
2514 }
2515
2516 while _next_ordinal_to_read < 4 {
2518 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2519 _next_ordinal_to_read += 1;
2520 next_offset += envelope_size;
2521 }
2522
2523 let next_out_of_line = decoder.next_out_of_line();
2524 let handles_before = decoder.remaining_handles();
2525 if let Some((inlined, num_bytes, num_handles)) =
2526 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2527 {
2528 let member_inline_size =
2529 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2530 if inlined != (member_inline_size <= 4) {
2531 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2532 }
2533 let inner_offset;
2534 let mut inner_depth = depth.clone();
2535 if inlined {
2536 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2537 inner_offset = next_offset;
2538 } else {
2539 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2540 inner_depth.increment()?;
2541 }
2542 let val_ref =
2543 self.include_rolled_out.get_or_insert_with(|| fidl::new_empty!(bool, D));
2544 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2545 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2546 {
2547 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2548 }
2549 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2550 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2551 }
2552 }
2553
2554 next_offset += envelope_size;
2555
2556 while next_offset < end_offset {
2558 _next_ordinal_to_read += 1;
2559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2560 next_offset += envelope_size;
2561 }
2562
2563 Ok(())
2564 }
2565 }
2566
2567 impl PerformanceConfiguration {
2568 #[inline(always)]
2569 fn max_ordinal_present(&self) -> u64 {
2570 if let Some(_) = self.batch_retrieval_timeout_seconds {
2571 return 2;
2572 }
2573 if let Some(_) = self.max_aggregate_content_size_bytes {
2574 return 1;
2575 }
2576 0
2577 }
2578 }
2579
2580 impl fidl::encoding::ValueTypeMarker for PerformanceConfiguration {
2581 type Borrowed<'a> = &'a Self;
2582 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2583 value
2584 }
2585 }
2586
2587 unsafe impl fidl::encoding::TypeMarker for PerformanceConfiguration {
2588 type Owned = Self;
2589
2590 #[inline(always)]
2591 fn inline_align(_context: fidl::encoding::Context) -> usize {
2592 8
2593 }
2594
2595 #[inline(always)]
2596 fn inline_size(_context: fidl::encoding::Context) -> usize {
2597 16
2598 }
2599 }
2600
2601 unsafe impl<D: fidl::encoding::ResourceDialect>
2602 fidl::encoding::Encode<PerformanceConfiguration, D> for &PerformanceConfiguration
2603 {
2604 unsafe fn encode(
2605 self,
2606 encoder: &mut fidl::encoding::Encoder<'_, D>,
2607 offset: usize,
2608 mut depth: fidl::encoding::Depth,
2609 ) -> fidl::Result<()> {
2610 encoder.debug_check_bounds::<PerformanceConfiguration>(offset);
2611 let max_ordinal: u64 = self.max_ordinal_present();
2613 encoder.write_num(max_ordinal, offset);
2614 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2615 if max_ordinal == 0 {
2617 return Ok(());
2618 }
2619 depth.increment()?;
2620 let envelope_size = 8;
2621 let bytes_len = max_ordinal as usize * envelope_size;
2622 #[allow(unused_variables)]
2623 let offset = encoder.out_of_line_offset(bytes_len);
2624 let mut _prev_end_offset: usize = 0;
2625 if 1 > max_ordinal {
2626 return Ok(());
2627 }
2628
2629 let cur_offset: usize = (1 - 1) * envelope_size;
2632
2633 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2635
2636 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2641 self.max_aggregate_content_size_bytes
2642 .as_ref()
2643 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2644 encoder,
2645 offset + cur_offset,
2646 depth,
2647 )?;
2648
2649 _prev_end_offset = cur_offset + envelope_size;
2650 if 2 > max_ordinal {
2651 return Ok(());
2652 }
2653
2654 let cur_offset: usize = (2 - 1) * envelope_size;
2657
2658 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2660
2661 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2666 self.batch_retrieval_timeout_seconds
2667 .as_ref()
2668 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2669 encoder,
2670 offset + cur_offset,
2671 depth,
2672 )?;
2673
2674 _prev_end_offset = cur_offset + envelope_size;
2675
2676 Ok(())
2677 }
2678 }
2679
2680 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2681 for PerformanceConfiguration
2682 {
2683 #[inline(always)]
2684 fn new_empty() -> Self {
2685 Self::default()
2686 }
2687
2688 unsafe fn decode(
2689 &mut self,
2690 decoder: &mut fidl::encoding::Decoder<'_, D>,
2691 offset: usize,
2692 mut depth: fidl::encoding::Depth,
2693 ) -> fidl::Result<()> {
2694 decoder.debug_check_bounds::<Self>(offset);
2695 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2696 None => return Err(fidl::Error::NotNullable),
2697 Some(len) => len,
2698 };
2699 if len == 0 {
2701 return Ok(());
2702 };
2703 depth.increment()?;
2704 let envelope_size = 8;
2705 let bytes_len = len * envelope_size;
2706 let offset = decoder.out_of_line_offset(bytes_len)?;
2707 let mut _next_ordinal_to_read = 0;
2709 let mut next_offset = offset;
2710 let end_offset = offset + bytes_len;
2711 _next_ordinal_to_read += 1;
2712 if next_offset >= end_offset {
2713 return Ok(());
2714 }
2715
2716 while _next_ordinal_to_read < 1 {
2718 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2719 _next_ordinal_to_read += 1;
2720 next_offset += envelope_size;
2721 }
2722
2723 let next_out_of_line = decoder.next_out_of_line();
2724 let handles_before = decoder.remaining_handles();
2725 if let Some((inlined, num_bytes, num_handles)) =
2726 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2727 {
2728 let member_inline_size =
2729 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2730 if inlined != (member_inline_size <= 4) {
2731 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2732 }
2733 let inner_offset;
2734 let mut inner_depth = depth.clone();
2735 if inlined {
2736 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2737 inner_offset = next_offset;
2738 } else {
2739 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2740 inner_depth.increment()?;
2741 }
2742 let val_ref = self
2743 .max_aggregate_content_size_bytes
2744 .get_or_insert_with(|| fidl::new_empty!(u64, D));
2745 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2746 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2747 {
2748 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2749 }
2750 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2751 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2752 }
2753 }
2754
2755 next_offset += envelope_size;
2756 _next_ordinal_to_read += 1;
2757 if next_offset >= end_offset {
2758 return Ok(());
2759 }
2760
2761 while _next_ordinal_to_read < 2 {
2763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2764 _next_ordinal_to_read += 1;
2765 next_offset += envelope_size;
2766 }
2767
2768 let next_out_of_line = decoder.next_out_of_line();
2769 let handles_before = decoder.remaining_handles();
2770 if let Some((inlined, num_bytes, num_handles)) =
2771 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2772 {
2773 let member_inline_size =
2774 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2775 if inlined != (member_inline_size <= 4) {
2776 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2777 }
2778 let inner_offset;
2779 let mut inner_depth = depth.clone();
2780 if inlined {
2781 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2782 inner_offset = next_offset;
2783 } else {
2784 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2785 inner_depth.increment()?;
2786 }
2787 let val_ref = self
2788 .batch_retrieval_timeout_seconds
2789 .get_or_insert_with(|| fidl::new_empty!(i64, D));
2790 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2791 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2792 {
2793 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2794 }
2795 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2796 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2797 }
2798 }
2799
2800 next_offset += envelope_size;
2801
2802 while next_offset < end_offset {
2804 _next_ordinal_to_read += 1;
2805 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2806 next_offset += envelope_size;
2807 }
2808
2809 Ok(())
2810 }
2811 }
2812
2813 impl Selector {
2814 #[inline(always)]
2815 fn max_ordinal_present(&self) -> u64 {
2816 if let Some(_) = self.tree_names {
2817 return 3;
2818 }
2819 if let Some(_) = self.tree_selector {
2820 return 2;
2821 }
2822 if let Some(_) = self.component_selector {
2823 return 1;
2824 }
2825 0
2826 }
2827 }
2828
2829 impl fidl::encoding::ValueTypeMarker for Selector {
2830 type Borrowed<'a> = &'a Self;
2831 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2832 value
2833 }
2834 }
2835
2836 unsafe impl fidl::encoding::TypeMarker for Selector {
2837 type Owned = Self;
2838
2839 #[inline(always)]
2840 fn inline_align(_context: fidl::encoding::Context) -> usize {
2841 8
2842 }
2843
2844 #[inline(always)]
2845 fn inline_size(_context: fidl::encoding::Context) -> usize {
2846 16
2847 }
2848 }
2849
2850 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Selector, D> for &Selector {
2851 unsafe fn encode(
2852 self,
2853 encoder: &mut fidl::encoding::Encoder<'_, D>,
2854 offset: usize,
2855 mut depth: fidl::encoding::Depth,
2856 ) -> fidl::Result<()> {
2857 encoder.debug_check_bounds::<Selector>(offset);
2858 let max_ordinal: u64 = self.max_ordinal_present();
2860 encoder.write_num(max_ordinal, offset);
2861 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2862 if max_ordinal == 0 {
2864 return Ok(());
2865 }
2866 depth.increment()?;
2867 let envelope_size = 8;
2868 let bytes_len = max_ordinal as usize * envelope_size;
2869 #[allow(unused_variables)]
2870 let offset = encoder.out_of_line_offset(bytes_len);
2871 let mut _prev_end_offset: usize = 0;
2872 if 1 > max_ordinal {
2873 return Ok(());
2874 }
2875
2876 let cur_offset: usize = (1 - 1) * envelope_size;
2879
2880 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2882
2883 fidl::encoding::encode_in_envelope_optional::<ComponentSelector, D>(
2888 self.component_selector
2889 .as_ref()
2890 .map(<ComponentSelector as fidl::encoding::ValueTypeMarker>::borrow),
2891 encoder,
2892 offset + cur_offset,
2893 depth,
2894 )?;
2895
2896 _prev_end_offset = cur_offset + envelope_size;
2897 if 2 > max_ordinal {
2898 return Ok(());
2899 }
2900
2901 let cur_offset: usize = (2 - 1) * envelope_size;
2904
2905 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2907
2908 fidl::encoding::encode_in_envelope_optional::<TreeSelector, D>(
2913 self.tree_selector
2914 .as_ref()
2915 .map(<TreeSelector as fidl::encoding::ValueTypeMarker>::borrow),
2916 encoder,
2917 offset + cur_offset,
2918 depth,
2919 )?;
2920
2921 _prev_end_offset = cur_offset + envelope_size;
2922 if 3 > max_ordinal {
2923 return Ok(());
2924 }
2925
2926 let cur_offset: usize = (3 - 1) * envelope_size;
2929
2930 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2932
2933 fidl::encoding::encode_in_envelope_optional::<TreeNames, D>(
2938 self.tree_names
2939 .as_ref()
2940 .map(<TreeNames as fidl::encoding::ValueTypeMarker>::borrow),
2941 encoder,
2942 offset + cur_offset,
2943 depth,
2944 )?;
2945
2946 _prev_end_offset = cur_offset + envelope_size;
2947
2948 Ok(())
2949 }
2950 }
2951
2952 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Selector {
2953 #[inline(always)]
2954 fn new_empty() -> Self {
2955 Self::default()
2956 }
2957
2958 unsafe fn decode(
2959 &mut self,
2960 decoder: &mut fidl::encoding::Decoder<'_, D>,
2961 offset: usize,
2962 mut depth: fidl::encoding::Depth,
2963 ) -> fidl::Result<()> {
2964 decoder.debug_check_bounds::<Self>(offset);
2965 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2966 None => return Err(fidl::Error::NotNullable),
2967 Some(len) => len,
2968 };
2969 if len == 0 {
2971 return Ok(());
2972 };
2973 depth.increment()?;
2974 let envelope_size = 8;
2975 let bytes_len = len * envelope_size;
2976 let offset = decoder.out_of_line_offset(bytes_len)?;
2977 let mut _next_ordinal_to_read = 0;
2979 let mut next_offset = offset;
2980 let end_offset = offset + bytes_len;
2981 _next_ordinal_to_read += 1;
2982 if next_offset >= end_offset {
2983 return Ok(());
2984 }
2985
2986 while _next_ordinal_to_read < 1 {
2988 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2989 _next_ordinal_to_read += 1;
2990 next_offset += envelope_size;
2991 }
2992
2993 let next_out_of_line = decoder.next_out_of_line();
2994 let handles_before = decoder.remaining_handles();
2995 if let Some((inlined, num_bytes, num_handles)) =
2996 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2997 {
2998 let member_inline_size =
2999 <ComponentSelector as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3000 if inlined != (member_inline_size <= 4) {
3001 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3002 }
3003 let inner_offset;
3004 let mut inner_depth = depth.clone();
3005 if inlined {
3006 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3007 inner_offset = next_offset;
3008 } else {
3009 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3010 inner_depth.increment()?;
3011 }
3012 let val_ref = self
3013 .component_selector
3014 .get_or_insert_with(|| fidl::new_empty!(ComponentSelector, D));
3015 fidl::decode!(ComponentSelector, D, val_ref, decoder, inner_offset, inner_depth)?;
3016 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3017 {
3018 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3019 }
3020 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3021 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3022 }
3023 }
3024
3025 next_offset += envelope_size;
3026 _next_ordinal_to_read += 1;
3027 if next_offset >= end_offset {
3028 return Ok(());
3029 }
3030
3031 while _next_ordinal_to_read < 2 {
3033 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3034 _next_ordinal_to_read += 1;
3035 next_offset += envelope_size;
3036 }
3037
3038 let next_out_of_line = decoder.next_out_of_line();
3039 let handles_before = decoder.remaining_handles();
3040 if let Some((inlined, num_bytes, num_handles)) =
3041 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3042 {
3043 let member_inline_size =
3044 <TreeSelector as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3045 if inlined != (member_inline_size <= 4) {
3046 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3047 }
3048 let inner_offset;
3049 let mut inner_depth = depth.clone();
3050 if inlined {
3051 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3052 inner_offset = next_offset;
3053 } else {
3054 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3055 inner_depth.increment()?;
3056 }
3057 let val_ref =
3058 self.tree_selector.get_or_insert_with(|| fidl::new_empty!(TreeSelector, D));
3059 fidl::decode!(TreeSelector, D, val_ref, decoder, inner_offset, inner_depth)?;
3060 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3061 {
3062 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3063 }
3064 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3065 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3066 }
3067 }
3068
3069 next_offset += envelope_size;
3070 _next_ordinal_to_read += 1;
3071 if next_offset >= end_offset {
3072 return Ok(());
3073 }
3074
3075 while _next_ordinal_to_read < 3 {
3077 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3078 _next_ordinal_to_read += 1;
3079 next_offset += envelope_size;
3080 }
3081
3082 let next_out_of_line = decoder.next_out_of_line();
3083 let handles_before = decoder.remaining_handles();
3084 if let Some((inlined, num_bytes, num_handles)) =
3085 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3086 {
3087 let member_inline_size =
3088 <TreeNames as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3089 if inlined != (member_inline_size <= 4) {
3090 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3091 }
3092 let inner_offset;
3093 let mut inner_depth = depth.clone();
3094 if inlined {
3095 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3096 inner_offset = next_offset;
3097 } else {
3098 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3099 inner_depth.increment()?;
3100 }
3101 let val_ref = self.tree_names.get_or_insert_with(|| fidl::new_empty!(TreeNames, D));
3102 fidl::decode!(TreeNames, D, val_ref, decoder, inner_offset, inner_depth)?;
3103 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3104 {
3105 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3106 }
3107 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3108 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3109 }
3110 }
3111
3112 next_offset += envelope_size;
3113
3114 while next_offset < end_offset {
3116 _next_ordinal_to_read += 1;
3117 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3118 next_offset += envelope_size;
3119 }
3120
3121 Ok(())
3122 }
3123 }
3124
3125 impl StreamParameters {
3126 #[inline(always)]
3127 fn max_ordinal_present(&self) -> u64 {
3128 if let Some(_) = self.performance_configuration {
3129 return 6;
3130 }
3131 if let Some(_) = self.batch_retrieval_timeout_seconds {
3132 return 5;
3133 }
3134 if let Some(_) = self.client_selector_configuration {
3135 return 4;
3136 }
3137 if let Some(_) = self.format {
3138 return 3;
3139 }
3140 if let Some(_) = self.stream_mode {
3141 return 2;
3142 }
3143 if let Some(_) = self.data_type {
3144 return 1;
3145 }
3146 0
3147 }
3148 }
3149
3150 impl fidl::encoding::ValueTypeMarker for StreamParameters {
3151 type Borrowed<'a> = &'a Self;
3152 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3153 value
3154 }
3155 }
3156
3157 unsafe impl fidl::encoding::TypeMarker for StreamParameters {
3158 type Owned = Self;
3159
3160 #[inline(always)]
3161 fn inline_align(_context: fidl::encoding::Context) -> usize {
3162 8
3163 }
3164
3165 #[inline(always)]
3166 fn inline_size(_context: fidl::encoding::Context) -> usize {
3167 16
3168 }
3169 }
3170
3171 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamParameters, D>
3172 for &StreamParameters
3173 {
3174 unsafe fn encode(
3175 self,
3176 encoder: &mut fidl::encoding::Encoder<'_, D>,
3177 offset: usize,
3178 mut depth: fidl::encoding::Depth,
3179 ) -> fidl::Result<()> {
3180 encoder.debug_check_bounds::<StreamParameters>(offset);
3181 let max_ordinal: u64 = self.max_ordinal_present();
3183 encoder.write_num(max_ordinal, offset);
3184 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3185 if max_ordinal == 0 {
3187 return Ok(());
3188 }
3189 depth.increment()?;
3190 let envelope_size = 8;
3191 let bytes_len = max_ordinal as usize * envelope_size;
3192 #[allow(unused_variables)]
3193 let offset = encoder.out_of_line_offset(bytes_len);
3194 let mut _prev_end_offset: usize = 0;
3195 if 1 > max_ordinal {
3196 return Ok(());
3197 }
3198
3199 let cur_offset: usize = (1 - 1) * envelope_size;
3202
3203 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3205
3206 fidl::encoding::encode_in_envelope_optional::<DataType, D>(
3211 self.data_type.as_ref().map(<DataType as fidl::encoding::ValueTypeMarker>::borrow),
3212 encoder,
3213 offset + cur_offset,
3214 depth,
3215 )?;
3216
3217 _prev_end_offset = cur_offset + envelope_size;
3218 if 2 > max_ordinal {
3219 return Ok(());
3220 }
3221
3222 let cur_offset: usize = (2 - 1) * envelope_size;
3225
3226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3228
3229 fidl::encoding::encode_in_envelope_optional::<StreamMode, D>(
3234 self.stream_mode
3235 .as_ref()
3236 .map(<StreamMode as fidl::encoding::ValueTypeMarker>::borrow),
3237 encoder,
3238 offset + cur_offset,
3239 depth,
3240 )?;
3241
3242 _prev_end_offset = cur_offset + envelope_size;
3243 if 3 > max_ordinal {
3244 return Ok(());
3245 }
3246
3247 let cur_offset: usize = (3 - 1) * envelope_size;
3250
3251 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3253
3254 fidl::encoding::encode_in_envelope_optional::<Format, D>(
3259 self.format.as_ref().map(<Format as fidl::encoding::ValueTypeMarker>::borrow),
3260 encoder,
3261 offset + cur_offset,
3262 depth,
3263 )?;
3264
3265 _prev_end_offset = cur_offset + envelope_size;
3266 if 4 > max_ordinal {
3267 return Ok(());
3268 }
3269
3270 let cur_offset: usize = (4 - 1) * envelope_size;
3273
3274 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3276
3277 fidl::encoding::encode_in_envelope_optional::<ClientSelectorConfiguration, D>(
3282 self.client_selector_configuration
3283 .as_ref()
3284 .map(<ClientSelectorConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3285 encoder,
3286 offset + cur_offset,
3287 depth,
3288 )?;
3289
3290 _prev_end_offset = cur_offset + envelope_size;
3291 if 5 > max_ordinal {
3292 return Ok(());
3293 }
3294
3295 let cur_offset: usize = (5 - 1) * envelope_size;
3298
3299 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3301
3302 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3307 self.batch_retrieval_timeout_seconds
3308 .as_ref()
3309 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3310 encoder,
3311 offset + cur_offset,
3312 depth,
3313 )?;
3314
3315 _prev_end_offset = cur_offset + envelope_size;
3316 if 6 > max_ordinal {
3317 return Ok(());
3318 }
3319
3320 let cur_offset: usize = (6 - 1) * envelope_size;
3323
3324 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3326
3327 fidl::encoding::encode_in_envelope_optional::<PerformanceConfiguration, D>(
3332 self.performance_configuration
3333 .as_ref()
3334 .map(<PerformanceConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3335 encoder,
3336 offset + cur_offset,
3337 depth,
3338 )?;
3339
3340 _prev_end_offset = cur_offset + envelope_size;
3341
3342 Ok(())
3343 }
3344 }
3345
3346 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamParameters {
3347 #[inline(always)]
3348 fn new_empty() -> Self {
3349 Self::default()
3350 }
3351
3352 unsafe fn decode(
3353 &mut self,
3354 decoder: &mut fidl::encoding::Decoder<'_, D>,
3355 offset: usize,
3356 mut depth: fidl::encoding::Depth,
3357 ) -> fidl::Result<()> {
3358 decoder.debug_check_bounds::<Self>(offset);
3359 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3360 None => return Err(fidl::Error::NotNullable),
3361 Some(len) => len,
3362 };
3363 if len == 0 {
3365 return Ok(());
3366 };
3367 depth.increment()?;
3368 let envelope_size = 8;
3369 let bytes_len = len * envelope_size;
3370 let offset = decoder.out_of_line_offset(bytes_len)?;
3371 let mut _next_ordinal_to_read = 0;
3373 let mut next_offset = offset;
3374 let end_offset = offset + bytes_len;
3375 _next_ordinal_to_read += 1;
3376 if next_offset >= end_offset {
3377 return Ok(());
3378 }
3379
3380 while _next_ordinal_to_read < 1 {
3382 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3383 _next_ordinal_to_read += 1;
3384 next_offset += envelope_size;
3385 }
3386
3387 let next_out_of_line = decoder.next_out_of_line();
3388 let handles_before = decoder.remaining_handles();
3389 if let Some((inlined, num_bytes, num_handles)) =
3390 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3391 {
3392 let member_inline_size =
3393 <DataType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3394 if inlined != (member_inline_size <= 4) {
3395 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3396 }
3397 let inner_offset;
3398 let mut inner_depth = depth.clone();
3399 if inlined {
3400 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3401 inner_offset = next_offset;
3402 } else {
3403 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3404 inner_depth.increment()?;
3405 }
3406 let val_ref = self.data_type.get_or_insert_with(|| fidl::new_empty!(DataType, D));
3407 fidl::decode!(DataType, D, val_ref, decoder, inner_offset, inner_depth)?;
3408 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3409 {
3410 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3411 }
3412 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3413 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3414 }
3415 }
3416
3417 next_offset += envelope_size;
3418 _next_ordinal_to_read += 1;
3419 if next_offset >= end_offset {
3420 return Ok(());
3421 }
3422
3423 while _next_ordinal_to_read < 2 {
3425 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3426 _next_ordinal_to_read += 1;
3427 next_offset += envelope_size;
3428 }
3429
3430 let next_out_of_line = decoder.next_out_of_line();
3431 let handles_before = decoder.remaining_handles();
3432 if let Some((inlined, num_bytes, num_handles)) =
3433 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3434 {
3435 let member_inline_size =
3436 <StreamMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3437 if inlined != (member_inline_size <= 4) {
3438 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3439 }
3440 let inner_offset;
3441 let mut inner_depth = depth.clone();
3442 if inlined {
3443 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3444 inner_offset = next_offset;
3445 } else {
3446 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3447 inner_depth.increment()?;
3448 }
3449 let val_ref =
3450 self.stream_mode.get_or_insert_with(|| fidl::new_empty!(StreamMode, D));
3451 fidl::decode!(StreamMode, D, val_ref, decoder, inner_offset, inner_depth)?;
3452 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3453 {
3454 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3455 }
3456 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3457 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3458 }
3459 }
3460
3461 next_offset += envelope_size;
3462 _next_ordinal_to_read += 1;
3463 if next_offset >= end_offset {
3464 return Ok(());
3465 }
3466
3467 while _next_ordinal_to_read < 3 {
3469 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3470 _next_ordinal_to_read += 1;
3471 next_offset += envelope_size;
3472 }
3473
3474 let next_out_of_line = decoder.next_out_of_line();
3475 let handles_before = decoder.remaining_handles();
3476 if let Some((inlined, num_bytes, num_handles)) =
3477 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3478 {
3479 let member_inline_size =
3480 <Format as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3481 if inlined != (member_inline_size <= 4) {
3482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3483 }
3484 let inner_offset;
3485 let mut inner_depth = depth.clone();
3486 if inlined {
3487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3488 inner_offset = next_offset;
3489 } else {
3490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3491 inner_depth.increment()?;
3492 }
3493 let val_ref = self.format.get_or_insert_with(|| fidl::new_empty!(Format, D));
3494 fidl::decode!(Format, D, val_ref, decoder, inner_offset, inner_depth)?;
3495 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3496 {
3497 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3498 }
3499 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3500 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3501 }
3502 }
3503
3504 next_offset += envelope_size;
3505 _next_ordinal_to_read += 1;
3506 if next_offset >= end_offset {
3507 return Ok(());
3508 }
3509
3510 while _next_ordinal_to_read < 4 {
3512 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3513 _next_ordinal_to_read += 1;
3514 next_offset += envelope_size;
3515 }
3516
3517 let next_out_of_line = decoder.next_out_of_line();
3518 let handles_before = decoder.remaining_handles();
3519 if let Some((inlined, num_bytes, num_handles)) =
3520 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3521 {
3522 let member_inline_size =
3523 <ClientSelectorConfiguration as fidl::encoding::TypeMarker>::inline_size(
3524 decoder.context,
3525 );
3526 if inlined != (member_inline_size <= 4) {
3527 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3528 }
3529 let inner_offset;
3530 let mut inner_depth = depth.clone();
3531 if inlined {
3532 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3533 inner_offset = next_offset;
3534 } else {
3535 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3536 inner_depth.increment()?;
3537 }
3538 let val_ref = self
3539 .client_selector_configuration
3540 .get_or_insert_with(|| fidl::new_empty!(ClientSelectorConfiguration, D));
3541 fidl::decode!(
3542 ClientSelectorConfiguration,
3543 D,
3544 val_ref,
3545 decoder,
3546 inner_offset,
3547 inner_depth
3548 )?;
3549 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3550 {
3551 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3552 }
3553 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3554 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3555 }
3556 }
3557
3558 next_offset += envelope_size;
3559 _next_ordinal_to_read += 1;
3560 if next_offset >= end_offset {
3561 return Ok(());
3562 }
3563
3564 while _next_ordinal_to_read < 5 {
3566 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3567 _next_ordinal_to_read += 1;
3568 next_offset += envelope_size;
3569 }
3570
3571 let next_out_of_line = decoder.next_out_of_line();
3572 let handles_before = decoder.remaining_handles();
3573 if let Some((inlined, num_bytes, num_handles)) =
3574 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3575 {
3576 let member_inline_size =
3577 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3578 if inlined != (member_inline_size <= 4) {
3579 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3580 }
3581 let inner_offset;
3582 let mut inner_depth = depth.clone();
3583 if inlined {
3584 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3585 inner_offset = next_offset;
3586 } else {
3587 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3588 inner_depth.increment()?;
3589 }
3590 let val_ref = self
3591 .batch_retrieval_timeout_seconds
3592 .get_or_insert_with(|| fidl::new_empty!(i64, D));
3593 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3594 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3595 {
3596 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3597 }
3598 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3599 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3600 }
3601 }
3602
3603 next_offset += envelope_size;
3604 _next_ordinal_to_read += 1;
3605 if next_offset >= end_offset {
3606 return Ok(());
3607 }
3608
3609 while _next_ordinal_to_read < 6 {
3611 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3612 _next_ordinal_to_read += 1;
3613 next_offset += envelope_size;
3614 }
3615
3616 let next_out_of_line = decoder.next_out_of_line();
3617 let handles_before = decoder.remaining_handles();
3618 if let Some((inlined, num_bytes, num_handles)) =
3619 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3620 {
3621 let member_inline_size =
3622 <PerformanceConfiguration as fidl::encoding::TypeMarker>::inline_size(
3623 decoder.context,
3624 );
3625 if inlined != (member_inline_size <= 4) {
3626 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3627 }
3628 let inner_offset;
3629 let mut inner_depth = depth.clone();
3630 if inlined {
3631 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3632 inner_offset = next_offset;
3633 } else {
3634 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3635 inner_depth.increment()?;
3636 }
3637 let val_ref = self
3638 .performance_configuration
3639 .get_or_insert_with(|| fidl::new_empty!(PerformanceConfiguration, D));
3640 fidl::decode!(
3641 PerformanceConfiguration,
3642 D,
3643 val_ref,
3644 decoder,
3645 inner_offset,
3646 inner_depth
3647 )?;
3648 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3649 {
3650 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3651 }
3652 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3653 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3654 }
3655 }
3656
3657 next_offset += envelope_size;
3658
3659 while next_offset < end_offset {
3661 _next_ordinal_to_read += 1;
3662 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3663 next_offset += envelope_size;
3664 }
3665
3666 Ok(())
3667 }
3668 }
3669
3670 impl fidl::encoding::ValueTypeMarker for ClientSelectorConfiguration {
3671 type Borrowed<'a> = &'a Self;
3672 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3673 value
3674 }
3675 }
3676
3677 unsafe impl fidl::encoding::TypeMarker for ClientSelectorConfiguration {
3678 type Owned = Self;
3679
3680 #[inline(always)]
3681 fn inline_align(_context: fidl::encoding::Context) -> usize {
3682 8
3683 }
3684
3685 #[inline(always)]
3686 fn inline_size(_context: fidl::encoding::Context) -> usize {
3687 16
3688 }
3689 }
3690
3691 unsafe impl<D: fidl::encoding::ResourceDialect>
3692 fidl::encoding::Encode<ClientSelectorConfiguration, D> for &ClientSelectorConfiguration
3693 {
3694 #[inline]
3695 unsafe fn encode(
3696 self,
3697 encoder: &mut fidl::encoding::Encoder<'_, D>,
3698 offset: usize,
3699 _depth: fidl::encoding::Depth,
3700 ) -> fidl::Result<()> {
3701 encoder.debug_check_bounds::<ClientSelectorConfiguration>(offset);
3702 encoder.write_num::<u64>(self.ordinal(), offset);
3703 match self {
3704 ClientSelectorConfiguration::Selectors(ref val) => {
3705 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<SelectorArgument>, D>(
3706 <fidl::encoding::UnboundedVector<SelectorArgument> as fidl::encoding::ValueTypeMarker>::borrow(val),
3707 encoder, offset + 8, _depth
3708 )
3709 }
3710 ClientSelectorConfiguration::SelectAll(ref val) => {
3711 fidl::encoding::encode_in_envelope::<bool, D>(
3712 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3713 encoder, offset + 8, _depth
3714 )
3715 }
3716 ClientSelectorConfiguration::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
3717 }
3718 }
3719 }
3720
3721 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3722 for ClientSelectorConfiguration
3723 {
3724 #[inline(always)]
3725 fn new_empty() -> Self {
3726 Self::__SourceBreaking { unknown_ordinal: 0 }
3727 }
3728
3729 #[inline]
3730 unsafe fn decode(
3731 &mut self,
3732 decoder: &mut fidl::encoding::Decoder<'_, D>,
3733 offset: usize,
3734 mut depth: fidl::encoding::Depth,
3735 ) -> fidl::Result<()> {
3736 decoder.debug_check_bounds::<Self>(offset);
3737 #[allow(unused_variables)]
3738 let next_out_of_line = decoder.next_out_of_line();
3739 let handles_before = decoder.remaining_handles();
3740 let (ordinal, inlined, num_bytes, num_handles) =
3741 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
3742
3743 let member_inline_size = match ordinal {
3744 1 => <fidl::encoding::UnboundedVector<SelectorArgument> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3745 2 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3746 0 => return Err(fidl::Error::UnknownUnionTag),
3747 _ => num_bytes as usize,
3748 };
3749
3750 if inlined != (member_inline_size <= 4) {
3751 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3752 }
3753 let _inner_offset;
3754 if inlined {
3755 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
3756 _inner_offset = offset + 8;
3757 } else {
3758 depth.increment()?;
3759 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3760 }
3761 match ordinal {
3762 1 => {
3763 #[allow(irrefutable_let_patterns)]
3764 if let ClientSelectorConfiguration::Selectors(_) = self {
3765 } else {
3767 *self = ClientSelectorConfiguration::Selectors(fidl::new_empty!(
3769 fidl::encoding::UnboundedVector<SelectorArgument>,
3770 D
3771 ));
3772 }
3773 #[allow(irrefutable_let_patterns)]
3774 if let ClientSelectorConfiguration::Selectors(ref mut val) = self {
3775 fidl::decode!(
3776 fidl::encoding::UnboundedVector<SelectorArgument>,
3777 D,
3778 val,
3779 decoder,
3780 _inner_offset,
3781 depth
3782 )?;
3783 } else {
3784 unreachable!()
3785 }
3786 }
3787 2 => {
3788 #[allow(irrefutable_let_patterns)]
3789 if let ClientSelectorConfiguration::SelectAll(_) = self {
3790 } else {
3792 *self = ClientSelectorConfiguration::SelectAll(fidl::new_empty!(bool, D));
3794 }
3795 #[allow(irrefutable_let_patterns)]
3796 if let ClientSelectorConfiguration::SelectAll(ref mut val) = self {
3797 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
3798 } else {
3799 unreachable!()
3800 }
3801 }
3802 #[allow(deprecated)]
3803 ordinal => {
3804 for _ in 0..num_handles {
3805 decoder.drop_next_handle()?;
3806 }
3807 *self =
3808 ClientSelectorConfiguration::__SourceBreaking { unknown_ordinal: ordinal };
3809 }
3810 }
3811 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
3812 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3813 }
3814 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3815 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3816 }
3817 Ok(())
3818 }
3819 }
3820
3821 impl fidl::encoding::ValueTypeMarker for SelectorArgument {
3822 type Borrowed<'a> = &'a Self;
3823 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3824 value
3825 }
3826 }
3827
3828 unsafe impl fidl::encoding::TypeMarker for SelectorArgument {
3829 type Owned = Self;
3830
3831 #[inline(always)]
3832 fn inline_align(_context: fidl::encoding::Context) -> usize {
3833 8
3834 }
3835
3836 #[inline(always)]
3837 fn inline_size(_context: fidl::encoding::Context) -> usize {
3838 16
3839 }
3840 }
3841
3842 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SelectorArgument, D>
3843 for &SelectorArgument
3844 {
3845 #[inline]
3846 unsafe fn encode(
3847 self,
3848 encoder: &mut fidl::encoding::Encoder<'_, D>,
3849 offset: usize,
3850 _depth: fidl::encoding::Depth,
3851 ) -> fidl::Result<()> {
3852 encoder.debug_check_bounds::<SelectorArgument>(offset);
3853 encoder.write_num::<u64>(self.ordinal(), offset);
3854 match self {
3855 SelectorArgument::StructuredSelector(ref val) => {
3856 fidl::encoding::encode_in_envelope::<Selector, D>(
3857 <Selector as fidl::encoding::ValueTypeMarker>::borrow(val),
3858 encoder, offset + 8, _depth
3859 )
3860 }
3861 SelectorArgument::RawSelector(ref val) => {
3862 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<1024>, D>(
3863 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
3864 encoder, offset + 8, _depth
3865 )
3866 }
3867 SelectorArgument::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
3868 }
3869 }
3870 }
3871
3872 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SelectorArgument {
3873 #[inline(always)]
3874 fn new_empty() -> Self {
3875 Self::__SourceBreaking { unknown_ordinal: 0 }
3876 }
3877
3878 #[inline]
3879 unsafe fn decode(
3880 &mut self,
3881 decoder: &mut fidl::encoding::Decoder<'_, D>,
3882 offset: usize,
3883 mut depth: fidl::encoding::Depth,
3884 ) -> fidl::Result<()> {
3885 decoder.debug_check_bounds::<Self>(offset);
3886 #[allow(unused_variables)]
3887 let next_out_of_line = decoder.next_out_of_line();
3888 let handles_before = decoder.remaining_handles();
3889 let (ordinal, inlined, num_bytes, num_handles) =
3890 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
3891
3892 let member_inline_size = match ordinal {
3893 1 => <Selector as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3894 2 => {
3895 <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(
3896 decoder.context,
3897 )
3898 }
3899 0 => return Err(fidl::Error::UnknownUnionTag),
3900 _ => num_bytes as usize,
3901 };
3902
3903 if inlined != (member_inline_size <= 4) {
3904 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3905 }
3906 let _inner_offset;
3907 if inlined {
3908 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
3909 _inner_offset = offset + 8;
3910 } else {
3911 depth.increment()?;
3912 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3913 }
3914 match ordinal {
3915 1 => {
3916 #[allow(irrefutable_let_patterns)]
3917 if let SelectorArgument::StructuredSelector(_) = self {
3918 } else {
3920 *self = SelectorArgument::StructuredSelector(fidl::new_empty!(Selector, D));
3922 }
3923 #[allow(irrefutable_let_patterns)]
3924 if let SelectorArgument::StructuredSelector(ref mut val) = self {
3925 fidl::decode!(Selector, D, val, decoder, _inner_offset, depth)?;
3926 } else {
3927 unreachable!()
3928 }
3929 }
3930 2 => {
3931 #[allow(irrefutable_let_patterns)]
3932 if let SelectorArgument::RawSelector(_) = self {
3933 } else {
3935 *self = SelectorArgument::RawSelector(fidl::new_empty!(
3937 fidl::encoding::BoundedString<1024>,
3938 D
3939 ));
3940 }
3941 #[allow(irrefutable_let_patterns)]
3942 if let SelectorArgument::RawSelector(ref mut val) = self {
3943 fidl::decode!(
3944 fidl::encoding::BoundedString<1024>,
3945 D,
3946 val,
3947 decoder,
3948 _inner_offset,
3949 depth
3950 )?;
3951 } else {
3952 unreachable!()
3953 }
3954 }
3955 #[allow(deprecated)]
3956 ordinal => {
3957 for _ in 0..num_handles {
3958 decoder.drop_next_handle()?;
3959 }
3960 *self = SelectorArgument::__SourceBreaking { unknown_ordinal: ordinal };
3961 }
3962 }
3963 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
3964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3965 }
3966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3968 }
3969 Ok(())
3970 }
3971 }
3972
3973 impl fidl::encoding::ValueTypeMarker for StringSelector {
3974 type Borrowed<'a> = &'a Self;
3975 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3976 value
3977 }
3978 }
3979
3980 unsafe impl fidl::encoding::TypeMarker for StringSelector {
3981 type Owned = Self;
3982
3983 #[inline(always)]
3984 fn inline_align(_context: fidl::encoding::Context) -> usize {
3985 8
3986 }
3987
3988 #[inline(always)]
3989 fn inline_size(_context: fidl::encoding::Context) -> usize {
3990 16
3991 }
3992 }
3993
3994 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StringSelector, D>
3995 for &StringSelector
3996 {
3997 #[inline]
3998 unsafe fn encode(
3999 self,
4000 encoder: &mut fidl::encoding::Encoder<'_, D>,
4001 offset: usize,
4002 _depth: fidl::encoding::Depth,
4003 ) -> fidl::Result<()> {
4004 encoder.debug_check_bounds::<StringSelector>(offset);
4005 encoder.write_num::<u64>(self.ordinal(), offset);
4006 match self {
4007 StringSelector::StringPattern(ref val) => {
4008 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<1024>, D>(
4009 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
4010 encoder, offset + 8, _depth
4011 )
4012 }
4013 StringSelector::ExactMatch(ref val) => {
4014 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<1024>, D>(
4015 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
4016 encoder, offset + 8, _depth
4017 )
4018 }
4019 StringSelector::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4020 }
4021 }
4022 }
4023
4024 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StringSelector {
4025 #[inline(always)]
4026 fn new_empty() -> Self {
4027 Self::__SourceBreaking { unknown_ordinal: 0 }
4028 }
4029
4030 #[inline]
4031 unsafe fn decode(
4032 &mut self,
4033 decoder: &mut fidl::encoding::Decoder<'_, D>,
4034 offset: usize,
4035 mut depth: fidl::encoding::Depth,
4036 ) -> fidl::Result<()> {
4037 decoder.debug_check_bounds::<Self>(offset);
4038 #[allow(unused_variables)]
4039 let next_out_of_line = decoder.next_out_of_line();
4040 let handles_before = decoder.remaining_handles();
4041 let (ordinal, inlined, num_bytes, num_handles) =
4042 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4043
4044 let member_inline_size = match ordinal {
4045 1 => {
4046 <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(
4047 decoder.context,
4048 )
4049 }
4050 2 => {
4051 <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(
4052 decoder.context,
4053 )
4054 }
4055 0 => return Err(fidl::Error::UnknownUnionTag),
4056 _ => num_bytes as usize,
4057 };
4058
4059 if inlined != (member_inline_size <= 4) {
4060 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4061 }
4062 let _inner_offset;
4063 if inlined {
4064 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4065 _inner_offset = offset + 8;
4066 } else {
4067 depth.increment()?;
4068 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4069 }
4070 match ordinal {
4071 1 => {
4072 #[allow(irrefutable_let_patterns)]
4073 if let StringSelector::StringPattern(_) = self {
4074 } else {
4076 *self = StringSelector::StringPattern(fidl::new_empty!(
4078 fidl::encoding::BoundedString<1024>,
4079 D
4080 ));
4081 }
4082 #[allow(irrefutable_let_patterns)]
4083 if let StringSelector::StringPattern(ref mut val) = self {
4084 fidl::decode!(
4085 fidl::encoding::BoundedString<1024>,
4086 D,
4087 val,
4088 decoder,
4089 _inner_offset,
4090 depth
4091 )?;
4092 } else {
4093 unreachable!()
4094 }
4095 }
4096 2 => {
4097 #[allow(irrefutable_let_patterns)]
4098 if let StringSelector::ExactMatch(_) = self {
4099 } else {
4101 *self = StringSelector::ExactMatch(fidl::new_empty!(
4103 fidl::encoding::BoundedString<1024>,
4104 D
4105 ));
4106 }
4107 #[allow(irrefutable_let_patterns)]
4108 if let StringSelector::ExactMatch(ref mut val) = self {
4109 fidl::decode!(
4110 fidl::encoding::BoundedString<1024>,
4111 D,
4112 val,
4113 decoder,
4114 _inner_offset,
4115 depth
4116 )?;
4117 } else {
4118 unreachable!()
4119 }
4120 }
4121 #[allow(deprecated)]
4122 ordinal => {
4123 for _ in 0..num_handles {
4124 decoder.drop_next_handle()?;
4125 }
4126 *self = StringSelector::__SourceBreaking { unknown_ordinal: ordinal };
4127 }
4128 }
4129 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4130 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4131 }
4132 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4133 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4134 }
4135 Ok(())
4136 }
4137 }
4138
4139 impl fidl::encoding::ValueTypeMarker for TreeNames {
4140 type Borrowed<'a> = &'a Self;
4141 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4142 value
4143 }
4144 }
4145
4146 unsafe impl fidl::encoding::TypeMarker for TreeNames {
4147 type Owned = Self;
4148
4149 #[inline(always)]
4150 fn inline_align(_context: fidl::encoding::Context) -> usize {
4151 8
4152 }
4153
4154 #[inline(always)]
4155 fn inline_size(_context: fidl::encoding::Context) -> usize {
4156 16
4157 }
4158 }
4159
4160 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TreeNames, D>
4161 for &TreeNames
4162 {
4163 #[inline]
4164 unsafe fn encode(
4165 self,
4166 encoder: &mut fidl::encoding::Encoder<'_, D>,
4167 offset: usize,
4168 _depth: fidl::encoding::Depth,
4169 ) -> fidl::Result<()> {
4170 encoder.debug_check_bounds::<TreeNames>(offset);
4171 encoder.write_num::<u64>(self.ordinal(), offset);
4172 match self {
4173 TreeNames::Some(ref val) => {
4174 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>>, D>(
4175 <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(val),
4176 encoder, offset + 8, _depth
4177 )
4178 }
4179 TreeNames::All(ref val) => {
4180 fidl::encoding::encode_in_envelope::<All, D>(
4181 <All as fidl::encoding::ValueTypeMarker>::borrow(val),
4182 encoder, offset + 8, _depth
4183 )
4184 }
4185 TreeNames::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4186 }
4187 }
4188 }
4189
4190 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TreeNames {
4191 #[inline(always)]
4192 fn new_empty() -> Self {
4193 Self::__SourceBreaking { unknown_ordinal: 0 }
4194 }
4195
4196 #[inline]
4197 unsafe fn decode(
4198 &mut self,
4199 decoder: &mut fidl::encoding::Decoder<'_, D>,
4200 offset: usize,
4201 mut depth: fidl::encoding::Depth,
4202 ) -> fidl::Result<()> {
4203 decoder.debug_check_bounds::<Self>(offset);
4204 #[allow(unused_variables)]
4205 let next_out_of_line = decoder.next_out_of_line();
4206 let handles_before = decoder.remaining_handles();
4207 let (ordinal, inlined, num_bytes, num_handles) =
4208 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4209
4210 let member_inline_size = match ordinal {
4211 1 => <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4212 2 => <All as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4213 0 => return Err(fidl::Error::UnknownUnionTag),
4214 _ => num_bytes as usize,
4215 };
4216
4217 if inlined != (member_inline_size <= 4) {
4218 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4219 }
4220 let _inner_offset;
4221 if inlined {
4222 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4223 _inner_offset = offset + 8;
4224 } else {
4225 depth.increment()?;
4226 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4227 }
4228 match ordinal {
4229 1 => {
4230 #[allow(irrefutable_let_patterns)]
4231 if let TreeNames::Some(_) = self {
4232 } else {
4234 *self = TreeNames::Some(fidl::new_empty!(
4236 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>>,
4237 D
4238 ));
4239 }
4240 #[allow(irrefutable_let_patterns)]
4241 if let TreeNames::Some(ref mut val) = self {
4242 fidl::decode!(
4243 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>>,
4244 D,
4245 val,
4246 decoder,
4247 _inner_offset,
4248 depth
4249 )?;
4250 } else {
4251 unreachable!()
4252 }
4253 }
4254 2 => {
4255 #[allow(irrefutable_let_patterns)]
4256 if let TreeNames::All(_) = self {
4257 } else {
4259 *self = TreeNames::All(fidl::new_empty!(All, D));
4261 }
4262 #[allow(irrefutable_let_patterns)]
4263 if let TreeNames::All(ref mut val) = self {
4264 fidl::decode!(All, D, val, decoder, _inner_offset, depth)?;
4265 } else {
4266 unreachable!()
4267 }
4268 }
4269 #[allow(deprecated)]
4270 ordinal => {
4271 for _ in 0..num_handles {
4272 decoder.drop_next_handle()?;
4273 }
4274 *self = TreeNames::__SourceBreaking { unknown_ordinal: ordinal };
4275 }
4276 }
4277 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4278 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4279 }
4280 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4281 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4282 }
4283 Ok(())
4284 }
4285 }
4286
4287 impl fidl::encoding::ValueTypeMarker for TreeSelector {
4288 type Borrowed<'a> = &'a Self;
4289 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4290 value
4291 }
4292 }
4293
4294 unsafe impl fidl::encoding::TypeMarker for TreeSelector {
4295 type Owned = Self;
4296
4297 #[inline(always)]
4298 fn inline_align(_context: fidl::encoding::Context) -> usize {
4299 8
4300 }
4301
4302 #[inline(always)]
4303 fn inline_size(_context: fidl::encoding::Context) -> usize {
4304 16
4305 }
4306 }
4307
4308 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TreeSelector, D>
4309 for &TreeSelector
4310 {
4311 #[inline]
4312 unsafe fn encode(
4313 self,
4314 encoder: &mut fidl::encoding::Encoder<'_, D>,
4315 offset: usize,
4316 _depth: fidl::encoding::Depth,
4317 ) -> fidl::Result<()> {
4318 encoder.debug_check_bounds::<TreeSelector>(offset);
4319 encoder.write_num::<u64>(self.ordinal(), offset);
4320 match self {
4321 TreeSelector::SubtreeSelector(ref val) => {
4322 fidl::encoding::encode_in_envelope::<SubtreeSelector, D>(
4323 <SubtreeSelector as fidl::encoding::ValueTypeMarker>::borrow(val),
4324 encoder,
4325 offset + 8,
4326 _depth,
4327 )
4328 }
4329 TreeSelector::PropertySelector(ref val) => {
4330 fidl::encoding::encode_in_envelope::<PropertySelector, D>(
4331 <PropertySelector as fidl::encoding::ValueTypeMarker>::borrow(val),
4332 encoder,
4333 offset + 8,
4334 _depth,
4335 )
4336 }
4337 TreeSelector::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4338 }
4339 }
4340 }
4341
4342 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TreeSelector {
4343 #[inline(always)]
4344 fn new_empty() -> Self {
4345 Self::__SourceBreaking { unknown_ordinal: 0 }
4346 }
4347
4348 #[inline]
4349 unsafe fn decode(
4350 &mut self,
4351 decoder: &mut fidl::encoding::Decoder<'_, D>,
4352 offset: usize,
4353 mut depth: fidl::encoding::Depth,
4354 ) -> fidl::Result<()> {
4355 decoder.debug_check_bounds::<Self>(offset);
4356 #[allow(unused_variables)]
4357 let next_out_of_line = decoder.next_out_of_line();
4358 let handles_before = decoder.remaining_handles();
4359 let (ordinal, inlined, num_bytes, num_handles) =
4360 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4361
4362 let member_inline_size = match ordinal {
4363 1 => <SubtreeSelector as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4364 2 => <PropertySelector as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4365 0 => return Err(fidl::Error::UnknownUnionTag),
4366 _ => num_bytes as usize,
4367 };
4368
4369 if inlined != (member_inline_size <= 4) {
4370 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4371 }
4372 let _inner_offset;
4373 if inlined {
4374 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4375 _inner_offset = offset + 8;
4376 } else {
4377 depth.increment()?;
4378 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4379 }
4380 match ordinal {
4381 1 => {
4382 #[allow(irrefutable_let_patterns)]
4383 if let TreeSelector::SubtreeSelector(_) = self {
4384 } else {
4386 *self = TreeSelector::SubtreeSelector(fidl::new_empty!(SubtreeSelector, D));
4388 }
4389 #[allow(irrefutable_let_patterns)]
4390 if let TreeSelector::SubtreeSelector(ref mut val) = self {
4391 fidl::decode!(SubtreeSelector, D, val, decoder, _inner_offset, depth)?;
4392 } else {
4393 unreachable!()
4394 }
4395 }
4396 2 => {
4397 #[allow(irrefutable_let_patterns)]
4398 if let TreeSelector::PropertySelector(_) = self {
4399 } else {
4401 *self =
4403 TreeSelector::PropertySelector(fidl::new_empty!(PropertySelector, D));
4404 }
4405 #[allow(irrefutable_let_patterns)]
4406 if let TreeSelector::PropertySelector(ref mut val) = self {
4407 fidl::decode!(PropertySelector, D, val, decoder, _inner_offset, depth)?;
4408 } else {
4409 unreachable!()
4410 }
4411 }
4412 #[allow(deprecated)]
4413 ordinal => {
4414 for _ in 0..num_handles {
4415 decoder.drop_next_handle()?;
4416 }
4417 *self = TreeSelector::__SourceBreaking { unknown_ordinal: ordinal };
4418 }
4419 }
4420 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4421 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4422 }
4423 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4424 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4425 }
4426 Ok(())
4427 }
4428 }
4429}