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 type NodeName = String;
12
13pub type NodeOffersVector = Vec<Offer>;
14
15pub type NodeProperties = Vec<NodeProperty2>;
16
17pub type NodePropertyDictionary = Vec<NodePropertyEntry>;
18
19pub type NodePropertyDictionary2 = Vec<NodePropertyEntry2>;
20
21pub type NodePropertyKeyString = String;
22
23pub type NodePropertyKeyUint = u32;
24
25pub type NodePropertyValueBool = bool;
26
27pub type NodePropertyValueEnum = String;
28
29pub type NodePropertyValueString = String;
30
31pub type NodePropertyValueUint = u32;
32
33pub type NodePropertyVector = Vec<NodeProperty>;
34
35pub const MAX_DEVICE_ADDRESS_ARRAY_LEN: u32 = 10;
36
37pub const MAX_DEVICE_ADDRESS_STR_LEN: u32 = 32;
38
39pub const MAX_MODULE_NAME_LENGTH: u8 = 128;
40
41pub const MAX_NAMESPACE_COUNT: u32 =
42 fidl_fuchsia_component_runner__common::MAX_NAMESPACE_COUNT as u32;
43
44pub const MAX_NODE_NAME_LENGTH: u8 = 128;
45
46pub const MAX_OFFER_COUNT: u32 = fidl_fuchsia_component__common::MAX_DYNAMIC_OFFER_COUNT as u32;
47
48pub const MAX_PROPERTY_COUNT: u8 = 64;
49
50pub const MAX_RESOURCE_NAME_LENGTH: u8 = 128;
51
52pub const MAX_SYMBOL_COUNT: u8 = 64;
53
54pub const MAX_SYMBOL_NAME_LENGTH: u8 = 128;
55
56#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57pub enum BusType {
58 Platform,
59 Acpi,
60 DeviceTree,
61 Pci,
62 Usb,
63 Gpio,
64 I2C,
65 Spi,
66 Sdio,
67 Uart,
68 Spmi,
69 #[doc(hidden)]
70 __SourceBreaking {
71 unknown_ordinal: u32,
72 },
73}
74
75#[macro_export]
77macro_rules! BusTypeUnknown {
78 () => {
79 _
80 };
81}
82
83impl BusType {
84 #[inline]
85 pub fn from_primitive(prim: u32) -> Option<Self> {
86 match prim {
87 1 => Some(Self::Platform),
88 2 => Some(Self::Acpi),
89 3 => Some(Self::DeviceTree),
90 4 => Some(Self::Pci),
91 5 => Some(Self::Usb),
92 6 => Some(Self::Gpio),
93 7 => Some(Self::I2C),
94 8 => Some(Self::Spi),
95 9 => Some(Self::Sdio),
96 10 => Some(Self::Uart),
97 11 => Some(Self::Spmi),
98 _ => None,
99 }
100 }
101
102 #[inline]
103 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
104 match prim {
105 1 => Self::Platform,
106 2 => Self::Acpi,
107 3 => Self::DeviceTree,
108 4 => Self::Pci,
109 5 => Self::Usb,
110 6 => Self::Gpio,
111 7 => Self::I2C,
112 8 => Self::Spi,
113 9 => Self::Sdio,
114 10 => Self::Uart,
115 11 => Self::Spmi,
116 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
117 }
118 }
119
120 #[inline]
121 pub fn unknown() -> Self {
122 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
123 }
124
125 #[inline]
126 pub const fn into_primitive(self) -> u32 {
127 match self {
128 Self::Platform => 1,
129 Self::Acpi => 2,
130 Self::DeviceTree => 3,
131 Self::Pci => 4,
132 Self::Usb => 5,
133 Self::Gpio => 6,
134 Self::I2C => 7,
135 Self::Spi => 8,
136 Self::Sdio => 9,
137 Self::Uart => 10,
138 Self::Spmi => 11,
139 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
140 }
141 }
142
143 #[inline]
144 pub fn is_unknown(&self) -> bool {
145 match self {
146 Self::__SourceBreaking { unknown_ordinal: _ } => true,
147 _ => false,
148 }
149 }
150}
151
152#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
154pub enum CompositeNodeSpecError {
155 MissingArgs,
157 EmptyNodes,
159 AlreadyExists,
162 DriverIndexFailure,
164 DuplicateParents,
166 #[doc(hidden)]
167 __SourceBreaking { unknown_ordinal: u32 },
168}
169
170#[macro_export]
172macro_rules! CompositeNodeSpecErrorUnknown {
173 () => {
174 _
175 };
176}
177
178impl CompositeNodeSpecError {
179 #[inline]
180 pub fn from_primitive(prim: u32) -> Option<Self> {
181 match prim {
182 1 => Some(Self::MissingArgs),
183 2 => Some(Self::EmptyNodes),
184 3 => Some(Self::AlreadyExists),
185 4 => Some(Self::DriverIndexFailure),
186 5 => Some(Self::DuplicateParents),
187 _ => None,
188 }
189 }
190
191 #[inline]
192 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
193 match prim {
194 1 => Self::MissingArgs,
195 2 => Self::EmptyNodes,
196 3 => Self::AlreadyExists,
197 4 => Self::DriverIndexFailure,
198 5 => Self::DuplicateParents,
199 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
200 }
201 }
202
203 #[inline]
204 pub fn unknown() -> Self {
205 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
206 }
207
208 #[inline]
209 pub const fn into_primitive(self) -> u32 {
210 match self {
211 Self::MissingArgs => 1,
212 Self::EmptyNodes => 2,
213 Self::AlreadyExists => 3,
214 Self::DriverIndexFailure => 4,
215 Self::DuplicateParents => 5,
216 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
217 }
218 }
219
220 #[inline]
221 pub fn is_unknown(&self) -> bool {
222 match self {
223 Self::__SourceBreaking { unknown_ordinal: _ } => true,
224 _ => false,
225 }
226 }
227}
228
229#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
231#[repr(u32)]
232pub enum Condition {
233 Unknown = 0,
234 Accept = 1,
235 Reject = 2,
236}
237
238impl Condition {
239 #[inline]
240 pub fn from_primitive(prim: u32) -> Option<Self> {
241 match prim {
242 0 => Some(Self::Unknown),
243 1 => Some(Self::Accept),
244 2 => Some(Self::Reject),
245 _ => None,
246 }
247 }
248
249 #[inline]
250 pub const fn into_primitive(self) -> u32 {
251 self as u32
252 }
253}
254
255#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
256pub enum DeviceAddressStability {
257 UnstableBetweenDriverRestart,
259 UnstableBetweenBoot,
261 UnstableBetweenSoftwareUpdate,
263 Stable,
265 #[doc(hidden)]
266 __SourceBreaking { unknown_ordinal: u32 },
267}
268
269#[macro_export]
271macro_rules! DeviceAddressStabilityUnknown {
272 () => {
273 _
274 };
275}
276
277impl DeviceAddressStability {
278 #[inline]
279 pub fn from_primitive(prim: u32) -> Option<Self> {
280 match prim {
281 0 => Some(Self::UnstableBetweenDriverRestart),
282 1 => Some(Self::UnstableBetweenBoot),
283 2 => Some(Self::UnstableBetweenSoftwareUpdate),
284 3 => Some(Self::Stable),
285 _ => None,
286 }
287 }
288
289 #[inline]
290 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
291 match prim {
292 0 => Self::UnstableBetweenDriverRestart,
293 1 => Self::UnstableBetweenBoot,
294 2 => Self::UnstableBetweenSoftwareUpdate,
295 3 => Self::Stable,
296 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
297 }
298 }
299
300 #[inline]
301 pub fn unknown() -> Self {
302 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
303 }
304
305 #[inline]
306 pub const fn into_primitive(self) -> u32 {
307 match self {
308 Self::UnstableBetweenDriverRestart => 0,
309 Self::UnstableBetweenBoot => 1,
310 Self::UnstableBetweenSoftwareUpdate => 2,
311 Self::Stable => 3,
312 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
313 }
314 }
315
316 #[inline]
317 pub fn is_unknown(&self) -> bool {
318 match self {
319 Self::__SourceBreaking { unknown_ordinal: _ } => true,
320 _ => false,
321 }
322 }
323}
324
325#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
329pub enum DriverPackageType {
330 Boot,
332 Base,
334 Cached,
337 Universe,
339 #[doc(hidden)]
340 __SourceBreaking { unknown_ordinal: u8 },
341}
342
343#[macro_export]
345macro_rules! DriverPackageTypeUnknown {
346 () => {
347 _
348 };
349}
350
351impl DriverPackageType {
352 #[inline]
353 pub fn from_primitive(prim: u8) -> Option<Self> {
354 match prim {
355 0 => Some(Self::Boot),
356 1 => Some(Self::Base),
357 2 => Some(Self::Cached),
358 3 => Some(Self::Universe),
359 _ => None,
360 }
361 }
362
363 #[inline]
364 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
365 match prim {
366 0 => Self::Boot,
367 1 => Self::Base,
368 2 => Self::Cached,
369 3 => Self::Universe,
370 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
371 }
372 }
373
374 #[inline]
375 pub fn unknown() -> Self {
376 Self::__SourceBreaking { unknown_ordinal: 0xff }
377 }
378
379 #[inline]
380 pub const fn into_primitive(self) -> u8 {
381 match self {
382 Self::Boot => 0,
383 Self::Base => 1,
384 Self::Cached => 2,
385 Self::Universe => 3,
386 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
387 }
388 }
389
390 #[inline]
391 pub fn is_unknown(&self) -> bool {
392 match self {
393 Self::__SourceBreaking { unknown_ordinal: _ } => true,
394 _ => false,
395 }
396 }
397}
398
399#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
401pub enum NodeError {
402 Internal,
403 NodeRemoved,
404 NameMissing,
405 NameInvalid,
408 NameAlreadyExists,
410 OfferSourceNameMissing,
412 OfferRefExists,
414 SymbolNameMissing,
416 SymbolAddressMissing,
418 SymbolAlreadyExists,
420 UnbindChildrenInProgress,
422 UnsupportedArgs,
424 #[doc(hidden)]
425 __SourceBreaking {
426 unknown_ordinal: u32,
427 },
428}
429
430#[macro_export]
432macro_rules! NodeErrorUnknown {
433 () => {
434 _
435 };
436}
437
438impl NodeError {
439 #[inline]
440 pub fn from_primitive(prim: u32) -> Option<Self> {
441 match prim {
442 1 => Some(Self::Internal),
443 2 => Some(Self::NodeRemoved),
444 3 => Some(Self::NameMissing),
445 4 => Some(Self::NameInvalid),
446 5 => Some(Self::NameAlreadyExists),
447 6 => Some(Self::OfferSourceNameMissing),
448 7 => Some(Self::OfferRefExists),
449 8 => Some(Self::SymbolNameMissing),
450 9 => Some(Self::SymbolAddressMissing),
451 10 => Some(Self::SymbolAlreadyExists),
452 11 => Some(Self::UnbindChildrenInProgress),
453 12 => Some(Self::UnsupportedArgs),
454 _ => None,
455 }
456 }
457
458 #[inline]
459 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
460 match prim {
461 1 => Self::Internal,
462 2 => Self::NodeRemoved,
463 3 => Self::NameMissing,
464 4 => Self::NameInvalid,
465 5 => Self::NameAlreadyExists,
466 6 => Self::OfferSourceNameMissing,
467 7 => Self::OfferRefExists,
468 8 => Self::SymbolNameMissing,
469 9 => Self::SymbolAddressMissing,
470 10 => Self::SymbolAlreadyExists,
471 11 => Self::UnbindChildrenInProgress,
472 12 => Self::UnsupportedArgs,
473 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
474 }
475 }
476
477 #[inline]
478 pub fn unknown() -> Self {
479 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
480 }
481
482 #[inline]
483 pub const fn into_primitive(self) -> u32 {
484 match self {
485 Self::Internal => 1,
486 Self::NodeRemoved => 2,
487 Self::NameMissing => 3,
488 Self::NameInvalid => 4,
489 Self::NameAlreadyExists => 5,
490 Self::OfferSourceNameMissing => 6,
491 Self::OfferRefExists => 7,
492 Self::SymbolNameMissing => 8,
493 Self::SymbolAddressMissing => 9,
494 Self::SymbolAlreadyExists => 10,
495 Self::UnbindChildrenInProgress => 11,
496 Self::UnsupportedArgs => 12,
497 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
498 }
499 }
500
501 #[inline]
502 pub fn is_unknown(&self) -> bool {
503 match self {
504 Self::__SourceBreaking { unknown_ordinal: _ } => true,
505 _ => false,
506 }
507 }
508}
509
510#[derive(Clone, Debug, PartialEq)]
512pub struct BindRule {
513 pub key: NodePropertyKey,
515 pub condition: Condition,
519 pub values: Vec<NodePropertyValue>,
522}
523
524impl fidl::Persistable for BindRule {}
525
526#[derive(Clone, Debug, PartialEq)]
528pub struct BindRule2 {
529 pub key: String,
531 pub condition: Condition,
535 pub values: Vec<NodePropertyValue>,
538}
539
540impl fidl::Persistable for BindRule2 {}
541
542#[derive(Clone, Debug, PartialEq)]
545pub struct NodeProperty {
546 pub key: NodePropertyKey,
549 pub value: NodePropertyValue,
551}
552
553impl fidl::Persistable for NodeProperty {}
554
555#[derive(Clone, Debug, PartialEq)]
556pub struct NodeProperty2 {
557 pub key: String,
559 pub value: NodePropertyValue,
561}
562
563impl fidl::Persistable for NodeProperty2 {}
564
565#[derive(Clone, Debug, PartialEq)]
567pub struct NodePropertyEntry {
568 pub name: String,
570 pub properties: Vec<NodeProperty>,
574}
575
576impl fidl::Persistable for NodePropertyEntry {}
577
578#[derive(Clone, Debug, PartialEq)]
580pub struct NodePropertyEntry2 {
581 pub name: String,
583 pub properties: Vec<NodeProperty2>,
587}
588
589impl fidl::Persistable for NodePropertyEntry2 {}
590
591#[derive(Clone, Debug, PartialEq)]
594pub struct ParentSpec {
595 pub bind_rules: Vec<BindRule>,
597 pub properties: Vec<NodeProperty>,
600}
601
602impl fidl::Persistable for ParentSpec {}
603
604#[derive(Clone, Debug, PartialEq)]
607pub struct ParentSpec2 {
608 pub bind_rules: Vec<BindRule2>,
610 pub properties: Vec<NodeProperty2>,
613}
614
615impl fidl::Persistable for ParentSpec2 {}
616
617#[derive(Clone, Debug, Default, PartialEq)]
618pub struct BusInfo {
619 pub bus: Option<BusType>,
621 pub address: Option<DeviceAddress>,
623 pub address_stability: Option<DeviceAddressStability>,
625 #[doc(hidden)]
626 pub __source_breaking: fidl::marker::SourceBreaking,
627}
628
629impl fidl::Persistable for BusInfo {}
630
631#[derive(Clone, Debug, Default, PartialEq)]
633pub struct CompositeDriverInfo {
634 pub composite_name: Option<String>,
636 pub driver_info: Option<DriverInfo>,
638 #[doc(hidden)]
639 pub __source_breaking: fidl::marker::SourceBreaking,
640}
641
642impl fidl::Persistable for CompositeDriverInfo {}
643
644#[derive(Clone, Debug, Default, PartialEq)]
646pub struct CompositeDriverMatch {
647 pub composite_driver: Option<CompositeDriverInfo>,
649 pub parent_names: Option<Vec<String>>,
652 pub primary_parent_index: Option<u32>,
655 #[doc(hidden)]
656 pub __source_breaking: fidl::marker::SourceBreaking,
657}
658
659impl fidl::Persistable for CompositeDriverMatch {}
660
661#[derive(Clone, Debug, Default, PartialEq)]
663pub struct CompositeInfo {
664 pub spec: Option<CompositeNodeSpec>,
666 pub matched_driver: Option<CompositeDriverMatch>,
669 #[doc(hidden)]
670 pub __source_breaking: fidl::marker::SourceBreaking,
671}
672
673impl fidl::Persistable for CompositeInfo {}
674
675#[derive(Clone, Debug, Default, PartialEq)]
677pub struct CompositeNodeSpec {
678 pub name: Option<String>,
680 pub parents: Option<Vec<ParentSpec>>,
683 pub parents2: Option<Vec<ParentSpec2>>,
686 #[doc(hidden)]
687 pub __source_breaking: fidl::marker::SourceBreaking,
688}
689
690impl fidl::Persistable for CompositeNodeSpec {}
691
692#[derive(Clone, Debug, Default, PartialEq)]
694pub struct CompositeParent {
695 pub composite: Option<CompositeInfo>,
697 pub index: Option<u32>,
699 #[doc(hidden)]
700 pub __source_breaking: fidl::marker::SourceBreaking,
701}
702
703impl fidl::Persistable for CompositeParent {}
704
705#[derive(Clone, Debug, Default, PartialEq)]
707pub struct DeviceCategory {
708 pub category: Option<String>,
709 pub subcategory: Option<String>,
710 #[doc(hidden)]
711 pub __source_breaking: fidl::marker::SourceBreaking,
712}
713
714impl fidl::Persistable for DeviceCategory {}
715
716#[derive(Clone, Debug, Default, PartialEq)]
718pub struct DriverInfo {
719 pub url: Option<String>,
721 pub name: Option<String>,
724 pub colocate: Option<bool>,
726 pub package_type: Option<DriverPackageType>,
728 pub is_fallback: Option<bool>,
732 pub device_categories: Option<Vec<DeviceCategory>>,
734 pub bind_rules_bytecode: Option<Vec<u8>>,
738 pub driver_framework_version: Option<u8>,
742 pub is_disabled: Option<bool>,
744 #[doc(hidden)]
745 pub __source_breaking: fidl::marker::SourceBreaking,
746}
747
748impl fidl::Persistable for DriverInfo {}
749
750#[derive(Clone, Debug, Default, PartialEq)]
751pub struct NodeControllerRequestBindRequest {
752 pub force_rebind: Option<bool>,
755 pub driver_url_suffix: Option<String>,
759 #[doc(hidden)]
760 pub __source_breaking: fidl::marker::SourceBreaking,
761}
762
763impl fidl::Persistable for NodeControllerRequestBindRequest {}
764
765#[derive(Clone, Debug, Default, PartialEq)]
768pub struct NodeSymbol {
769 pub name: Option<String>,
771 pub address: Option<u64>,
773 pub module_name: Option<String>,
776 #[doc(hidden)]
777 pub __source_breaking: fidl::marker::SourceBreaking,
778}
779
780impl fidl::Persistable for NodeSymbol {}
781
782#[derive(Clone, Debug)]
783pub enum DeviceAddress {
784 IntValue(u8),
786 ArrayIntValue(Vec<u8>),
788 CharIntValue(String),
790 ArrayCharIntValue(Vec<String>),
792 StringValue(String),
794 #[doc(hidden)]
795 __SourceBreaking { unknown_ordinal: u64 },
796}
797
798#[macro_export]
800macro_rules! DeviceAddressUnknown {
801 () => {
802 _
803 };
804}
805
806impl PartialEq for DeviceAddress {
808 fn eq(&self, other: &Self) -> bool {
809 match (self, other) {
810 (Self::IntValue(x), Self::IntValue(y)) => *x == *y,
811 (Self::ArrayIntValue(x), Self::ArrayIntValue(y)) => *x == *y,
812 (Self::CharIntValue(x), Self::CharIntValue(y)) => *x == *y,
813 (Self::ArrayCharIntValue(x), Self::ArrayCharIntValue(y)) => *x == *y,
814 (Self::StringValue(x), Self::StringValue(y)) => *x == *y,
815 _ => false,
816 }
817 }
818}
819
820impl DeviceAddress {
821 #[inline]
822 pub fn ordinal(&self) -> u64 {
823 match *self {
824 Self::IntValue(_) => 1,
825 Self::ArrayIntValue(_) => 2,
826 Self::CharIntValue(_) => 3,
827 Self::ArrayCharIntValue(_) => 4,
828 Self::StringValue(_) => 5,
829 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
830 }
831 }
832
833 #[inline]
834 pub fn unknown_variant_for_testing() -> Self {
835 Self::__SourceBreaking { unknown_ordinal: 0 }
836 }
837
838 #[inline]
839 pub fn is_unknown(&self) -> bool {
840 match self {
841 Self::__SourceBreaking { .. } => true,
842 _ => false,
843 }
844 }
845}
846
847impl fidl::Persistable for DeviceAddress {}
848
849#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
850pub enum NodePropertyKey {
851 IntValue(u32),
853 StringValue(String),
854}
855
856impl NodePropertyKey {
857 #[inline]
858 pub fn ordinal(&self) -> u64 {
859 match *self {
860 Self::IntValue(_) => 1,
861 Self::StringValue(_) => 2,
862 }
863 }
864}
865
866impl fidl::Persistable for NodePropertyKey {}
867
868#[derive(Clone, Debug)]
869pub enum NodePropertyValue {
870 IntValue(u32),
871 StringValue(String),
872 BoolValue(bool),
873 EnumValue(String),
874 #[doc(hidden)]
875 __SourceBreaking {
876 unknown_ordinal: u64,
877 },
878}
879
880#[macro_export]
882macro_rules! NodePropertyValueUnknown {
883 () => {
884 _
885 };
886}
887
888impl PartialEq for NodePropertyValue {
890 fn eq(&self, other: &Self) -> bool {
891 match (self, other) {
892 (Self::IntValue(x), Self::IntValue(y)) => *x == *y,
893 (Self::StringValue(x), Self::StringValue(y)) => *x == *y,
894 (Self::BoolValue(x), Self::BoolValue(y)) => *x == *y,
895 (Self::EnumValue(x), Self::EnumValue(y)) => *x == *y,
896 _ => false,
897 }
898 }
899}
900
901impl NodePropertyValue {
902 #[inline]
903 pub fn ordinal(&self) -> u64 {
904 match *self {
905 Self::IntValue(_) => 1,
906 Self::StringValue(_) => 2,
907 Self::BoolValue(_) => 3,
908 Self::EnumValue(_) => 4,
909 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
910 }
911 }
912
913 #[inline]
914 pub fn unknown_variant_for_testing() -> Self {
915 Self::__SourceBreaking { unknown_ordinal: 0 }
916 }
917
918 #[inline]
919 pub fn is_unknown(&self) -> bool {
920 match self {
921 Self::__SourceBreaking { .. } => true,
922 _ => false,
923 }
924 }
925}
926
927impl fidl::Persistable for NodePropertyValue {}
928
929#[derive(Clone, Debug)]
930pub enum Offer {
931 ZirconTransport(fidl_fuchsia_component_decl__common::Offer),
932 DriverTransport(fidl_fuchsia_component_decl__common::Offer),
933 #[doc(hidden)]
934 __SourceBreaking {
935 unknown_ordinal: u64,
936 },
937}
938
939#[macro_export]
941macro_rules! OfferUnknown {
942 () => {
943 _
944 };
945}
946
947impl PartialEq for Offer {
949 fn eq(&self, other: &Self) -> bool {
950 match (self, other) {
951 (Self::ZirconTransport(x), Self::ZirconTransport(y)) => *x == *y,
952 (Self::DriverTransport(x), Self::DriverTransport(y)) => *x == *y,
953 _ => false,
954 }
955 }
956}
957
958impl Offer {
959 #[inline]
960 pub fn ordinal(&self) -> u64 {
961 match *self {
962 Self::ZirconTransport(_) => 1,
963 Self::DriverTransport(_) => 2,
964 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
965 }
966 }
967
968 #[inline]
969 pub fn unknown_variant_for_testing() -> Self {
970 Self::__SourceBreaking { unknown_ordinal: 0 }
971 }
972
973 #[inline]
974 pub fn is_unknown(&self) -> bool {
975 match self {
976 Self::__SourceBreaking { .. } => true,
977 _ => false,
978 }
979 }
980}
981
982impl fidl::Persistable for Offer {}
983
984pub mod composite_node_manager_ordinals {
985 pub const ADD_SPEC: u64 = 0x524e353c8130cc74;
986}
987
988pub mod driver_ordinals {
989 pub const START: u64 = 0x27be00ae42aa60c2;
990 pub const STOP: u64 = 0x4b96c67e29b3843d;
991}
992
993pub mod node_ordinals {
994 pub const ADD_CHILD: u64 = 0x77d10dff3c1ea129;
995}
996
997pub mod node_controller_ordinals {
998 pub const REMOVE: u64 = 0x54fa8b3dfe7bb341;
999 pub const REQUEST_BIND: u64 = 0x41b954726b13508f;
1000 pub const ON_BIND: u64 = 0x51f4165bc5ea202a;
1001}
1002
1003mod internal {
1004 use super::*;
1005 unsafe impl fidl::encoding::TypeMarker for BusType {
1006 type Owned = Self;
1007
1008 #[inline(always)]
1009 fn inline_align(_context: fidl::encoding::Context) -> usize {
1010 std::mem::align_of::<u32>()
1011 }
1012
1013 #[inline(always)]
1014 fn inline_size(_context: fidl::encoding::Context) -> usize {
1015 std::mem::size_of::<u32>()
1016 }
1017
1018 #[inline(always)]
1019 fn encode_is_copy() -> bool {
1020 false
1021 }
1022
1023 #[inline(always)]
1024 fn decode_is_copy() -> bool {
1025 false
1026 }
1027 }
1028
1029 impl fidl::encoding::ValueTypeMarker for BusType {
1030 type Borrowed<'a> = Self;
1031 #[inline(always)]
1032 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1033 *value
1034 }
1035 }
1036
1037 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BusType {
1038 #[inline]
1039 unsafe fn encode(
1040 self,
1041 encoder: &mut fidl::encoding::Encoder<'_, D>,
1042 offset: usize,
1043 _depth: fidl::encoding::Depth,
1044 ) -> fidl::Result<()> {
1045 encoder.debug_check_bounds::<Self>(offset);
1046 encoder.write_num(self.into_primitive(), offset);
1047 Ok(())
1048 }
1049 }
1050
1051 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BusType {
1052 #[inline(always)]
1053 fn new_empty() -> Self {
1054 Self::unknown()
1055 }
1056
1057 #[inline]
1058 unsafe fn decode(
1059 &mut self,
1060 decoder: &mut fidl::encoding::Decoder<'_, D>,
1061 offset: usize,
1062 _depth: fidl::encoding::Depth,
1063 ) -> fidl::Result<()> {
1064 decoder.debug_check_bounds::<Self>(offset);
1065 let prim = decoder.read_num::<u32>(offset);
1066
1067 *self = Self::from_primitive_allow_unknown(prim);
1068 Ok(())
1069 }
1070 }
1071 unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecError {
1072 type Owned = Self;
1073
1074 #[inline(always)]
1075 fn inline_align(_context: fidl::encoding::Context) -> usize {
1076 std::mem::align_of::<u32>()
1077 }
1078
1079 #[inline(always)]
1080 fn inline_size(_context: fidl::encoding::Context) -> usize {
1081 std::mem::size_of::<u32>()
1082 }
1083
1084 #[inline(always)]
1085 fn encode_is_copy() -> bool {
1086 false
1087 }
1088
1089 #[inline(always)]
1090 fn decode_is_copy() -> bool {
1091 false
1092 }
1093 }
1094
1095 impl fidl::encoding::ValueTypeMarker for CompositeNodeSpecError {
1096 type Borrowed<'a> = Self;
1097 #[inline(always)]
1098 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1099 *value
1100 }
1101 }
1102
1103 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1104 for CompositeNodeSpecError
1105 {
1106 #[inline]
1107 unsafe fn encode(
1108 self,
1109 encoder: &mut fidl::encoding::Encoder<'_, D>,
1110 offset: usize,
1111 _depth: fidl::encoding::Depth,
1112 ) -> fidl::Result<()> {
1113 encoder.debug_check_bounds::<Self>(offset);
1114 encoder.write_num(self.into_primitive(), offset);
1115 Ok(())
1116 }
1117 }
1118
1119 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1120 for CompositeNodeSpecError
1121 {
1122 #[inline(always)]
1123 fn new_empty() -> Self {
1124 Self::unknown()
1125 }
1126
1127 #[inline]
1128 unsafe fn decode(
1129 &mut self,
1130 decoder: &mut fidl::encoding::Decoder<'_, D>,
1131 offset: usize,
1132 _depth: fidl::encoding::Depth,
1133 ) -> fidl::Result<()> {
1134 decoder.debug_check_bounds::<Self>(offset);
1135 let prim = decoder.read_num::<u32>(offset);
1136
1137 *self = Self::from_primitive_allow_unknown(prim);
1138 Ok(())
1139 }
1140 }
1141 unsafe impl fidl::encoding::TypeMarker for Condition {
1142 type Owned = Self;
1143
1144 #[inline(always)]
1145 fn inline_align(_context: fidl::encoding::Context) -> usize {
1146 std::mem::align_of::<u32>()
1147 }
1148
1149 #[inline(always)]
1150 fn inline_size(_context: fidl::encoding::Context) -> usize {
1151 std::mem::size_of::<u32>()
1152 }
1153
1154 #[inline(always)]
1155 fn encode_is_copy() -> bool {
1156 true
1157 }
1158
1159 #[inline(always)]
1160 fn decode_is_copy() -> bool {
1161 false
1162 }
1163 }
1164
1165 impl fidl::encoding::ValueTypeMarker for Condition {
1166 type Borrowed<'a> = Self;
1167 #[inline(always)]
1168 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1169 *value
1170 }
1171 }
1172
1173 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Condition {
1174 #[inline]
1175 unsafe fn encode(
1176 self,
1177 encoder: &mut fidl::encoding::Encoder<'_, D>,
1178 offset: usize,
1179 _depth: fidl::encoding::Depth,
1180 ) -> fidl::Result<()> {
1181 encoder.debug_check_bounds::<Self>(offset);
1182 encoder.write_num(self.into_primitive(), offset);
1183 Ok(())
1184 }
1185 }
1186
1187 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Condition {
1188 #[inline(always)]
1189 fn new_empty() -> Self {
1190 Self::Unknown
1191 }
1192
1193 #[inline]
1194 unsafe fn decode(
1195 &mut self,
1196 decoder: &mut fidl::encoding::Decoder<'_, D>,
1197 offset: usize,
1198 _depth: fidl::encoding::Depth,
1199 ) -> fidl::Result<()> {
1200 decoder.debug_check_bounds::<Self>(offset);
1201 let prim = decoder.read_num::<u32>(offset);
1202
1203 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1204 Ok(())
1205 }
1206 }
1207 unsafe impl fidl::encoding::TypeMarker for DeviceAddressStability {
1208 type Owned = Self;
1209
1210 #[inline(always)]
1211 fn inline_align(_context: fidl::encoding::Context) -> usize {
1212 std::mem::align_of::<u32>()
1213 }
1214
1215 #[inline(always)]
1216 fn inline_size(_context: fidl::encoding::Context) -> usize {
1217 std::mem::size_of::<u32>()
1218 }
1219
1220 #[inline(always)]
1221 fn encode_is_copy() -> bool {
1222 false
1223 }
1224
1225 #[inline(always)]
1226 fn decode_is_copy() -> bool {
1227 false
1228 }
1229 }
1230
1231 impl fidl::encoding::ValueTypeMarker for DeviceAddressStability {
1232 type Borrowed<'a> = Self;
1233 #[inline(always)]
1234 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1235 *value
1236 }
1237 }
1238
1239 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1240 for DeviceAddressStability
1241 {
1242 #[inline]
1243 unsafe fn encode(
1244 self,
1245 encoder: &mut fidl::encoding::Encoder<'_, D>,
1246 offset: usize,
1247 _depth: fidl::encoding::Depth,
1248 ) -> fidl::Result<()> {
1249 encoder.debug_check_bounds::<Self>(offset);
1250 encoder.write_num(self.into_primitive(), offset);
1251 Ok(())
1252 }
1253 }
1254
1255 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1256 for DeviceAddressStability
1257 {
1258 #[inline(always)]
1259 fn new_empty() -> Self {
1260 Self::unknown()
1261 }
1262
1263 #[inline]
1264 unsafe fn decode(
1265 &mut self,
1266 decoder: &mut fidl::encoding::Decoder<'_, D>,
1267 offset: usize,
1268 _depth: fidl::encoding::Depth,
1269 ) -> fidl::Result<()> {
1270 decoder.debug_check_bounds::<Self>(offset);
1271 let prim = decoder.read_num::<u32>(offset);
1272
1273 *self = Self::from_primitive_allow_unknown(prim);
1274 Ok(())
1275 }
1276 }
1277 unsafe impl fidl::encoding::TypeMarker for DriverPackageType {
1278 type Owned = Self;
1279
1280 #[inline(always)]
1281 fn inline_align(_context: fidl::encoding::Context) -> usize {
1282 std::mem::align_of::<u8>()
1283 }
1284
1285 #[inline(always)]
1286 fn inline_size(_context: fidl::encoding::Context) -> usize {
1287 std::mem::size_of::<u8>()
1288 }
1289
1290 #[inline(always)]
1291 fn encode_is_copy() -> bool {
1292 false
1293 }
1294
1295 #[inline(always)]
1296 fn decode_is_copy() -> bool {
1297 false
1298 }
1299 }
1300
1301 impl fidl::encoding::ValueTypeMarker for DriverPackageType {
1302 type Borrowed<'a> = Self;
1303 #[inline(always)]
1304 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1305 *value
1306 }
1307 }
1308
1309 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1310 for DriverPackageType
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::<Self>(offset);
1320 encoder.write_num(self.into_primitive(), offset);
1321 Ok(())
1322 }
1323 }
1324
1325 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverPackageType {
1326 #[inline(always)]
1327 fn new_empty() -> Self {
1328 Self::unknown()
1329 }
1330
1331 #[inline]
1332 unsafe fn decode(
1333 &mut self,
1334 decoder: &mut fidl::encoding::Decoder<'_, D>,
1335 offset: usize,
1336 _depth: fidl::encoding::Depth,
1337 ) -> fidl::Result<()> {
1338 decoder.debug_check_bounds::<Self>(offset);
1339 let prim = decoder.read_num::<u8>(offset);
1340
1341 *self = Self::from_primitive_allow_unknown(prim);
1342 Ok(())
1343 }
1344 }
1345 unsafe impl fidl::encoding::TypeMarker for NodeError {
1346 type Owned = Self;
1347
1348 #[inline(always)]
1349 fn inline_align(_context: fidl::encoding::Context) -> usize {
1350 std::mem::align_of::<u32>()
1351 }
1352
1353 #[inline(always)]
1354 fn inline_size(_context: fidl::encoding::Context) -> usize {
1355 std::mem::size_of::<u32>()
1356 }
1357
1358 #[inline(always)]
1359 fn encode_is_copy() -> bool {
1360 false
1361 }
1362
1363 #[inline(always)]
1364 fn decode_is_copy() -> bool {
1365 false
1366 }
1367 }
1368
1369 impl fidl::encoding::ValueTypeMarker for NodeError {
1370 type Borrowed<'a> = Self;
1371 #[inline(always)]
1372 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1373 *value
1374 }
1375 }
1376
1377 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeError {
1378 #[inline]
1379 unsafe fn encode(
1380 self,
1381 encoder: &mut fidl::encoding::Encoder<'_, D>,
1382 offset: usize,
1383 _depth: fidl::encoding::Depth,
1384 ) -> fidl::Result<()> {
1385 encoder.debug_check_bounds::<Self>(offset);
1386 encoder.write_num(self.into_primitive(), offset);
1387 Ok(())
1388 }
1389 }
1390
1391 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeError {
1392 #[inline(always)]
1393 fn new_empty() -> Self {
1394 Self::unknown()
1395 }
1396
1397 #[inline]
1398 unsafe fn decode(
1399 &mut self,
1400 decoder: &mut fidl::encoding::Decoder<'_, D>,
1401 offset: usize,
1402 _depth: fidl::encoding::Depth,
1403 ) -> fidl::Result<()> {
1404 decoder.debug_check_bounds::<Self>(offset);
1405 let prim = decoder.read_num::<u32>(offset);
1406
1407 *self = Self::from_primitive_allow_unknown(prim);
1408 Ok(())
1409 }
1410 }
1411
1412 impl fidl::encoding::ValueTypeMarker for BindRule {
1413 type Borrowed<'a> = &'a Self;
1414 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1415 value
1416 }
1417 }
1418
1419 unsafe impl fidl::encoding::TypeMarker for BindRule {
1420 type Owned = Self;
1421
1422 #[inline(always)]
1423 fn inline_align(_context: fidl::encoding::Context) -> usize {
1424 8
1425 }
1426
1427 #[inline(always)]
1428 fn inline_size(_context: fidl::encoding::Context) -> usize {
1429 40
1430 }
1431 }
1432
1433 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindRule, D> for &BindRule {
1434 #[inline]
1435 unsafe fn encode(
1436 self,
1437 encoder: &mut fidl::encoding::Encoder<'_, D>,
1438 offset: usize,
1439 _depth: fidl::encoding::Depth,
1440 ) -> fidl::Result<()> {
1441 encoder.debug_check_bounds::<BindRule>(offset);
1442 fidl::encoding::Encode::<BindRule, D>::encode(
1444 (
1445 <NodePropertyKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1446 <Condition as fidl::encoding::ValueTypeMarker>::borrow(&self.condition),
1447 <fidl::encoding::Vector<NodePropertyValue, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.values),
1448 ),
1449 encoder, offset, _depth
1450 )
1451 }
1452 }
1453 unsafe impl<
1454 D: fidl::encoding::ResourceDialect,
1455 T0: fidl::encoding::Encode<NodePropertyKey, D>,
1456 T1: fidl::encoding::Encode<Condition, D>,
1457 T2: fidl::encoding::Encode<fidl::encoding::Vector<NodePropertyValue, 64>, D>,
1458 > fidl::encoding::Encode<BindRule, D> for (T0, T1, T2)
1459 {
1460 #[inline]
1461 unsafe fn encode(
1462 self,
1463 encoder: &mut fidl::encoding::Encoder<'_, D>,
1464 offset: usize,
1465 depth: fidl::encoding::Depth,
1466 ) -> fidl::Result<()> {
1467 encoder.debug_check_bounds::<BindRule>(offset);
1468 unsafe {
1471 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1472 (ptr as *mut u64).write_unaligned(0);
1473 }
1474 self.0.encode(encoder, offset + 0, depth)?;
1476 self.1.encode(encoder, offset + 16, depth)?;
1477 self.2.encode(encoder, offset + 24, depth)?;
1478 Ok(())
1479 }
1480 }
1481
1482 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BindRule {
1483 #[inline(always)]
1484 fn new_empty() -> Self {
1485 Self {
1486 key: fidl::new_empty!(NodePropertyKey, D),
1487 condition: fidl::new_empty!(Condition, D),
1488 values: fidl::new_empty!(fidl::encoding::Vector<NodePropertyValue, 64>, D),
1489 }
1490 }
1491
1492 #[inline]
1493 unsafe fn decode(
1494 &mut self,
1495 decoder: &mut fidl::encoding::Decoder<'_, D>,
1496 offset: usize,
1497 _depth: fidl::encoding::Depth,
1498 ) -> fidl::Result<()> {
1499 decoder.debug_check_bounds::<Self>(offset);
1500 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1502 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1503 let mask = 0xffffffff00000000u64;
1504 let maskedval = padval & mask;
1505 if maskedval != 0 {
1506 return Err(fidl::Error::NonZeroPadding {
1507 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1508 });
1509 }
1510 fidl::decode!(NodePropertyKey, D, &mut self.key, decoder, offset + 0, _depth)?;
1511 fidl::decode!(Condition, D, &mut self.condition, decoder, offset + 16, _depth)?;
1512 fidl::decode!(fidl::encoding::Vector<NodePropertyValue, 64>, D, &mut self.values, decoder, offset + 24, _depth)?;
1513 Ok(())
1514 }
1515 }
1516
1517 impl fidl::encoding::ValueTypeMarker for BindRule2 {
1518 type Borrowed<'a> = &'a Self;
1519 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1520 value
1521 }
1522 }
1523
1524 unsafe impl fidl::encoding::TypeMarker for BindRule2 {
1525 type Owned = Self;
1526
1527 #[inline(always)]
1528 fn inline_align(_context: fidl::encoding::Context) -> usize {
1529 8
1530 }
1531
1532 #[inline(always)]
1533 fn inline_size(_context: fidl::encoding::Context) -> usize {
1534 40
1535 }
1536 }
1537
1538 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindRule2, D>
1539 for &BindRule2
1540 {
1541 #[inline]
1542 unsafe fn encode(
1543 self,
1544 encoder: &mut fidl::encoding::Encoder<'_, D>,
1545 offset: usize,
1546 _depth: fidl::encoding::Depth,
1547 ) -> fidl::Result<()> {
1548 encoder.debug_check_bounds::<BindRule2>(offset);
1549 fidl::encoding::Encode::<BindRule2, D>::encode(
1551 (
1552 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1553 <Condition as fidl::encoding::ValueTypeMarker>::borrow(&self.condition),
1554 <fidl::encoding::Vector<NodePropertyValue, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.values),
1555 ),
1556 encoder, offset, _depth
1557 )
1558 }
1559 }
1560 unsafe impl<
1561 D: fidl::encoding::ResourceDialect,
1562 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1563 T1: fidl::encoding::Encode<Condition, D>,
1564 T2: fidl::encoding::Encode<fidl::encoding::Vector<NodePropertyValue, 64>, D>,
1565 > fidl::encoding::Encode<BindRule2, D> for (T0, T1, T2)
1566 {
1567 #[inline]
1568 unsafe fn encode(
1569 self,
1570 encoder: &mut fidl::encoding::Encoder<'_, D>,
1571 offset: usize,
1572 depth: fidl::encoding::Depth,
1573 ) -> fidl::Result<()> {
1574 encoder.debug_check_bounds::<BindRule2>(offset);
1575 unsafe {
1578 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1579 (ptr as *mut u64).write_unaligned(0);
1580 }
1581 self.0.encode(encoder, offset + 0, depth)?;
1583 self.1.encode(encoder, offset + 16, depth)?;
1584 self.2.encode(encoder, offset + 24, depth)?;
1585 Ok(())
1586 }
1587 }
1588
1589 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BindRule2 {
1590 #[inline(always)]
1591 fn new_empty() -> Self {
1592 Self {
1593 key: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1594 condition: fidl::new_empty!(Condition, D),
1595 values: fidl::new_empty!(fidl::encoding::Vector<NodePropertyValue, 64>, D),
1596 }
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 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1609 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1610 let mask = 0xffffffff00000000u64;
1611 let maskedval = padval & mask;
1612 if maskedval != 0 {
1613 return Err(fidl::Error::NonZeroPadding {
1614 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1615 });
1616 }
1617 fidl::decode!(
1618 fidl::encoding::BoundedString<256>,
1619 D,
1620 &mut self.key,
1621 decoder,
1622 offset + 0,
1623 _depth
1624 )?;
1625 fidl::decode!(Condition, D, &mut self.condition, decoder, offset + 16, _depth)?;
1626 fidl::decode!(fidl::encoding::Vector<NodePropertyValue, 64>, D, &mut self.values, decoder, offset + 24, _depth)?;
1627 Ok(())
1628 }
1629 }
1630
1631 impl fidl::encoding::ValueTypeMarker for NodeProperty {
1632 type Borrowed<'a> = &'a Self;
1633 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1634 value
1635 }
1636 }
1637
1638 unsafe impl fidl::encoding::TypeMarker for NodeProperty {
1639 type Owned = Self;
1640
1641 #[inline(always)]
1642 fn inline_align(_context: fidl::encoding::Context) -> usize {
1643 8
1644 }
1645
1646 #[inline(always)]
1647 fn inline_size(_context: fidl::encoding::Context) -> usize {
1648 32
1649 }
1650 }
1651
1652 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProperty, D>
1653 for &NodeProperty
1654 {
1655 #[inline]
1656 unsafe fn encode(
1657 self,
1658 encoder: &mut fidl::encoding::Encoder<'_, D>,
1659 offset: usize,
1660 _depth: fidl::encoding::Depth,
1661 ) -> fidl::Result<()> {
1662 encoder.debug_check_bounds::<NodeProperty>(offset);
1663 fidl::encoding::Encode::<NodeProperty, D>::encode(
1665 (
1666 <NodePropertyKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1667 <NodePropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
1668 ),
1669 encoder,
1670 offset,
1671 _depth,
1672 )
1673 }
1674 }
1675 unsafe impl<
1676 D: fidl::encoding::ResourceDialect,
1677 T0: fidl::encoding::Encode<NodePropertyKey, D>,
1678 T1: fidl::encoding::Encode<NodePropertyValue, D>,
1679 > fidl::encoding::Encode<NodeProperty, D> for (T0, T1)
1680 {
1681 #[inline]
1682 unsafe fn encode(
1683 self,
1684 encoder: &mut fidl::encoding::Encoder<'_, D>,
1685 offset: usize,
1686 depth: fidl::encoding::Depth,
1687 ) -> fidl::Result<()> {
1688 encoder.debug_check_bounds::<NodeProperty>(offset);
1689 self.0.encode(encoder, offset + 0, depth)?;
1693 self.1.encode(encoder, offset + 16, depth)?;
1694 Ok(())
1695 }
1696 }
1697
1698 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProperty {
1699 #[inline(always)]
1700 fn new_empty() -> Self {
1701 Self {
1702 key: fidl::new_empty!(NodePropertyKey, D),
1703 value: fidl::new_empty!(NodePropertyValue, D),
1704 }
1705 }
1706
1707 #[inline]
1708 unsafe fn decode(
1709 &mut self,
1710 decoder: &mut fidl::encoding::Decoder<'_, D>,
1711 offset: usize,
1712 _depth: fidl::encoding::Depth,
1713 ) -> fidl::Result<()> {
1714 decoder.debug_check_bounds::<Self>(offset);
1715 fidl::decode!(NodePropertyKey, D, &mut self.key, decoder, offset + 0, _depth)?;
1717 fidl::decode!(NodePropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
1718 Ok(())
1719 }
1720 }
1721
1722 impl fidl::encoding::ValueTypeMarker for NodeProperty2 {
1723 type Borrowed<'a> = &'a Self;
1724 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1725 value
1726 }
1727 }
1728
1729 unsafe impl fidl::encoding::TypeMarker for NodeProperty2 {
1730 type Owned = Self;
1731
1732 #[inline(always)]
1733 fn inline_align(_context: fidl::encoding::Context) -> usize {
1734 8
1735 }
1736
1737 #[inline(always)]
1738 fn inline_size(_context: fidl::encoding::Context) -> usize {
1739 32
1740 }
1741 }
1742
1743 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProperty2, D>
1744 for &NodeProperty2
1745 {
1746 #[inline]
1747 unsafe fn encode(
1748 self,
1749 encoder: &mut fidl::encoding::Encoder<'_, D>,
1750 offset: usize,
1751 _depth: fidl::encoding::Depth,
1752 ) -> fidl::Result<()> {
1753 encoder.debug_check_bounds::<NodeProperty2>(offset);
1754 fidl::encoding::Encode::<NodeProperty2, D>::encode(
1756 (
1757 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
1758 &self.key,
1759 ),
1760 <NodePropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
1761 ),
1762 encoder,
1763 offset,
1764 _depth,
1765 )
1766 }
1767 }
1768 unsafe impl<
1769 D: fidl::encoding::ResourceDialect,
1770 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1771 T1: fidl::encoding::Encode<NodePropertyValue, D>,
1772 > fidl::encoding::Encode<NodeProperty2, D> for (T0, T1)
1773 {
1774 #[inline]
1775 unsafe fn encode(
1776 self,
1777 encoder: &mut fidl::encoding::Encoder<'_, D>,
1778 offset: usize,
1779 depth: fidl::encoding::Depth,
1780 ) -> fidl::Result<()> {
1781 encoder.debug_check_bounds::<NodeProperty2>(offset);
1782 self.0.encode(encoder, offset + 0, depth)?;
1786 self.1.encode(encoder, offset + 16, depth)?;
1787 Ok(())
1788 }
1789 }
1790
1791 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProperty2 {
1792 #[inline(always)]
1793 fn new_empty() -> Self {
1794 Self {
1795 key: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1796 value: fidl::new_empty!(NodePropertyValue, D),
1797 }
1798 }
1799
1800 #[inline]
1801 unsafe fn decode(
1802 &mut self,
1803 decoder: &mut fidl::encoding::Decoder<'_, D>,
1804 offset: usize,
1805 _depth: fidl::encoding::Depth,
1806 ) -> fidl::Result<()> {
1807 decoder.debug_check_bounds::<Self>(offset);
1808 fidl::decode!(
1810 fidl::encoding::BoundedString<256>,
1811 D,
1812 &mut self.key,
1813 decoder,
1814 offset + 0,
1815 _depth
1816 )?;
1817 fidl::decode!(NodePropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
1818 Ok(())
1819 }
1820 }
1821
1822 impl fidl::encoding::ValueTypeMarker for NodePropertyEntry {
1823 type Borrowed<'a> = &'a Self;
1824 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1825 value
1826 }
1827 }
1828
1829 unsafe impl fidl::encoding::TypeMarker for NodePropertyEntry {
1830 type Owned = Self;
1831
1832 #[inline(always)]
1833 fn inline_align(_context: fidl::encoding::Context) -> usize {
1834 8
1835 }
1836
1837 #[inline(always)]
1838 fn inline_size(_context: fidl::encoding::Context) -> usize {
1839 32
1840 }
1841 }
1842
1843 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyEntry, D>
1844 for &NodePropertyEntry
1845 {
1846 #[inline]
1847 unsafe fn encode(
1848 self,
1849 encoder: &mut fidl::encoding::Encoder<'_, D>,
1850 offset: usize,
1851 _depth: fidl::encoding::Depth,
1852 ) -> fidl::Result<()> {
1853 encoder.debug_check_bounds::<NodePropertyEntry>(offset);
1854 fidl::encoding::Encode::<NodePropertyEntry, D>::encode(
1856 (
1857 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1858 <fidl::encoding::Vector<NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
1859 ),
1860 encoder, offset, _depth
1861 )
1862 }
1863 }
1864 unsafe impl<
1865 D: fidl::encoding::ResourceDialect,
1866 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1867 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty, 64>, D>,
1868 > fidl::encoding::Encode<NodePropertyEntry, D> for (T0, T1)
1869 {
1870 #[inline]
1871 unsafe fn encode(
1872 self,
1873 encoder: &mut fidl::encoding::Encoder<'_, D>,
1874 offset: usize,
1875 depth: fidl::encoding::Depth,
1876 ) -> fidl::Result<()> {
1877 encoder.debug_check_bounds::<NodePropertyEntry>(offset);
1878 self.0.encode(encoder, offset + 0, depth)?;
1882 self.1.encode(encoder, offset + 16, depth)?;
1883 Ok(())
1884 }
1885 }
1886
1887 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyEntry {
1888 #[inline(always)]
1889 fn new_empty() -> Self {
1890 Self {
1891 name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1892 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty, 64>, D),
1893 }
1894 }
1895
1896 #[inline]
1897 unsafe fn decode(
1898 &mut self,
1899 decoder: &mut fidl::encoding::Decoder<'_, D>,
1900 offset: usize,
1901 _depth: fidl::encoding::Depth,
1902 ) -> fidl::Result<()> {
1903 decoder.debug_check_bounds::<Self>(offset);
1904 fidl::decode!(
1906 fidl::encoding::BoundedString<128>,
1907 D,
1908 &mut self.name,
1909 decoder,
1910 offset + 0,
1911 _depth
1912 )?;
1913 fidl::decode!(fidl::encoding::Vector<NodeProperty, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
1914 Ok(())
1915 }
1916 }
1917
1918 impl fidl::encoding::ValueTypeMarker for NodePropertyEntry2 {
1919 type Borrowed<'a> = &'a Self;
1920 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1921 value
1922 }
1923 }
1924
1925 unsafe impl fidl::encoding::TypeMarker for NodePropertyEntry2 {
1926 type Owned = Self;
1927
1928 #[inline(always)]
1929 fn inline_align(_context: fidl::encoding::Context) -> usize {
1930 8
1931 }
1932
1933 #[inline(always)]
1934 fn inline_size(_context: fidl::encoding::Context) -> usize {
1935 32
1936 }
1937 }
1938
1939 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyEntry2, D>
1940 for &NodePropertyEntry2
1941 {
1942 #[inline]
1943 unsafe fn encode(
1944 self,
1945 encoder: &mut fidl::encoding::Encoder<'_, D>,
1946 offset: usize,
1947 _depth: fidl::encoding::Depth,
1948 ) -> fidl::Result<()> {
1949 encoder.debug_check_bounds::<NodePropertyEntry2>(offset);
1950 fidl::encoding::Encode::<NodePropertyEntry2, D>::encode(
1952 (
1953 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1954 <fidl::encoding::Vector<NodeProperty2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
1955 ),
1956 encoder, offset, _depth
1957 )
1958 }
1959 }
1960 unsafe impl<
1961 D: fidl::encoding::ResourceDialect,
1962 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1963 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty2, 64>, D>,
1964 > fidl::encoding::Encode<NodePropertyEntry2, D> for (T0, T1)
1965 {
1966 #[inline]
1967 unsafe fn encode(
1968 self,
1969 encoder: &mut fidl::encoding::Encoder<'_, D>,
1970 offset: usize,
1971 depth: fidl::encoding::Depth,
1972 ) -> fidl::Result<()> {
1973 encoder.debug_check_bounds::<NodePropertyEntry2>(offset);
1974 self.0.encode(encoder, offset + 0, depth)?;
1978 self.1.encode(encoder, offset + 16, depth)?;
1979 Ok(())
1980 }
1981 }
1982
1983 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyEntry2 {
1984 #[inline(always)]
1985 fn new_empty() -> Self {
1986 Self {
1987 name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1988 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty2, 64>, D),
1989 }
1990 }
1991
1992 #[inline]
1993 unsafe fn decode(
1994 &mut self,
1995 decoder: &mut fidl::encoding::Decoder<'_, D>,
1996 offset: usize,
1997 _depth: fidl::encoding::Depth,
1998 ) -> fidl::Result<()> {
1999 decoder.debug_check_bounds::<Self>(offset);
2000 fidl::decode!(
2002 fidl::encoding::BoundedString<128>,
2003 D,
2004 &mut self.name,
2005 decoder,
2006 offset + 0,
2007 _depth
2008 )?;
2009 fidl::decode!(fidl::encoding::Vector<NodeProperty2, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2010 Ok(())
2011 }
2012 }
2013
2014 impl fidl::encoding::ValueTypeMarker for ParentSpec {
2015 type Borrowed<'a> = &'a Self;
2016 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2017 value
2018 }
2019 }
2020
2021 unsafe impl fidl::encoding::TypeMarker for ParentSpec {
2022 type Owned = Self;
2023
2024 #[inline(always)]
2025 fn inline_align(_context: fidl::encoding::Context) -> usize {
2026 8
2027 }
2028
2029 #[inline(always)]
2030 fn inline_size(_context: fidl::encoding::Context) -> usize {
2031 32
2032 }
2033 }
2034
2035 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentSpec, D>
2036 for &ParentSpec
2037 {
2038 #[inline]
2039 unsafe fn encode(
2040 self,
2041 encoder: &mut fidl::encoding::Encoder<'_, D>,
2042 offset: usize,
2043 _depth: fidl::encoding::Depth,
2044 ) -> fidl::Result<()> {
2045 encoder.debug_check_bounds::<ParentSpec>(offset);
2046 fidl::encoding::Encode::<ParentSpec, D>::encode(
2048 (
2049 <fidl::encoding::Vector<BindRule, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.bind_rules),
2050 <fidl::encoding::Vector<NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
2051 ),
2052 encoder, offset, _depth
2053 )
2054 }
2055 }
2056 unsafe impl<
2057 D: fidl::encoding::ResourceDialect,
2058 T0: fidl::encoding::Encode<fidl::encoding::Vector<BindRule, 64>, D>,
2059 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty, 64>, D>,
2060 > fidl::encoding::Encode<ParentSpec, D> for (T0, T1)
2061 {
2062 #[inline]
2063 unsafe fn encode(
2064 self,
2065 encoder: &mut fidl::encoding::Encoder<'_, D>,
2066 offset: usize,
2067 depth: fidl::encoding::Depth,
2068 ) -> fidl::Result<()> {
2069 encoder.debug_check_bounds::<ParentSpec>(offset);
2070 self.0.encode(encoder, offset + 0, depth)?;
2074 self.1.encode(encoder, offset + 16, depth)?;
2075 Ok(())
2076 }
2077 }
2078
2079 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentSpec {
2080 #[inline(always)]
2081 fn new_empty() -> Self {
2082 Self {
2083 bind_rules: fidl::new_empty!(fidl::encoding::Vector<BindRule, 64>, D),
2084 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty, 64>, D),
2085 }
2086 }
2087
2088 #[inline]
2089 unsafe fn decode(
2090 &mut self,
2091 decoder: &mut fidl::encoding::Decoder<'_, D>,
2092 offset: usize,
2093 _depth: fidl::encoding::Depth,
2094 ) -> fidl::Result<()> {
2095 decoder.debug_check_bounds::<Self>(offset);
2096 fidl::decode!(fidl::encoding::Vector<BindRule, 64>, D, &mut self.bind_rules, decoder, offset + 0, _depth)?;
2098 fidl::decode!(fidl::encoding::Vector<NodeProperty, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2099 Ok(())
2100 }
2101 }
2102
2103 impl fidl::encoding::ValueTypeMarker for ParentSpec2 {
2104 type Borrowed<'a> = &'a Self;
2105 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2106 value
2107 }
2108 }
2109
2110 unsafe impl fidl::encoding::TypeMarker for ParentSpec2 {
2111 type Owned = Self;
2112
2113 #[inline(always)]
2114 fn inline_align(_context: fidl::encoding::Context) -> usize {
2115 8
2116 }
2117
2118 #[inline(always)]
2119 fn inline_size(_context: fidl::encoding::Context) -> usize {
2120 32
2121 }
2122 }
2123
2124 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentSpec2, D>
2125 for &ParentSpec2
2126 {
2127 #[inline]
2128 unsafe fn encode(
2129 self,
2130 encoder: &mut fidl::encoding::Encoder<'_, D>,
2131 offset: usize,
2132 _depth: fidl::encoding::Depth,
2133 ) -> fidl::Result<()> {
2134 encoder.debug_check_bounds::<ParentSpec2>(offset);
2135 fidl::encoding::Encode::<ParentSpec2, D>::encode(
2137 (
2138 <fidl::encoding::Vector<BindRule2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.bind_rules),
2139 <fidl::encoding::Vector<NodeProperty2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
2140 ),
2141 encoder, offset, _depth
2142 )
2143 }
2144 }
2145 unsafe impl<
2146 D: fidl::encoding::ResourceDialect,
2147 T0: fidl::encoding::Encode<fidl::encoding::Vector<BindRule2, 64>, D>,
2148 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty2, 64>, D>,
2149 > fidl::encoding::Encode<ParentSpec2, D> for (T0, T1)
2150 {
2151 #[inline]
2152 unsafe fn encode(
2153 self,
2154 encoder: &mut fidl::encoding::Encoder<'_, D>,
2155 offset: usize,
2156 depth: fidl::encoding::Depth,
2157 ) -> fidl::Result<()> {
2158 encoder.debug_check_bounds::<ParentSpec2>(offset);
2159 self.0.encode(encoder, offset + 0, depth)?;
2163 self.1.encode(encoder, offset + 16, depth)?;
2164 Ok(())
2165 }
2166 }
2167
2168 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentSpec2 {
2169 #[inline(always)]
2170 fn new_empty() -> Self {
2171 Self {
2172 bind_rules: fidl::new_empty!(fidl::encoding::Vector<BindRule2, 64>, D),
2173 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty2, 64>, D),
2174 }
2175 }
2176
2177 #[inline]
2178 unsafe fn decode(
2179 &mut self,
2180 decoder: &mut fidl::encoding::Decoder<'_, D>,
2181 offset: usize,
2182 _depth: fidl::encoding::Depth,
2183 ) -> fidl::Result<()> {
2184 decoder.debug_check_bounds::<Self>(offset);
2185 fidl::decode!(fidl::encoding::Vector<BindRule2, 64>, D, &mut self.bind_rules, decoder, offset + 0, _depth)?;
2187 fidl::decode!(fidl::encoding::Vector<NodeProperty2, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2188 Ok(())
2189 }
2190 }
2191
2192 impl BusInfo {
2193 #[inline(always)]
2194 fn max_ordinal_present(&self) -> u64 {
2195 if let Some(_) = self.address_stability {
2196 return 3;
2197 }
2198 if let Some(_) = self.address {
2199 return 2;
2200 }
2201 if let Some(_) = self.bus {
2202 return 1;
2203 }
2204 0
2205 }
2206 }
2207
2208 impl fidl::encoding::ValueTypeMarker for BusInfo {
2209 type Borrowed<'a> = &'a Self;
2210 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2211 value
2212 }
2213 }
2214
2215 unsafe impl fidl::encoding::TypeMarker for BusInfo {
2216 type Owned = Self;
2217
2218 #[inline(always)]
2219 fn inline_align(_context: fidl::encoding::Context) -> usize {
2220 8
2221 }
2222
2223 #[inline(always)]
2224 fn inline_size(_context: fidl::encoding::Context) -> usize {
2225 16
2226 }
2227 }
2228
2229 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BusInfo, D> for &BusInfo {
2230 unsafe fn encode(
2231 self,
2232 encoder: &mut fidl::encoding::Encoder<'_, D>,
2233 offset: usize,
2234 mut depth: fidl::encoding::Depth,
2235 ) -> fidl::Result<()> {
2236 encoder.debug_check_bounds::<BusInfo>(offset);
2237 let max_ordinal: u64 = self.max_ordinal_present();
2239 encoder.write_num(max_ordinal, offset);
2240 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2241 if max_ordinal == 0 {
2243 return Ok(());
2244 }
2245 depth.increment()?;
2246 let envelope_size = 8;
2247 let bytes_len = max_ordinal as usize * envelope_size;
2248 #[allow(unused_variables)]
2249 let offset = encoder.out_of_line_offset(bytes_len);
2250 let mut _prev_end_offset: usize = 0;
2251 if 1 > max_ordinal {
2252 return Ok(());
2253 }
2254
2255 let cur_offset: usize = (1 - 1) * envelope_size;
2258
2259 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2261
2262 fidl::encoding::encode_in_envelope_optional::<BusType, D>(
2267 self.bus.as_ref().map(<BusType as fidl::encoding::ValueTypeMarker>::borrow),
2268 encoder,
2269 offset + cur_offset,
2270 depth,
2271 )?;
2272
2273 _prev_end_offset = cur_offset + envelope_size;
2274 if 2 > max_ordinal {
2275 return Ok(());
2276 }
2277
2278 let cur_offset: usize = (2 - 1) * envelope_size;
2281
2282 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2284
2285 fidl::encoding::encode_in_envelope_optional::<DeviceAddress, D>(
2290 self.address
2291 .as_ref()
2292 .map(<DeviceAddress as fidl::encoding::ValueTypeMarker>::borrow),
2293 encoder,
2294 offset + cur_offset,
2295 depth,
2296 )?;
2297
2298 _prev_end_offset = cur_offset + envelope_size;
2299 if 3 > max_ordinal {
2300 return Ok(());
2301 }
2302
2303 let cur_offset: usize = (3 - 1) * envelope_size;
2306
2307 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2309
2310 fidl::encoding::encode_in_envelope_optional::<DeviceAddressStability, D>(
2315 self.address_stability
2316 .as_ref()
2317 .map(<DeviceAddressStability as fidl::encoding::ValueTypeMarker>::borrow),
2318 encoder,
2319 offset + cur_offset,
2320 depth,
2321 )?;
2322
2323 _prev_end_offset = cur_offset + envelope_size;
2324
2325 Ok(())
2326 }
2327 }
2328
2329 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BusInfo {
2330 #[inline(always)]
2331 fn new_empty() -> Self {
2332 Self::default()
2333 }
2334
2335 unsafe fn decode(
2336 &mut self,
2337 decoder: &mut fidl::encoding::Decoder<'_, D>,
2338 offset: usize,
2339 mut depth: fidl::encoding::Depth,
2340 ) -> fidl::Result<()> {
2341 decoder.debug_check_bounds::<Self>(offset);
2342 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2343 None => return Err(fidl::Error::NotNullable),
2344 Some(len) => len,
2345 };
2346 if len == 0 {
2348 return Ok(());
2349 };
2350 depth.increment()?;
2351 let envelope_size = 8;
2352 let bytes_len = len * envelope_size;
2353 let offset = decoder.out_of_line_offset(bytes_len)?;
2354 let mut _next_ordinal_to_read = 0;
2356 let mut next_offset = offset;
2357 let end_offset = offset + bytes_len;
2358 _next_ordinal_to_read += 1;
2359 if next_offset >= end_offset {
2360 return Ok(());
2361 }
2362
2363 while _next_ordinal_to_read < 1 {
2365 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2366 _next_ordinal_to_read += 1;
2367 next_offset += envelope_size;
2368 }
2369
2370 let next_out_of_line = decoder.next_out_of_line();
2371 let handles_before = decoder.remaining_handles();
2372 if let Some((inlined, num_bytes, num_handles)) =
2373 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2374 {
2375 let member_inline_size =
2376 <BusType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2377 if inlined != (member_inline_size <= 4) {
2378 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2379 }
2380 let inner_offset;
2381 let mut inner_depth = depth.clone();
2382 if inlined {
2383 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2384 inner_offset = next_offset;
2385 } else {
2386 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2387 inner_depth.increment()?;
2388 }
2389 let val_ref = self.bus.get_or_insert_with(|| fidl::new_empty!(BusType, D));
2390 fidl::decode!(BusType, D, val_ref, decoder, inner_offset, inner_depth)?;
2391 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2392 {
2393 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2394 }
2395 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2396 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2397 }
2398 }
2399
2400 next_offset += envelope_size;
2401 _next_ordinal_to_read += 1;
2402 if next_offset >= end_offset {
2403 return Ok(());
2404 }
2405
2406 while _next_ordinal_to_read < 2 {
2408 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2409 _next_ordinal_to_read += 1;
2410 next_offset += envelope_size;
2411 }
2412
2413 let next_out_of_line = decoder.next_out_of_line();
2414 let handles_before = decoder.remaining_handles();
2415 if let Some((inlined, num_bytes, num_handles)) =
2416 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2417 {
2418 let member_inline_size =
2419 <DeviceAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2420 if inlined != (member_inline_size <= 4) {
2421 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2422 }
2423 let inner_offset;
2424 let mut inner_depth = depth.clone();
2425 if inlined {
2426 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2427 inner_offset = next_offset;
2428 } else {
2429 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2430 inner_depth.increment()?;
2431 }
2432 let val_ref =
2433 self.address.get_or_insert_with(|| fidl::new_empty!(DeviceAddress, D));
2434 fidl::decode!(DeviceAddress, D, val_ref, decoder, inner_offset, inner_depth)?;
2435 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2436 {
2437 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2438 }
2439 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2440 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2441 }
2442 }
2443
2444 next_offset += envelope_size;
2445 _next_ordinal_to_read += 1;
2446 if next_offset >= end_offset {
2447 return Ok(());
2448 }
2449
2450 while _next_ordinal_to_read < 3 {
2452 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2453 _next_ordinal_to_read += 1;
2454 next_offset += envelope_size;
2455 }
2456
2457 let next_out_of_line = decoder.next_out_of_line();
2458 let handles_before = decoder.remaining_handles();
2459 if let Some((inlined, num_bytes, num_handles)) =
2460 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2461 {
2462 let member_inline_size =
2463 <DeviceAddressStability as fidl::encoding::TypeMarker>::inline_size(
2464 decoder.context,
2465 );
2466 if inlined != (member_inline_size <= 4) {
2467 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2468 }
2469 let inner_offset;
2470 let mut inner_depth = depth.clone();
2471 if inlined {
2472 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2473 inner_offset = next_offset;
2474 } else {
2475 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2476 inner_depth.increment()?;
2477 }
2478 let val_ref = self
2479 .address_stability
2480 .get_or_insert_with(|| fidl::new_empty!(DeviceAddressStability, D));
2481 fidl::decode!(
2482 DeviceAddressStability,
2483 D,
2484 val_ref,
2485 decoder,
2486 inner_offset,
2487 inner_depth
2488 )?;
2489 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2490 {
2491 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2492 }
2493 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2494 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2495 }
2496 }
2497
2498 next_offset += envelope_size;
2499
2500 while next_offset < end_offset {
2502 _next_ordinal_to_read += 1;
2503 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2504 next_offset += envelope_size;
2505 }
2506
2507 Ok(())
2508 }
2509 }
2510
2511 impl CompositeDriverInfo {
2512 #[inline(always)]
2513 fn max_ordinal_present(&self) -> u64 {
2514 if let Some(_) = self.driver_info {
2515 return 2;
2516 }
2517 if let Some(_) = self.composite_name {
2518 return 1;
2519 }
2520 0
2521 }
2522 }
2523
2524 impl fidl::encoding::ValueTypeMarker for CompositeDriverInfo {
2525 type Borrowed<'a> = &'a Self;
2526 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2527 value
2528 }
2529 }
2530
2531 unsafe impl fidl::encoding::TypeMarker for CompositeDriverInfo {
2532 type Owned = Self;
2533
2534 #[inline(always)]
2535 fn inline_align(_context: fidl::encoding::Context) -> usize {
2536 8
2537 }
2538
2539 #[inline(always)]
2540 fn inline_size(_context: fidl::encoding::Context) -> usize {
2541 16
2542 }
2543 }
2544
2545 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeDriverInfo, D>
2546 for &CompositeDriverInfo
2547 {
2548 unsafe fn encode(
2549 self,
2550 encoder: &mut fidl::encoding::Encoder<'_, D>,
2551 offset: usize,
2552 mut depth: fidl::encoding::Depth,
2553 ) -> fidl::Result<()> {
2554 encoder.debug_check_bounds::<CompositeDriverInfo>(offset);
2555 let max_ordinal: u64 = self.max_ordinal_present();
2557 encoder.write_num(max_ordinal, offset);
2558 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2559 if max_ordinal == 0 {
2561 return Ok(());
2562 }
2563 depth.increment()?;
2564 let envelope_size = 8;
2565 let bytes_len = max_ordinal as usize * envelope_size;
2566 #[allow(unused_variables)]
2567 let offset = encoder.out_of_line_offset(bytes_len);
2568 let mut _prev_end_offset: usize = 0;
2569 if 1 > max_ordinal {
2570 return Ok(());
2571 }
2572
2573 let cur_offset: usize = (1 - 1) * envelope_size;
2576
2577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2579
2580 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
2585 self.composite_name.as_ref().map(
2586 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
2587 ),
2588 encoder,
2589 offset + cur_offset,
2590 depth,
2591 )?;
2592
2593 _prev_end_offset = cur_offset + envelope_size;
2594 if 2 > max_ordinal {
2595 return Ok(());
2596 }
2597
2598 let cur_offset: usize = (2 - 1) * envelope_size;
2601
2602 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2604
2605 fidl::encoding::encode_in_envelope_optional::<DriverInfo, D>(
2610 self.driver_info
2611 .as_ref()
2612 .map(<DriverInfo as fidl::encoding::ValueTypeMarker>::borrow),
2613 encoder,
2614 offset + cur_offset,
2615 depth,
2616 )?;
2617
2618 _prev_end_offset = cur_offset + envelope_size;
2619
2620 Ok(())
2621 }
2622 }
2623
2624 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeDriverInfo {
2625 #[inline(always)]
2626 fn new_empty() -> Self {
2627 Self::default()
2628 }
2629
2630 unsafe fn decode(
2631 &mut self,
2632 decoder: &mut fidl::encoding::Decoder<'_, D>,
2633 offset: usize,
2634 mut depth: fidl::encoding::Depth,
2635 ) -> fidl::Result<()> {
2636 decoder.debug_check_bounds::<Self>(offset);
2637 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2638 None => return Err(fidl::Error::NotNullable),
2639 Some(len) => len,
2640 };
2641 if len == 0 {
2643 return Ok(());
2644 };
2645 depth.increment()?;
2646 let envelope_size = 8;
2647 let bytes_len = len * envelope_size;
2648 let offset = decoder.out_of_line_offset(bytes_len)?;
2649 let mut _next_ordinal_to_read = 0;
2651 let mut next_offset = offset;
2652 let end_offset = offset + bytes_len;
2653 _next_ordinal_to_read += 1;
2654 if next_offset >= end_offset {
2655 return Ok(());
2656 }
2657
2658 while _next_ordinal_to_read < 1 {
2660 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2661 _next_ordinal_to_read += 1;
2662 next_offset += envelope_size;
2663 }
2664
2665 let next_out_of_line = decoder.next_out_of_line();
2666 let handles_before = decoder.remaining_handles();
2667 if let Some((inlined, num_bytes, num_handles)) =
2668 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2669 {
2670 let member_inline_size =
2671 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2672 decoder.context,
2673 );
2674 if inlined != (member_inline_size <= 4) {
2675 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2676 }
2677 let inner_offset;
2678 let mut inner_depth = depth.clone();
2679 if inlined {
2680 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2681 inner_offset = next_offset;
2682 } else {
2683 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2684 inner_depth.increment()?;
2685 }
2686 let val_ref = self
2687 .composite_name
2688 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2689 fidl::decode!(
2690 fidl::encoding::UnboundedString,
2691 D,
2692 val_ref,
2693 decoder,
2694 inner_offset,
2695 inner_depth
2696 )?;
2697 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2698 {
2699 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2700 }
2701 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2702 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2703 }
2704 }
2705
2706 next_offset += envelope_size;
2707 _next_ordinal_to_read += 1;
2708 if next_offset >= end_offset {
2709 return Ok(());
2710 }
2711
2712 while _next_ordinal_to_read < 2 {
2714 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2715 _next_ordinal_to_read += 1;
2716 next_offset += envelope_size;
2717 }
2718
2719 let next_out_of_line = decoder.next_out_of_line();
2720 let handles_before = decoder.remaining_handles();
2721 if let Some((inlined, num_bytes, num_handles)) =
2722 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2723 {
2724 let member_inline_size =
2725 <DriverInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2726 if inlined != (member_inline_size <= 4) {
2727 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2728 }
2729 let inner_offset;
2730 let mut inner_depth = depth.clone();
2731 if inlined {
2732 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2733 inner_offset = next_offset;
2734 } else {
2735 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2736 inner_depth.increment()?;
2737 }
2738 let val_ref =
2739 self.driver_info.get_or_insert_with(|| fidl::new_empty!(DriverInfo, D));
2740 fidl::decode!(DriverInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2742 {
2743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2744 }
2745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2747 }
2748 }
2749
2750 next_offset += envelope_size;
2751
2752 while next_offset < end_offset {
2754 _next_ordinal_to_read += 1;
2755 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2756 next_offset += envelope_size;
2757 }
2758
2759 Ok(())
2760 }
2761 }
2762
2763 impl CompositeDriverMatch {
2764 #[inline(always)]
2765 fn max_ordinal_present(&self) -> u64 {
2766 if let Some(_) = self.primary_parent_index {
2767 return 3;
2768 }
2769 if let Some(_) = self.parent_names {
2770 return 2;
2771 }
2772 if let Some(_) = self.composite_driver {
2773 return 1;
2774 }
2775 0
2776 }
2777 }
2778
2779 impl fidl::encoding::ValueTypeMarker for CompositeDriverMatch {
2780 type Borrowed<'a> = &'a Self;
2781 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2782 value
2783 }
2784 }
2785
2786 unsafe impl fidl::encoding::TypeMarker for CompositeDriverMatch {
2787 type Owned = Self;
2788
2789 #[inline(always)]
2790 fn inline_align(_context: fidl::encoding::Context) -> usize {
2791 8
2792 }
2793
2794 #[inline(always)]
2795 fn inline_size(_context: fidl::encoding::Context) -> usize {
2796 16
2797 }
2798 }
2799
2800 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeDriverMatch, D>
2801 for &CompositeDriverMatch
2802 {
2803 unsafe fn encode(
2804 self,
2805 encoder: &mut fidl::encoding::Encoder<'_, D>,
2806 offset: usize,
2807 mut depth: fidl::encoding::Depth,
2808 ) -> fidl::Result<()> {
2809 encoder.debug_check_bounds::<CompositeDriverMatch>(offset);
2810 let max_ordinal: u64 = self.max_ordinal_present();
2812 encoder.write_num(max_ordinal, offset);
2813 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2814 if max_ordinal == 0 {
2816 return Ok(());
2817 }
2818 depth.increment()?;
2819 let envelope_size = 8;
2820 let bytes_len = max_ordinal as usize * envelope_size;
2821 #[allow(unused_variables)]
2822 let offset = encoder.out_of_line_offset(bytes_len);
2823 let mut _prev_end_offset: usize = 0;
2824 if 1 > max_ordinal {
2825 return Ok(());
2826 }
2827
2828 let cur_offset: usize = (1 - 1) * envelope_size;
2831
2832 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2834
2835 fidl::encoding::encode_in_envelope_optional::<CompositeDriverInfo, D>(
2840 self.composite_driver
2841 .as_ref()
2842 .map(<CompositeDriverInfo as fidl::encoding::ValueTypeMarker>::borrow),
2843 encoder,
2844 offset + cur_offset,
2845 depth,
2846 )?;
2847
2848 _prev_end_offset = cur_offset + envelope_size;
2849 if 2 > max_ordinal {
2850 return Ok(());
2851 }
2852
2853 let cur_offset: usize = (2 - 1) * envelope_size;
2856
2857 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2859
2860 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, D>(
2865 self.parent_names.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow),
2866 encoder, offset + cur_offset, depth
2867 )?;
2868
2869 _prev_end_offset = cur_offset + envelope_size;
2870 if 3 > max_ordinal {
2871 return Ok(());
2872 }
2873
2874 let cur_offset: usize = (3 - 1) * envelope_size;
2877
2878 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2880
2881 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2886 self.primary_parent_index
2887 .as_ref()
2888 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2889 encoder,
2890 offset + cur_offset,
2891 depth,
2892 )?;
2893
2894 _prev_end_offset = cur_offset + envelope_size;
2895
2896 Ok(())
2897 }
2898 }
2899
2900 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeDriverMatch {
2901 #[inline(always)]
2902 fn new_empty() -> Self {
2903 Self::default()
2904 }
2905
2906 unsafe fn decode(
2907 &mut self,
2908 decoder: &mut fidl::encoding::Decoder<'_, D>,
2909 offset: usize,
2910 mut depth: fidl::encoding::Depth,
2911 ) -> fidl::Result<()> {
2912 decoder.debug_check_bounds::<Self>(offset);
2913 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2914 None => return Err(fidl::Error::NotNullable),
2915 Some(len) => len,
2916 };
2917 if len == 0 {
2919 return Ok(());
2920 };
2921 depth.increment()?;
2922 let envelope_size = 8;
2923 let bytes_len = len * envelope_size;
2924 let offset = decoder.out_of_line_offset(bytes_len)?;
2925 let mut _next_ordinal_to_read = 0;
2927 let mut next_offset = offset;
2928 let end_offset = offset + bytes_len;
2929 _next_ordinal_to_read += 1;
2930 if next_offset >= end_offset {
2931 return Ok(());
2932 }
2933
2934 while _next_ordinal_to_read < 1 {
2936 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2937 _next_ordinal_to_read += 1;
2938 next_offset += envelope_size;
2939 }
2940
2941 let next_out_of_line = decoder.next_out_of_line();
2942 let handles_before = decoder.remaining_handles();
2943 if let Some((inlined, num_bytes, num_handles)) =
2944 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2945 {
2946 let member_inline_size =
2947 <CompositeDriverInfo as fidl::encoding::TypeMarker>::inline_size(
2948 decoder.context,
2949 );
2950 if inlined != (member_inline_size <= 4) {
2951 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2952 }
2953 let inner_offset;
2954 let mut inner_depth = depth.clone();
2955 if inlined {
2956 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2957 inner_offset = next_offset;
2958 } else {
2959 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2960 inner_depth.increment()?;
2961 }
2962 let val_ref = self
2963 .composite_driver
2964 .get_or_insert_with(|| fidl::new_empty!(CompositeDriverInfo, D));
2965 fidl::decode!(CompositeDriverInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2966 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2967 {
2968 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2969 }
2970 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2971 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2972 }
2973 }
2974
2975 next_offset += envelope_size;
2976 _next_ordinal_to_read += 1;
2977 if next_offset >= end_offset {
2978 return Ok(());
2979 }
2980
2981 while _next_ordinal_to_read < 2 {
2983 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2984 _next_ordinal_to_read += 1;
2985 next_offset += envelope_size;
2986 }
2987
2988 let next_out_of_line = decoder.next_out_of_line();
2989 let handles_before = decoder.remaining_handles();
2990 if let Some((inlined, num_bytes, num_handles)) =
2991 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2992 {
2993 let member_inline_size = <fidl::encoding::UnboundedVector<
2994 fidl::encoding::UnboundedString,
2995 > as fidl::encoding::TypeMarker>::inline_size(
2996 decoder.context
2997 );
2998 if inlined != (member_inline_size <= 4) {
2999 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3000 }
3001 let inner_offset;
3002 let mut inner_depth = depth.clone();
3003 if inlined {
3004 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3005 inner_offset = next_offset;
3006 } else {
3007 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3008 inner_depth.increment()?;
3009 }
3010 let val_ref = self.parent_names.get_or_insert_with(|| {
3011 fidl::new_empty!(
3012 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
3013 D
3014 )
3015 });
3016 fidl::decode!(
3017 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
3018 D,
3019 val_ref,
3020 decoder,
3021 inner_offset,
3022 inner_depth
3023 )?;
3024 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3025 {
3026 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3027 }
3028 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3029 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3030 }
3031 }
3032
3033 next_offset += envelope_size;
3034 _next_ordinal_to_read += 1;
3035 if next_offset >= end_offset {
3036 return Ok(());
3037 }
3038
3039 while _next_ordinal_to_read < 3 {
3041 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3042 _next_ordinal_to_read += 1;
3043 next_offset += envelope_size;
3044 }
3045
3046 let next_out_of_line = decoder.next_out_of_line();
3047 let handles_before = decoder.remaining_handles();
3048 if let Some((inlined, num_bytes, num_handles)) =
3049 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3050 {
3051 let member_inline_size =
3052 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3053 if inlined != (member_inline_size <= 4) {
3054 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3055 }
3056 let inner_offset;
3057 let mut inner_depth = depth.clone();
3058 if inlined {
3059 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3060 inner_offset = next_offset;
3061 } else {
3062 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3063 inner_depth.increment()?;
3064 }
3065 let val_ref =
3066 self.primary_parent_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
3067 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3068 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3069 {
3070 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3071 }
3072 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3073 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3074 }
3075 }
3076
3077 next_offset += envelope_size;
3078
3079 while next_offset < end_offset {
3081 _next_ordinal_to_read += 1;
3082 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3083 next_offset += envelope_size;
3084 }
3085
3086 Ok(())
3087 }
3088 }
3089
3090 impl CompositeInfo {
3091 #[inline(always)]
3092 fn max_ordinal_present(&self) -> u64 {
3093 if let Some(_) = self.matched_driver {
3094 return 2;
3095 }
3096 if let Some(_) = self.spec {
3097 return 1;
3098 }
3099 0
3100 }
3101 }
3102
3103 impl fidl::encoding::ValueTypeMarker for CompositeInfo {
3104 type Borrowed<'a> = &'a Self;
3105 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3106 value
3107 }
3108 }
3109
3110 unsafe impl fidl::encoding::TypeMarker for CompositeInfo {
3111 type Owned = Self;
3112
3113 #[inline(always)]
3114 fn inline_align(_context: fidl::encoding::Context) -> usize {
3115 8
3116 }
3117
3118 #[inline(always)]
3119 fn inline_size(_context: fidl::encoding::Context) -> usize {
3120 16
3121 }
3122 }
3123
3124 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeInfo, D>
3125 for &CompositeInfo
3126 {
3127 unsafe fn encode(
3128 self,
3129 encoder: &mut fidl::encoding::Encoder<'_, D>,
3130 offset: usize,
3131 mut depth: fidl::encoding::Depth,
3132 ) -> fidl::Result<()> {
3133 encoder.debug_check_bounds::<CompositeInfo>(offset);
3134 let max_ordinal: u64 = self.max_ordinal_present();
3136 encoder.write_num(max_ordinal, offset);
3137 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3138 if max_ordinal == 0 {
3140 return Ok(());
3141 }
3142 depth.increment()?;
3143 let envelope_size = 8;
3144 let bytes_len = max_ordinal as usize * envelope_size;
3145 #[allow(unused_variables)]
3146 let offset = encoder.out_of_line_offset(bytes_len);
3147 let mut _prev_end_offset: usize = 0;
3148 if 1 > max_ordinal {
3149 return Ok(());
3150 }
3151
3152 let cur_offset: usize = (1 - 1) * envelope_size;
3155
3156 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3158
3159 fidl::encoding::encode_in_envelope_optional::<CompositeNodeSpec, D>(
3164 self.spec
3165 .as_ref()
3166 .map(<CompositeNodeSpec as fidl::encoding::ValueTypeMarker>::borrow),
3167 encoder,
3168 offset + cur_offset,
3169 depth,
3170 )?;
3171
3172 _prev_end_offset = cur_offset + envelope_size;
3173 if 2 > max_ordinal {
3174 return Ok(());
3175 }
3176
3177 let cur_offset: usize = (2 - 1) * envelope_size;
3180
3181 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3183
3184 fidl::encoding::encode_in_envelope_optional::<CompositeDriverMatch, D>(
3189 self.matched_driver
3190 .as_ref()
3191 .map(<CompositeDriverMatch as fidl::encoding::ValueTypeMarker>::borrow),
3192 encoder,
3193 offset + cur_offset,
3194 depth,
3195 )?;
3196
3197 _prev_end_offset = cur_offset + envelope_size;
3198
3199 Ok(())
3200 }
3201 }
3202
3203 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeInfo {
3204 #[inline(always)]
3205 fn new_empty() -> Self {
3206 Self::default()
3207 }
3208
3209 unsafe fn decode(
3210 &mut self,
3211 decoder: &mut fidl::encoding::Decoder<'_, D>,
3212 offset: usize,
3213 mut depth: fidl::encoding::Depth,
3214 ) -> fidl::Result<()> {
3215 decoder.debug_check_bounds::<Self>(offset);
3216 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3217 None => return Err(fidl::Error::NotNullable),
3218 Some(len) => len,
3219 };
3220 if len == 0 {
3222 return Ok(());
3223 };
3224 depth.increment()?;
3225 let envelope_size = 8;
3226 let bytes_len = len * envelope_size;
3227 let offset = decoder.out_of_line_offset(bytes_len)?;
3228 let mut _next_ordinal_to_read = 0;
3230 let mut next_offset = offset;
3231 let end_offset = offset + bytes_len;
3232 _next_ordinal_to_read += 1;
3233 if next_offset >= end_offset {
3234 return Ok(());
3235 }
3236
3237 while _next_ordinal_to_read < 1 {
3239 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3240 _next_ordinal_to_read += 1;
3241 next_offset += envelope_size;
3242 }
3243
3244 let next_out_of_line = decoder.next_out_of_line();
3245 let handles_before = decoder.remaining_handles();
3246 if let Some((inlined, num_bytes, num_handles)) =
3247 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3248 {
3249 let member_inline_size =
3250 <CompositeNodeSpec as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3251 if inlined != (member_inline_size <= 4) {
3252 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3253 }
3254 let inner_offset;
3255 let mut inner_depth = depth.clone();
3256 if inlined {
3257 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3258 inner_offset = next_offset;
3259 } else {
3260 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3261 inner_depth.increment()?;
3262 }
3263 let val_ref =
3264 self.spec.get_or_insert_with(|| fidl::new_empty!(CompositeNodeSpec, D));
3265 fidl::decode!(CompositeNodeSpec, D, val_ref, decoder, inner_offset, inner_depth)?;
3266 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3267 {
3268 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3269 }
3270 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3271 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3272 }
3273 }
3274
3275 next_offset += envelope_size;
3276 _next_ordinal_to_read += 1;
3277 if next_offset >= end_offset {
3278 return Ok(());
3279 }
3280
3281 while _next_ordinal_to_read < 2 {
3283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3284 _next_ordinal_to_read += 1;
3285 next_offset += envelope_size;
3286 }
3287
3288 let next_out_of_line = decoder.next_out_of_line();
3289 let handles_before = decoder.remaining_handles();
3290 if let Some((inlined, num_bytes, num_handles)) =
3291 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3292 {
3293 let member_inline_size =
3294 <CompositeDriverMatch as fidl::encoding::TypeMarker>::inline_size(
3295 decoder.context,
3296 );
3297 if inlined != (member_inline_size <= 4) {
3298 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3299 }
3300 let inner_offset;
3301 let mut inner_depth = depth.clone();
3302 if inlined {
3303 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3304 inner_offset = next_offset;
3305 } else {
3306 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3307 inner_depth.increment()?;
3308 }
3309 let val_ref = self
3310 .matched_driver
3311 .get_or_insert_with(|| fidl::new_empty!(CompositeDriverMatch, D));
3312 fidl::decode!(
3313 CompositeDriverMatch,
3314 D,
3315 val_ref,
3316 decoder,
3317 inner_offset,
3318 inner_depth
3319 )?;
3320 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3321 {
3322 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3323 }
3324 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3325 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3326 }
3327 }
3328
3329 next_offset += envelope_size;
3330
3331 while next_offset < end_offset {
3333 _next_ordinal_to_read += 1;
3334 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3335 next_offset += envelope_size;
3336 }
3337
3338 Ok(())
3339 }
3340 }
3341
3342 impl CompositeNodeSpec {
3343 #[inline(always)]
3344 fn max_ordinal_present(&self) -> u64 {
3345 if let Some(_) = self.parents2 {
3346 return 3;
3347 }
3348 if let Some(_) = self.parents {
3349 return 2;
3350 }
3351 if let Some(_) = self.name {
3352 return 1;
3353 }
3354 0
3355 }
3356 }
3357
3358 impl fidl::encoding::ValueTypeMarker for CompositeNodeSpec {
3359 type Borrowed<'a> = &'a Self;
3360 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3361 value
3362 }
3363 }
3364
3365 unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpec {
3366 type Owned = Self;
3367
3368 #[inline(always)]
3369 fn inline_align(_context: fidl::encoding::Context) -> usize {
3370 8
3371 }
3372
3373 #[inline(always)]
3374 fn inline_size(_context: fidl::encoding::Context) -> usize {
3375 16
3376 }
3377 }
3378
3379 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeNodeSpec, D>
3380 for &CompositeNodeSpec
3381 {
3382 unsafe fn encode(
3383 self,
3384 encoder: &mut fidl::encoding::Encoder<'_, D>,
3385 offset: usize,
3386 mut depth: fidl::encoding::Depth,
3387 ) -> fidl::Result<()> {
3388 encoder.debug_check_bounds::<CompositeNodeSpec>(offset);
3389 let max_ordinal: u64 = self.max_ordinal_present();
3391 encoder.write_num(max_ordinal, offset);
3392 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3393 if max_ordinal == 0 {
3395 return Ok(());
3396 }
3397 depth.increment()?;
3398 let envelope_size = 8;
3399 let bytes_len = max_ordinal as usize * envelope_size;
3400 #[allow(unused_variables)]
3401 let offset = encoder.out_of_line_offset(bytes_len);
3402 let mut _prev_end_offset: usize = 0;
3403 if 1 > max_ordinal {
3404 return Ok(());
3405 }
3406
3407 let cur_offset: usize = (1 - 1) * envelope_size;
3410
3411 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3413
3414 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3419 self.name.as_ref().map(
3420 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3421 ),
3422 encoder,
3423 offset + cur_offset,
3424 depth,
3425 )?;
3426
3427 _prev_end_offset = cur_offset + envelope_size;
3428 if 2 > max_ordinal {
3429 return Ok(());
3430 }
3431
3432 let cur_offset: usize = (2 - 1) * envelope_size;
3435
3436 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3438
3439 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ParentSpec>, D>(
3444 self.parents.as_ref().map(<fidl::encoding::UnboundedVector<ParentSpec> as fidl::encoding::ValueTypeMarker>::borrow),
3445 encoder, offset + cur_offset, depth
3446 )?;
3447
3448 _prev_end_offset = cur_offset + envelope_size;
3449 if 3 > max_ordinal {
3450 return Ok(());
3451 }
3452
3453 let cur_offset: usize = (3 - 1) * envelope_size;
3456
3457 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3459
3460 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ParentSpec2>, D>(
3465 self.parents2.as_ref().map(<fidl::encoding::UnboundedVector<ParentSpec2> as fidl::encoding::ValueTypeMarker>::borrow),
3466 encoder, offset + cur_offset, depth
3467 )?;
3468
3469 _prev_end_offset = cur_offset + envelope_size;
3470
3471 Ok(())
3472 }
3473 }
3474
3475 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeNodeSpec {
3476 #[inline(always)]
3477 fn new_empty() -> Self {
3478 Self::default()
3479 }
3480
3481 unsafe fn decode(
3482 &mut self,
3483 decoder: &mut fidl::encoding::Decoder<'_, D>,
3484 offset: usize,
3485 mut depth: fidl::encoding::Depth,
3486 ) -> fidl::Result<()> {
3487 decoder.debug_check_bounds::<Self>(offset);
3488 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3489 None => return Err(fidl::Error::NotNullable),
3490 Some(len) => len,
3491 };
3492 if len == 0 {
3494 return Ok(());
3495 };
3496 depth.increment()?;
3497 let envelope_size = 8;
3498 let bytes_len = len * envelope_size;
3499 let offset = decoder.out_of_line_offset(bytes_len)?;
3500 let mut _next_ordinal_to_read = 0;
3502 let mut next_offset = offset;
3503 let end_offset = offset + bytes_len;
3504 _next_ordinal_to_read += 1;
3505 if next_offset >= end_offset {
3506 return Ok(());
3507 }
3508
3509 while _next_ordinal_to_read < 1 {
3511 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3512 _next_ordinal_to_read += 1;
3513 next_offset += envelope_size;
3514 }
3515
3516 let next_out_of_line = decoder.next_out_of_line();
3517 let handles_before = decoder.remaining_handles();
3518 if let Some((inlined, num_bytes, num_handles)) =
3519 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3520 {
3521 let member_inline_size =
3522 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
3523 decoder.context,
3524 );
3525 if inlined != (member_inline_size <= 4) {
3526 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3527 }
3528 let inner_offset;
3529 let mut inner_depth = depth.clone();
3530 if inlined {
3531 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3532 inner_offset = next_offset;
3533 } else {
3534 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3535 inner_depth.increment()?;
3536 }
3537 let val_ref = self
3538 .name
3539 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3540 fidl::decode!(
3541 fidl::encoding::UnboundedString,
3542 D,
3543 val_ref,
3544 decoder,
3545 inner_offset,
3546 inner_depth
3547 )?;
3548 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3549 {
3550 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3551 }
3552 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3553 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3554 }
3555 }
3556
3557 next_offset += envelope_size;
3558 _next_ordinal_to_read += 1;
3559 if next_offset >= end_offset {
3560 return Ok(());
3561 }
3562
3563 while _next_ordinal_to_read < 2 {
3565 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3566 _next_ordinal_to_read += 1;
3567 next_offset += envelope_size;
3568 }
3569
3570 let next_out_of_line = decoder.next_out_of_line();
3571 let handles_before = decoder.remaining_handles();
3572 if let Some((inlined, num_bytes, num_handles)) =
3573 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3574 {
3575 let member_inline_size = <fidl::encoding::UnboundedVector<ParentSpec> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3576 if inlined != (member_inline_size <= 4) {
3577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3578 }
3579 let inner_offset;
3580 let mut inner_depth = depth.clone();
3581 if inlined {
3582 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3583 inner_offset = next_offset;
3584 } else {
3585 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3586 inner_depth.increment()?;
3587 }
3588 let val_ref = self.parents.get_or_insert_with(|| {
3589 fidl::new_empty!(fidl::encoding::UnboundedVector<ParentSpec>, D)
3590 });
3591 fidl::decode!(
3592 fidl::encoding::UnboundedVector<ParentSpec>,
3593 D,
3594 val_ref,
3595 decoder,
3596 inner_offset,
3597 inner_depth
3598 )?;
3599 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3600 {
3601 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3602 }
3603 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3604 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3605 }
3606 }
3607
3608 next_offset += envelope_size;
3609 _next_ordinal_to_read += 1;
3610 if next_offset >= end_offset {
3611 return Ok(());
3612 }
3613
3614 while _next_ordinal_to_read < 3 {
3616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3617 _next_ordinal_to_read += 1;
3618 next_offset += envelope_size;
3619 }
3620
3621 let next_out_of_line = decoder.next_out_of_line();
3622 let handles_before = decoder.remaining_handles();
3623 if let Some((inlined, num_bytes, num_handles)) =
3624 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3625 {
3626 let member_inline_size = <fidl::encoding::UnboundedVector<ParentSpec2> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3627 if inlined != (member_inline_size <= 4) {
3628 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3629 }
3630 let inner_offset;
3631 let mut inner_depth = depth.clone();
3632 if inlined {
3633 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3634 inner_offset = next_offset;
3635 } else {
3636 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3637 inner_depth.increment()?;
3638 }
3639 let val_ref = self.parents2.get_or_insert_with(|| {
3640 fidl::new_empty!(fidl::encoding::UnboundedVector<ParentSpec2>, D)
3641 });
3642 fidl::decode!(
3643 fidl::encoding::UnboundedVector<ParentSpec2>,
3644 D,
3645 val_ref,
3646 decoder,
3647 inner_offset,
3648 inner_depth
3649 )?;
3650 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3651 {
3652 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3653 }
3654 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3655 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3656 }
3657 }
3658
3659 next_offset += envelope_size;
3660
3661 while next_offset < end_offset {
3663 _next_ordinal_to_read += 1;
3664 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3665 next_offset += envelope_size;
3666 }
3667
3668 Ok(())
3669 }
3670 }
3671
3672 impl CompositeParent {
3673 #[inline(always)]
3674 fn max_ordinal_present(&self) -> u64 {
3675 if let Some(_) = self.index {
3676 return 2;
3677 }
3678 if let Some(_) = self.composite {
3679 return 1;
3680 }
3681 0
3682 }
3683 }
3684
3685 impl fidl::encoding::ValueTypeMarker for CompositeParent {
3686 type Borrowed<'a> = &'a Self;
3687 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3688 value
3689 }
3690 }
3691
3692 unsafe impl fidl::encoding::TypeMarker for CompositeParent {
3693 type Owned = Self;
3694
3695 #[inline(always)]
3696 fn inline_align(_context: fidl::encoding::Context) -> usize {
3697 8
3698 }
3699
3700 #[inline(always)]
3701 fn inline_size(_context: fidl::encoding::Context) -> usize {
3702 16
3703 }
3704 }
3705
3706 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeParent, D>
3707 for &CompositeParent
3708 {
3709 unsafe fn encode(
3710 self,
3711 encoder: &mut fidl::encoding::Encoder<'_, D>,
3712 offset: usize,
3713 mut depth: fidl::encoding::Depth,
3714 ) -> fidl::Result<()> {
3715 encoder.debug_check_bounds::<CompositeParent>(offset);
3716 let max_ordinal: u64 = self.max_ordinal_present();
3718 encoder.write_num(max_ordinal, offset);
3719 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3720 if max_ordinal == 0 {
3722 return Ok(());
3723 }
3724 depth.increment()?;
3725 let envelope_size = 8;
3726 let bytes_len = max_ordinal as usize * envelope_size;
3727 #[allow(unused_variables)]
3728 let offset = encoder.out_of_line_offset(bytes_len);
3729 let mut _prev_end_offset: usize = 0;
3730 if 1 > max_ordinal {
3731 return Ok(());
3732 }
3733
3734 let cur_offset: usize = (1 - 1) * envelope_size;
3737
3738 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3740
3741 fidl::encoding::encode_in_envelope_optional::<CompositeInfo, D>(
3746 self.composite
3747 .as_ref()
3748 .map(<CompositeInfo as fidl::encoding::ValueTypeMarker>::borrow),
3749 encoder,
3750 offset + cur_offset,
3751 depth,
3752 )?;
3753
3754 _prev_end_offset = cur_offset + envelope_size;
3755 if 2 > max_ordinal {
3756 return Ok(());
3757 }
3758
3759 let cur_offset: usize = (2 - 1) * envelope_size;
3762
3763 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3765
3766 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3771 self.index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3772 encoder,
3773 offset + cur_offset,
3774 depth,
3775 )?;
3776
3777 _prev_end_offset = cur_offset + envelope_size;
3778
3779 Ok(())
3780 }
3781 }
3782
3783 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeParent {
3784 #[inline(always)]
3785 fn new_empty() -> Self {
3786 Self::default()
3787 }
3788
3789 unsafe fn decode(
3790 &mut self,
3791 decoder: &mut fidl::encoding::Decoder<'_, D>,
3792 offset: usize,
3793 mut depth: fidl::encoding::Depth,
3794 ) -> fidl::Result<()> {
3795 decoder.debug_check_bounds::<Self>(offset);
3796 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3797 None => return Err(fidl::Error::NotNullable),
3798 Some(len) => len,
3799 };
3800 if len == 0 {
3802 return Ok(());
3803 };
3804 depth.increment()?;
3805 let envelope_size = 8;
3806 let bytes_len = len * envelope_size;
3807 let offset = decoder.out_of_line_offset(bytes_len)?;
3808 let mut _next_ordinal_to_read = 0;
3810 let mut next_offset = offset;
3811 let end_offset = offset + bytes_len;
3812 _next_ordinal_to_read += 1;
3813 if next_offset >= end_offset {
3814 return Ok(());
3815 }
3816
3817 while _next_ordinal_to_read < 1 {
3819 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3820 _next_ordinal_to_read += 1;
3821 next_offset += envelope_size;
3822 }
3823
3824 let next_out_of_line = decoder.next_out_of_line();
3825 let handles_before = decoder.remaining_handles();
3826 if let Some((inlined, num_bytes, num_handles)) =
3827 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3828 {
3829 let member_inline_size =
3830 <CompositeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3831 if inlined != (member_inline_size <= 4) {
3832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3833 }
3834 let inner_offset;
3835 let mut inner_depth = depth.clone();
3836 if inlined {
3837 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3838 inner_offset = next_offset;
3839 } else {
3840 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3841 inner_depth.increment()?;
3842 }
3843 let val_ref =
3844 self.composite.get_or_insert_with(|| fidl::new_empty!(CompositeInfo, D));
3845 fidl::decode!(CompositeInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3846 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3847 {
3848 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3849 }
3850 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3851 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3852 }
3853 }
3854
3855 next_offset += envelope_size;
3856 _next_ordinal_to_read += 1;
3857 if next_offset >= end_offset {
3858 return Ok(());
3859 }
3860
3861 while _next_ordinal_to_read < 2 {
3863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3864 _next_ordinal_to_read += 1;
3865 next_offset += envelope_size;
3866 }
3867
3868 let next_out_of_line = decoder.next_out_of_line();
3869 let handles_before = decoder.remaining_handles();
3870 if let Some((inlined, num_bytes, num_handles)) =
3871 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3872 {
3873 let member_inline_size =
3874 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3875 if inlined != (member_inline_size <= 4) {
3876 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3877 }
3878 let inner_offset;
3879 let mut inner_depth = depth.clone();
3880 if inlined {
3881 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3882 inner_offset = next_offset;
3883 } else {
3884 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3885 inner_depth.increment()?;
3886 }
3887 let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u32, D));
3888 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3889 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3890 {
3891 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3892 }
3893 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3894 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3895 }
3896 }
3897
3898 next_offset += envelope_size;
3899
3900 while next_offset < end_offset {
3902 _next_ordinal_to_read += 1;
3903 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3904 next_offset += envelope_size;
3905 }
3906
3907 Ok(())
3908 }
3909 }
3910
3911 impl DeviceCategory {
3912 #[inline(always)]
3913 fn max_ordinal_present(&self) -> u64 {
3914 if let Some(_) = self.subcategory {
3915 return 2;
3916 }
3917 if let Some(_) = self.category {
3918 return 1;
3919 }
3920 0
3921 }
3922 }
3923
3924 impl fidl::encoding::ValueTypeMarker for DeviceCategory {
3925 type Borrowed<'a> = &'a Self;
3926 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3927 value
3928 }
3929 }
3930
3931 unsafe impl fidl::encoding::TypeMarker for DeviceCategory {
3932 type Owned = Self;
3933
3934 #[inline(always)]
3935 fn inline_align(_context: fidl::encoding::Context) -> usize {
3936 8
3937 }
3938
3939 #[inline(always)]
3940 fn inline_size(_context: fidl::encoding::Context) -> usize {
3941 16
3942 }
3943 }
3944
3945 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceCategory, D>
3946 for &DeviceCategory
3947 {
3948 unsafe fn encode(
3949 self,
3950 encoder: &mut fidl::encoding::Encoder<'_, D>,
3951 offset: usize,
3952 mut depth: fidl::encoding::Depth,
3953 ) -> fidl::Result<()> {
3954 encoder.debug_check_bounds::<DeviceCategory>(offset);
3955 let max_ordinal: u64 = self.max_ordinal_present();
3957 encoder.write_num(max_ordinal, offset);
3958 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3959 if max_ordinal == 0 {
3961 return Ok(());
3962 }
3963 depth.increment()?;
3964 let envelope_size = 8;
3965 let bytes_len = max_ordinal as usize * envelope_size;
3966 #[allow(unused_variables)]
3967 let offset = encoder.out_of_line_offset(bytes_len);
3968 let mut _prev_end_offset: usize = 0;
3969 if 1 > max_ordinal {
3970 return Ok(());
3971 }
3972
3973 let cur_offset: usize = (1 - 1) * envelope_size;
3976
3977 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3979
3980 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3985 self.category.as_ref().map(
3986 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3987 ),
3988 encoder,
3989 offset + cur_offset,
3990 depth,
3991 )?;
3992
3993 _prev_end_offset = cur_offset + envelope_size;
3994 if 2 > max_ordinal {
3995 return Ok(());
3996 }
3997
3998 let cur_offset: usize = (2 - 1) * envelope_size;
4001
4002 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4004
4005 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4010 self.subcategory.as_ref().map(
4011 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4012 ),
4013 encoder,
4014 offset + cur_offset,
4015 depth,
4016 )?;
4017
4018 _prev_end_offset = cur_offset + envelope_size;
4019
4020 Ok(())
4021 }
4022 }
4023
4024 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceCategory {
4025 #[inline(always)]
4026 fn new_empty() -> Self {
4027 Self::default()
4028 }
4029
4030 unsafe fn decode(
4031 &mut self,
4032 decoder: &mut fidl::encoding::Decoder<'_, D>,
4033 offset: usize,
4034 mut depth: fidl::encoding::Depth,
4035 ) -> fidl::Result<()> {
4036 decoder.debug_check_bounds::<Self>(offset);
4037 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4038 None => return Err(fidl::Error::NotNullable),
4039 Some(len) => len,
4040 };
4041 if len == 0 {
4043 return Ok(());
4044 };
4045 depth.increment()?;
4046 let envelope_size = 8;
4047 let bytes_len = len * envelope_size;
4048 let offset = decoder.out_of_line_offset(bytes_len)?;
4049 let mut _next_ordinal_to_read = 0;
4051 let mut next_offset = offset;
4052 let end_offset = offset + bytes_len;
4053 _next_ordinal_to_read += 1;
4054 if next_offset >= end_offset {
4055 return Ok(());
4056 }
4057
4058 while _next_ordinal_to_read < 1 {
4060 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4061 _next_ordinal_to_read += 1;
4062 next_offset += envelope_size;
4063 }
4064
4065 let next_out_of_line = decoder.next_out_of_line();
4066 let handles_before = decoder.remaining_handles();
4067 if let Some((inlined, num_bytes, num_handles)) =
4068 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4069 {
4070 let member_inline_size =
4071 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4072 decoder.context,
4073 );
4074 if inlined != (member_inline_size <= 4) {
4075 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4076 }
4077 let inner_offset;
4078 let mut inner_depth = depth.clone();
4079 if inlined {
4080 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4081 inner_offset = next_offset;
4082 } else {
4083 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4084 inner_depth.increment()?;
4085 }
4086 let val_ref = self
4087 .category
4088 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4089 fidl::decode!(
4090 fidl::encoding::UnboundedString,
4091 D,
4092 val_ref,
4093 decoder,
4094 inner_offset,
4095 inner_depth
4096 )?;
4097 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4098 {
4099 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4100 }
4101 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4102 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4103 }
4104 }
4105
4106 next_offset += envelope_size;
4107 _next_ordinal_to_read += 1;
4108 if next_offset >= end_offset {
4109 return Ok(());
4110 }
4111
4112 while _next_ordinal_to_read < 2 {
4114 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4115 _next_ordinal_to_read += 1;
4116 next_offset += envelope_size;
4117 }
4118
4119 let next_out_of_line = decoder.next_out_of_line();
4120 let handles_before = decoder.remaining_handles();
4121 if let Some((inlined, num_bytes, num_handles)) =
4122 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4123 {
4124 let member_inline_size =
4125 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4126 decoder.context,
4127 );
4128 if inlined != (member_inline_size <= 4) {
4129 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4130 }
4131 let inner_offset;
4132 let mut inner_depth = depth.clone();
4133 if inlined {
4134 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4135 inner_offset = next_offset;
4136 } else {
4137 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4138 inner_depth.increment()?;
4139 }
4140 let val_ref = self
4141 .subcategory
4142 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4143 fidl::decode!(
4144 fidl::encoding::UnboundedString,
4145 D,
4146 val_ref,
4147 decoder,
4148 inner_offset,
4149 inner_depth
4150 )?;
4151 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4152 {
4153 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4154 }
4155 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4156 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4157 }
4158 }
4159
4160 next_offset += envelope_size;
4161
4162 while next_offset < end_offset {
4164 _next_ordinal_to_read += 1;
4165 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4166 next_offset += envelope_size;
4167 }
4168
4169 Ok(())
4170 }
4171 }
4172
4173 impl DriverInfo {
4174 #[inline(always)]
4175 fn max_ordinal_present(&self) -> u64 {
4176 if let Some(_) = self.is_disabled {
4177 return 9;
4178 }
4179 if let Some(_) = self.driver_framework_version {
4180 return 8;
4181 }
4182 if let Some(_) = self.bind_rules_bytecode {
4183 return 7;
4184 }
4185 if let Some(_) = self.device_categories {
4186 return 6;
4187 }
4188 if let Some(_) = self.is_fallback {
4189 return 5;
4190 }
4191 if let Some(_) = self.package_type {
4192 return 4;
4193 }
4194 if let Some(_) = self.colocate {
4195 return 3;
4196 }
4197 if let Some(_) = self.name {
4198 return 2;
4199 }
4200 if let Some(_) = self.url {
4201 return 1;
4202 }
4203 0
4204 }
4205 }
4206
4207 impl fidl::encoding::ValueTypeMarker for DriverInfo {
4208 type Borrowed<'a> = &'a Self;
4209 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4210 value
4211 }
4212 }
4213
4214 unsafe impl fidl::encoding::TypeMarker for DriverInfo {
4215 type Owned = Self;
4216
4217 #[inline(always)]
4218 fn inline_align(_context: fidl::encoding::Context) -> usize {
4219 8
4220 }
4221
4222 #[inline(always)]
4223 fn inline_size(_context: fidl::encoding::Context) -> usize {
4224 16
4225 }
4226 }
4227
4228 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DriverInfo, D>
4229 for &DriverInfo
4230 {
4231 unsafe fn encode(
4232 self,
4233 encoder: &mut fidl::encoding::Encoder<'_, D>,
4234 offset: usize,
4235 mut depth: fidl::encoding::Depth,
4236 ) -> fidl::Result<()> {
4237 encoder.debug_check_bounds::<DriverInfo>(offset);
4238 let max_ordinal: u64 = self.max_ordinal_present();
4240 encoder.write_num(max_ordinal, offset);
4241 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4242 if max_ordinal == 0 {
4244 return Ok(());
4245 }
4246 depth.increment()?;
4247 let envelope_size = 8;
4248 let bytes_len = max_ordinal as usize * envelope_size;
4249 #[allow(unused_variables)]
4250 let offset = encoder.out_of_line_offset(bytes_len);
4251 let mut _prev_end_offset: usize = 0;
4252 if 1 > max_ordinal {
4253 return Ok(());
4254 }
4255
4256 let cur_offset: usize = (1 - 1) * envelope_size;
4259
4260 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4262
4263 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4268 self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4269 encoder, offset + cur_offset, depth
4270 )?;
4271
4272 _prev_end_offset = cur_offset + envelope_size;
4273 if 2 > max_ordinal {
4274 return Ok(());
4275 }
4276
4277 let cur_offset: usize = (2 - 1) * envelope_size;
4280
4281 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4283
4284 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4289 self.name.as_ref().map(
4290 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4291 ),
4292 encoder,
4293 offset + cur_offset,
4294 depth,
4295 )?;
4296
4297 _prev_end_offset = cur_offset + envelope_size;
4298 if 3 > max_ordinal {
4299 return Ok(());
4300 }
4301
4302 let cur_offset: usize = (3 - 1) * envelope_size;
4305
4306 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4308
4309 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4314 self.colocate.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4315 encoder,
4316 offset + cur_offset,
4317 depth,
4318 )?;
4319
4320 _prev_end_offset = cur_offset + envelope_size;
4321 if 4 > max_ordinal {
4322 return Ok(());
4323 }
4324
4325 let cur_offset: usize = (4 - 1) * envelope_size;
4328
4329 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4331
4332 fidl::encoding::encode_in_envelope_optional::<DriverPackageType, D>(
4337 self.package_type
4338 .as_ref()
4339 .map(<DriverPackageType as fidl::encoding::ValueTypeMarker>::borrow),
4340 encoder,
4341 offset + cur_offset,
4342 depth,
4343 )?;
4344
4345 _prev_end_offset = cur_offset + envelope_size;
4346 if 5 > max_ordinal {
4347 return Ok(());
4348 }
4349
4350 let cur_offset: usize = (5 - 1) * envelope_size;
4353
4354 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4356
4357 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4362 self.is_fallback.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4363 encoder,
4364 offset + cur_offset,
4365 depth,
4366 )?;
4367
4368 _prev_end_offset = cur_offset + envelope_size;
4369 if 6 > max_ordinal {
4370 return Ok(());
4371 }
4372
4373 let cur_offset: usize = (6 - 1) * envelope_size;
4376
4377 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4379
4380 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<DeviceCategory>, D>(
4385 self.device_categories.as_ref().map(<fidl::encoding::UnboundedVector<DeviceCategory> as fidl::encoding::ValueTypeMarker>::borrow),
4386 encoder, offset + cur_offset, depth
4387 )?;
4388
4389 _prev_end_offset = cur_offset + envelope_size;
4390 if 7 > max_ordinal {
4391 return Ok(());
4392 }
4393
4394 let cur_offset: usize = (7 - 1) * envelope_size;
4397
4398 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4400
4401 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4406 self.bind_rules_bytecode.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4407 encoder, offset + cur_offset, depth
4408 )?;
4409
4410 _prev_end_offset = cur_offset + envelope_size;
4411 if 8 > max_ordinal {
4412 return Ok(());
4413 }
4414
4415 let cur_offset: usize = (8 - 1) * envelope_size;
4418
4419 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4421
4422 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4427 self.driver_framework_version
4428 .as_ref()
4429 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4430 encoder,
4431 offset + cur_offset,
4432 depth,
4433 )?;
4434
4435 _prev_end_offset = cur_offset + envelope_size;
4436 if 9 > max_ordinal {
4437 return Ok(());
4438 }
4439
4440 let cur_offset: usize = (9 - 1) * envelope_size;
4443
4444 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4446
4447 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4452 self.is_disabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4453 encoder,
4454 offset + cur_offset,
4455 depth,
4456 )?;
4457
4458 _prev_end_offset = cur_offset + envelope_size;
4459
4460 Ok(())
4461 }
4462 }
4463
4464 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverInfo {
4465 #[inline(always)]
4466 fn new_empty() -> Self {
4467 Self::default()
4468 }
4469
4470 unsafe fn decode(
4471 &mut self,
4472 decoder: &mut fidl::encoding::Decoder<'_, D>,
4473 offset: usize,
4474 mut depth: fidl::encoding::Depth,
4475 ) -> fidl::Result<()> {
4476 decoder.debug_check_bounds::<Self>(offset);
4477 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4478 None => return Err(fidl::Error::NotNullable),
4479 Some(len) => len,
4480 };
4481 if len == 0 {
4483 return Ok(());
4484 };
4485 depth.increment()?;
4486 let envelope_size = 8;
4487 let bytes_len = len * envelope_size;
4488 let offset = decoder.out_of_line_offset(bytes_len)?;
4489 let mut _next_ordinal_to_read = 0;
4491 let mut next_offset = offset;
4492 let end_offset = offset + bytes_len;
4493 _next_ordinal_to_read += 1;
4494 if next_offset >= end_offset {
4495 return Ok(());
4496 }
4497
4498 while _next_ordinal_to_read < 1 {
4500 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4501 _next_ordinal_to_read += 1;
4502 next_offset += envelope_size;
4503 }
4504
4505 let next_out_of_line = decoder.next_out_of_line();
4506 let handles_before = decoder.remaining_handles();
4507 if let Some((inlined, num_bytes, num_handles)) =
4508 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4509 {
4510 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4511 if inlined != (member_inline_size <= 4) {
4512 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4513 }
4514 let inner_offset;
4515 let mut inner_depth = depth.clone();
4516 if inlined {
4517 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4518 inner_offset = next_offset;
4519 } else {
4520 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4521 inner_depth.increment()?;
4522 }
4523 let val_ref = self.url.get_or_insert_with(|| {
4524 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4525 });
4526 fidl::decode!(
4527 fidl::encoding::BoundedString<4096>,
4528 D,
4529 val_ref,
4530 decoder,
4531 inner_offset,
4532 inner_depth
4533 )?;
4534 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4535 {
4536 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4537 }
4538 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4539 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4540 }
4541 }
4542
4543 next_offset += envelope_size;
4544 _next_ordinal_to_read += 1;
4545 if next_offset >= end_offset {
4546 return Ok(());
4547 }
4548
4549 while _next_ordinal_to_read < 2 {
4551 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4552 _next_ordinal_to_read += 1;
4553 next_offset += envelope_size;
4554 }
4555
4556 let next_out_of_line = decoder.next_out_of_line();
4557 let handles_before = decoder.remaining_handles();
4558 if let Some((inlined, num_bytes, num_handles)) =
4559 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4560 {
4561 let member_inline_size =
4562 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4563 decoder.context,
4564 );
4565 if inlined != (member_inline_size <= 4) {
4566 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4567 }
4568 let inner_offset;
4569 let mut inner_depth = depth.clone();
4570 if inlined {
4571 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4572 inner_offset = next_offset;
4573 } else {
4574 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4575 inner_depth.increment()?;
4576 }
4577 let val_ref = self
4578 .name
4579 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4580 fidl::decode!(
4581 fidl::encoding::UnboundedString,
4582 D,
4583 val_ref,
4584 decoder,
4585 inner_offset,
4586 inner_depth
4587 )?;
4588 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4589 {
4590 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4591 }
4592 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4593 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4594 }
4595 }
4596
4597 next_offset += envelope_size;
4598 _next_ordinal_to_read += 1;
4599 if next_offset >= end_offset {
4600 return Ok(());
4601 }
4602
4603 while _next_ordinal_to_read < 3 {
4605 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4606 _next_ordinal_to_read += 1;
4607 next_offset += envelope_size;
4608 }
4609
4610 let next_out_of_line = decoder.next_out_of_line();
4611 let handles_before = decoder.remaining_handles();
4612 if let Some((inlined, num_bytes, num_handles)) =
4613 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4614 {
4615 let member_inline_size =
4616 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4617 if inlined != (member_inline_size <= 4) {
4618 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4619 }
4620 let inner_offset;
4621 let mut inner_depth = depth.clone();
4622 if inlined {
4623 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4624 inner_offset = next_offset;
4625 } else {
4626 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4627 inner_depth.increment()?;
4628 }
4629 let val_ref = self.colocate.get_or_insert_with(|| fidl::new_empty!(bool, D));
4630 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4631 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4632 {
4633 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4634 }
4635 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4636 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4637 }
4638 }
4639
4640 next_offset += envelope_size;
4641 _next_ordinal_to_read += 1;
4642 if next_offset >= end_offset {
4643 return Ok(());
4644 }
4645
4646 while _next_ordinal_to_read < 4 {
4648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4649 _next_ordinal_to_read += 1;
4650 next_offset += envelope_size;
4651 }
4652
4653 let next_out_of_line = decoder.next_out_of_line();
4654 let handles_before = decoder.remaining_handles();
4655 if let Some((inlined, num_bytes, num_handles)) =
4656 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4657 {
4658 let member_inline_size =
4659 <DriverPackageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4660 if inlined != (member_inline_size <= 4) {
4661 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4662 }
4663 let inner_offset;
4664 let mut inner_depth = depth.clone();
4665 if inlined {
4666 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4667 inner_offset = next_offset;
4668 } else {
4669 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4670 inner_depth.increment()?;
4671 }
4672 let val_ref =
4673 self.package_type.get_or_insert_with(|| fidl::new_empty!(DriverPackageType, D));
4674 fidl::decode!(DriverPackageType, D, val_ref, decoder, inner_offset, inner_depth)?;
4675 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4676 {
4677 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4678 }
4679 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4680 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4681 }
4682 }
4683
4684 next_offset += envelope_size;
4685 _next_ordinal_to_read += 1;
4686 if next_offset >= end_offset {
4687 return Ok(());
4688 }
4689
4690 while _next_ordinal_to_read < 5 {
4692 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4693 _next_ordinal_to_read += 1;
4694 next_offset += envelope_size;
4695 }
4696
4697 let next_out_of_line = decoder.next_out_of_line();
4698 let handles_before = decoder.remaining_handles();
4699 if let Some((inlined, num_bytes, num_handles)) =
4700 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4701 {
4702 let member_inline_size =
4703 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4704 if inlined != (member_inline_size <= 4) {
4705 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4706 }
4707 let inner_offset;
4708 let mut inner_depth = depth.clone();
4709 if inlined {
4710 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4711 inner_offset = next_offset;
4712 } else {
4713 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4714 inner_depth.increment()?;
4715 }
4716 let val_ref = self.is_fallback.get_or_insert_with(|| fidl::new_empty!(bool, D));
4717 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4718 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4719 {
4720 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4721 }
4722 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4723 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4724 }
4725 }
4726
4727 next_offset += envelope_size;
4728 _next_ordinal_to_read += 1;
4729 if next_offset >= end_offset {
4730 return Ok(());
4731 }
4732
4733 while _next_ordinal_to_read < 6 {
4735 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4736 _next_ordinal_to_read += 1;
4737 next_offset += envelope_size;
4738 }
4739
4740 let next_out_of_line = decoder.next_out_of_line();
4741 let handles_before = decoder.remaining_handles();
4742 if let Some((inlined, num_bytes, num_handles)) =
4743 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4744 {
4745 let member_inline_size = <fidl::encoding::UnboundedVector<DeviceCategory> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4746 if inlined != (member_inline_size <= 4) {
4747 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4748 }
4749 let inner_offset;
4750 let mut inner_depth = depth.clone();
4751 if inlined {
4752 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4753 inner_offset = next_offset;
4754 } else {
4755 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4756 inner_depth.increment()?;
4757 }
4758 let val_ref = self.device_categories.get_or_insert_with(|| {
4759 fidl::new_empty!(fidl::encoding::UnboundedVector<DeviceCategory>, D)
4760 });
4761 fidl::decode!(
4762 fidl::encoding::UnboundedVector<DeviceCategory>,
4763 D,
4764 val_ref,
4765 decoder,
4766 inner_offset,
4767 inner_depth
4768 )?;
4769 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4770 {
4771 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4772 }
4773 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4774 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4775 }
4776 }
4777
4778 next_offset += envelope_size;
4779 _next_ordinal_to_read += 1;
4780 if next_offset >= end_offset {
4781 return Ok(());
4782 }
4783
4784 while _next_ordinal_to_read < 7 {
4786 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4787 _next_ordinal_to_read += 1;
4788 next_offset += envelope_size;
4789 }
4790
4791 let next_out_of_line = decoder.next_out_of_line();
4792 let handles_before = decoder.remaining_handles();
4793 if let Some((inlined, num_bytes, num_handles)) =
4794 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4795 {
4796 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4797 if inlined != (member_inline_size <= 4) {
4798 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4799 }
4800 let inner_offset;
4801 let mut inner_depth = depth.clone();
4802 if inlined {
4803 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4804 inner_offset = next_offset;
4805 } else {
4806 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4807 inner_depth.increment()?;
4808 }
4809 let val_ref = self.bind_rules_bytecode.get_or_insert_with(|| {
4810 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
4811 });
4812 fidl::decode!(
4813 fidl::encoding::UnboundedVector<u8>,
4814 D,
4815 val_ref,
4816 decoder,
4817 inner_offset,
4818 inner_depth
4819 )?;
4820 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4821 {
4822 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4823 }
4824 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4825 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4826 }
4827 }
4828
4829 next_offset += envelope_size;
4830 _next_ordinal_to_read += 1;
4831 if next_offset >= end_offset {
4832 return Ok(());
4833 }
4834
4835 while _next_ordinal_to_read < 8 {
4837 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4838 _next_ordinal_to_read += 1;
4839 next_offset += envelope_size;
4840 }
4841
4842 let next_out_of_line = decoder.next_out_of_line();
4843 let handles_before = decoder.remaining_handles();
4844 if let Some((inlined, num_bytes, num_handles)) =
4845 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4846 {
4847 let member_inline_size =
4848 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4849 if inlined != (member_inline_size <= 4) {
4850 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4851 }
4852 let inner_offset;
4853 let mut inner_depth = depth.clone();
4854 if inlined {
4855 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4856 inner_offset = next_offset;
4857 } else {
4858 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4859 inner_depth.increment()?;
4860 }
4861 let val_ref =
4862 self.driver_framework_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4863 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4864 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4865 {
4866 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4867 }
4868 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4869 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4870 }
4871 }
4872
4873 next_offset += envelope_size;
4874 _next_ordinal_to_read += 1;
4875 if next_offset >= end_offset {
4876 return Ok(());
4877 }
4878
4879 while _next_ordinal_to_read < 9 {
4881 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4882 _next_ordinal_to_read += 1;
4883 next_offset += envelope_size;
4884 }
4885
4886 let next_out_of_line = decoder.next_out_of_line();
4887 let handles_before = decoder.remaining_handles();
4888 if let Some((inlined, num_bytes, num_handles)) =
4889 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4890 {
4891 let member_inline_size =
4892 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4893 if inlined != (member_inline_size <= 4) {
4894 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4895 }
4896 let inner_offset;
4897 let mut inner_depth = depth.clone();
4898 if inlined {
4899 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4900 inner_offset = next_offset;
4901 } else {
4902 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4903 inner_depth.increment()?;
4904 }
4905 let val_ref = self.is_disabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
4906 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4907 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4908 {
4909 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4910 }
4911 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4912 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4913 }
4914 }
4915
4916 next_offset += envelope_size;
4917
4918 while next_offset < end_offset {
4920 _next_ordinal_to_read += 1;
4921 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4922 next_offset += envelope_size;
4923 }
4924
4925 Ok(())
4926 }
4927 }
4928
4929 impl NodeControllerRequestBindRequest {
4930 #[inline(always)]
4931 fn max_ordinal_present(&self) -> u64 {
4932 if let Some(_) = self.driver_url_suffix {
4933 return 2;
4934 }
4935 if let Some(_) = self.force_rebind {
4936 return 1;
4937 }
4938 0
4939 }
4940 }
4941
4942 impl fidl::encoding::ValueTypeMarker for NodeControllerRequestBindRequest {
4943 type Borrowed<'a> = &'a Self;
4944 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4945 value
4946 }
4947 }
4948
4949 unsafe impl fidl::encoding::TypeMarker for NodeControllerRequestBindRequest {
4950 type Owned = Self;
4951
4952 #[inline(always)]
4953 fn inline_align(_context: fidl::encoding::Context) -> usize {
4954 8
4955 }
4956
4957 #[inline(always)]
4958 fn inline_size(_context: fidl::encoding::Context) -> usize {
4959 16
4960 }
4961 }
4962
4963 unsafe impl<D: fidl::encoding::ResourceDialect>
4964 fidl::encoding::Encode<NodeControllerRequestBindRequest, D>
4965 for &NodeControllerRequestBindRequest
4966 {
4967 unsafe fn encode(
4968 self,
4969 encoder: &mut fidl::encoding::Encoder<'_, D>,
4970 offset: usize,
4971 mut depth: fidl::encoding::Depth,
4972 ) -> fidl::Result<()> {
4973 encoder.debug_check_bounds::<NodeControllerRequestBindRequest>(offset);
4974 let max_ordinal: u64 = self.max_ordinal_present();
4976 encoder.write_num(max_ordinal, offset);
4977 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4978 if max_ordinal == 0 {
4980 return Ok(());
4981 }
4982 depth.increment()?;
4983 let envelope_size = 8;
4984 let bytes_len = max_ordinal as usize * envelope_size;
4985 #[allow(unused_variables)]
4986 let offset = encoder.out_of_line_offset(bytes_len);
4987 let mut _prev_end_offset: usize = 0;
4988 if 1 > max_ordinal {
4989 return Ok(());
4990 }
4991
4992 let cur_offset: usize = (1 - 1) * envelope_size;
4995
4996 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4998
4999 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5004 self.force_rebind.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5005 encoder,
5006 offset + cur_offset,
5007 depth,
5008 )?;
5009
5010 _prev_end_offset = cur_offset + envelope_size;
5011 if 2 > max_ordinal {
5012 return Ok(());
5013 }
5014
5015 let cur_offset: usize = (2 - 1) * envelope_size;
5018
5019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5021
5022 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
5027 self.driver_url_suffix.as_ref().map(
5028 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
5029 ),
5030 encoder,
5031 offset + cur_offset,
5032 depth,
5033 )?;
5034
5035 _prev_end_offset = cur_offset + envelope_size;
5036
5037 Ok(())
5038 }
5039 }
5040
5041 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5042 for NodeControllerRequestBindRequest
5043 {
5044 #[inline(always)]
5045 fn new_empty() -> Self {
5046 Self::default()
5047 }
5048
5049 unsafe fn decode(
5050 &mut self,
5051 decoder: &mut fidl::encoding::Decoder<'_, D>,
5052 offset: usize,
5053 mut depth: fidl::encoding::Depth,
5054 ) -> fidl::Result<()> {
5055 decoder.debug_check_bounds::<Self>(offset);
5056 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5057 None => return Err(fidl::Error::NotNullable),
5058 Some(len) => len,
5059 };
5060 if len == 0 {
5062 return Ok(());
5063 };
5064 depth.increment()?;
5065 let envelope_size = 8;
5066 let bytes_len = len * envelope_size;
5067 let offset = decoder.out_of_line_offset(bytes_len)?;
5068 let mut _next_ordinal_to_read = 0;
5070 let mut next_offset = offset;
5071 let end_offset = offset + bytes_len;
5072 _next_ordinal_to_read += 1;
5073 if next_offset >= end_offset {
5074 return Ok(());
5075 }
5076
5077 while _next_ordinal_to_read < 1 {
5079 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5080 _next_ordinal_to_read += 1;
5081 next_offset += envelope_size;
5082 }
5083
5084 let next_out_of_line = decoder.next_out_of_line();
5085 let handles_before = decoder.remaining_handles();
5086 if let Some((inlined, num_bytes, num_handles)) =
5087 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5088 {
5089 let member_inline_size =
5090 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5091 if inlined != (member_inline_size <= 4) {
5092 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5093 }
5094 let inner_offset;
5095 let mut inner_depth = depth.clone();
5096 if inlined {
5097 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5098 inner_offset = next_offset;
5099 } else {
5100 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5101 inner_depth.increment()?;
5102 }
5103 let val_ref = self.force_rebind.get_or_insert_with(|| fidl::new_empty!(bool, D));
5104 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5105 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5106 {
5107 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5108 }
5109 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5110 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5111 }
5112 }
5113
5114 next_offset += envelope_size;
5115 _next_ordinal_to_read += 1;
5116 if next_offset >= end_offset {
5117 return Ok(());
5118 }
5119
5120 while _next_ordinal_to_read < 2 {
5122 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5123 _next_ordinal_to_read += 1;
5124 next_offset += envelope_size;
5125 }
5126
5127 let next_out_of_line = decoder.next_out_of_line();
5128 let handles_before = decoder.remaining_handles();
5129 if let Some((inlined, num_bytes, num_handles)) =
5130 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5131 {
5132 let member_inline_size =
5133 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5134 decoder.context,
5135 );
5136 if inlined != (member_inline_size <= 4) {
5137 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5138 }
5139 let inner_offset;
5140 let mut inner_depth = depth.clone();
5141 if inlined {
5142 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5143 inner_offset = next_offset;
5144 } else {
5145 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5146 inner_depth.increment()?;
5147 }
5148 let val_ref = self
5149 .driver_url_suffix
5150 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5151 fidl::decode!(
5152 fidl::encoding::UnboundedString,
5153 D,
5154 val_ref,
5155 decoder,
5156 inner_offset,
5157 inner_depth
5158 )?;
5159 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5160 {
5161 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5162 }
5163 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5164 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5165 }
5166 }
5167
5168 next_offset += envelope_size;
5169
5170 while next_offset < end_offset {
5172 _next_ordinal_to_read += 1;
5173 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5174 next_offset += envelope_size;
5175 }
5176
5177 Ok(())
5178 }
5179 }
5180
5181 impl NodeSymbol {
5182 #[inline(always)]
5183 fn max_ordinal_present(&self) -> u64 {
5184 if let Some(_) = self.module_name {
5185 return 3;
5186 }
5187 if let Some(_) = self.address {
5188 return 2;
5189 }
5190 if let Some(_) = self.name {
5191 return 1;
5192 }
5193 0
5194 }
5195 }
5196
5197 impl fidl::encoding::ValueTypeMarker for NodeSymbol {
5198 type Borrowed<'a> = &'a Self;
5199 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5200 value
5201 }
5202 }
5203
5204 unsafe impl fidl::encoding::TypeMarker for NodeSymbol {
5205 type Owned = Self;
5206
5207 #[inline(always)]
5208 fn inline_align(_context: fidl::encoding::Context) -> usize {
5209 8
5210 }
5211
5212 #[inline(always)]
5213 fn inline_size(_context: fidl::encoding::Context) -> usize {
5214 16
5215 }
5216 }
5217
5218 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSymbol, D>
5219 for &NodeSymbol
5220 {
5221 unsafe fn encode(
5222 self,
5223 encoder: &mut fidl::encoding::Encoder<'_, D>,
5224 offset: usize,
5225 mut depth: fidl::encoding::Depth,
5226 ) -> fidl::Result<()> {
5227 encoder.debug_check_bounds::<NodeSymbol>(offset);
5228 let max_ordinal: u64 = self.max_ordinal_present();
5230 encoder.write_num(max_ordinal, offset);
5231 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5232 if max_ordinal == 0 {
5234 return Ok(());
5235 }
5236 depth.increment()?;
5237 let envelope_size = 8;
5238 let bytes_len = max_ordinal as usize * envelope_size;
5239 #[allow(unused_variables)]
5240 let offset = encoder.out_of_line_offset(bytes_len);
5241 let mut _prev_end_offset: usize = 0;
5242 if 1 > max_ordinal {
5243 return Ok(());
5244 }
5245
5246 let cur_offset: usize = (1 - 1) * envelope_size;
5249
5250 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5252
5253 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
5258 self.name.as_ref().map(
5259 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
5260 ),
5261 encoder,
5262 offset + cur_offset,
5263 depth,
5264 )?;
5265
5266 _prev_end_offset = cur_offset + envelope_size;
5267 if 2 > max_ordinal {
5268 return Ok(());
5269 }
5270
5271 let cur_offset: usize = (2 - 1) * envelope_size;
5274
5275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5277
5278 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5283 self.address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5284 encoder,
5285 offset + cur_offset,
5286 depth,
5287 )?;
5288
5289 _prev_end_offset = cur_offset + envelope_size;
5290 if 3 > max_ordinal {
5291 return Ok(());
5292 }
5293
5294 let cur_offset: usize = (3 - 1) * envelope_size;
5297
5298 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5300
5301 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
5306 self.module_name.as_ref().map(
5307 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
5308 ),
5309 encoder,
5310 offset + cur_offset,
5311 depth,
5312 )?;
5313
5314 _prev_end_offset = cur_offset + envelope_size;
5315
5316 Ok(())
5317 }
5318 }
5319
5320 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSymbol {
5321 #[inline(always)]
5322 fn new_empty() -> Self {
5323 Self::default()
5324 }
5325
5326 unsafe fn decode(
5327 &mut self,
5328 decoder: &mut fidl::encoding::Decoder<'_, D>,
5329 offset: usize,
5330 mut depth: fidl::encoding::Depth,
5331 ) -> fidl::Result<()> {
5332 decoder.debug_check_bounds::<Self>(offset);
5333 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5334 None => return Err(fidl::Error::NotNullable),
5335 Some(len) => len,
5336 };
5337 if len == 0 {
5339 return Ok(());
5340 };
5341 depth.increment()?;
5342 let envelope_size = 8;
5343 let bytes_len = len * envelope_size;
5344 let offset = decoder.out_of_line_offset(bytes_len)?;
5345 let mut _next_ordinal_to_read = 0;
5347 let mut next_offset = offset;
5348 let end_offset = offset + bytes_len;
5349 _next_ordinal_to_read += 1;
5350 if next_offset >= end_offset {
5351 return Ok(());
5352 }
5353
5354 while _next_ordinal_to_read < 1 {
5356 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5357 _next_ordinal_to_read += 1;
5358 next_offset += envelope_size;
5359 }
5360
5361 let next_out_of_line = decoder.next_out_of_line();
5362 let handles_before = decoder.remaining_handles();
5363 if let Some((inlined, num_bytes, num_handles)) =
5364 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5365 {
5366 let member_inline_size =
5367 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5368 decoder.context,
5369 );
5370 if inlined != (member_inline_size <= 4) {
5371 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5372 }
5373 let inner_offset;
5374 let mut inner_depth = depth.clone();
5375 if inlined {
5376 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5377 inner_offset = next_offset;
5378 } else {
5379 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5380 inner_depth.increment()?;
5381 }
5382 let val_ref = self
5383 .name
5384 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5385 fidl::decode!(
5386 fidl::encoding::BoundedString<128>,
5387 D,
5388 val_ref,
5389 decoder,
5390 inner_offset,
5391 inner_depth
5392 )?;
5393 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5394 {
5395 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5396 }
5397 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5398 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5399 }
5400 }
5401
5402 next_offset += envelope_size;
5403 _next_ordinal_to_read += 1;
5404 if next_offset >= end_offset {
5405 return Ok(());
5406 }
5407
5408 while _next_ordinal_to_read < 2 {
5410 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5411 _next_ordinal_to_read += 1;
5412 next_offset += envelope_size;
5413 }
5414
5415 let next_out_of_line = decoder.next_out_of_line();
5416 let handles_before = decoder.remaining_handles();
5417 if let Some((inlined, num_bytes, num_handles)) =
5418 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5419 {
5420 let member_inline_size =
5421 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5422 if inlined != (member_inline_size <= 4) {
5423 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5424 }
5425 let inner_offset;
5426 let mut inner_depth = depth.clone();
5427 if inlined {
5428 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5429 inner_offset = next_offset;
5430 } else {
5431 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5432 inner_depth.increment()?;
5433 }
5434 let val_ref = self.address.get_or_insert_with(|| fidl::new_empty!(u64, D));
5435 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5436 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5437 {
5438 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5439 }
5440 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5441 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5442 }
5443 }
5444
5445 next_offset += envelope_size;
5446 _next_ordinal_to_read += 1;
5447 if next_offset >= end_offset {
5448 return Ok(());
5449 }
5450
5451 while _next_ordinal_to_read < 3 {
5453 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5454 _next_ordinal_to_read += 1;
5455 next_offset += envelope_size;
5456 }
5457
5458 let next_out_of_line = decoder.next_out_of_line();
5459 let handles_before = decoder.remaining_handles();
5460 if let Some((inlined, num_bytes, num_handles)) =
5461 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5462 {
5463 let member_inline_size =
5464 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5465 decoder.context,
5466 );
5467 if inlined != (member_inline_size <= 4) {
5468 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5469 }
5470 let inner_offset;
5471 let mut inner_depth = depth.clone();
5472 if inlined {
5473 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5474 inner_offset = next_offset;
5475 } else {
5476 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5477 inner_depth.increment()?;
5478 }
5479 let val_ref = self
5480 .module_name
5481 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5482 fidl::decode!(
5483 fidl::encoding::BoundedString<128>,
5484 D,
5485 val_ref,
5486 decoder,
5487 inner_offset,
5488 inner_depth
5489 )?;
5490 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5491 {
5492 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5493 }
5494 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5495 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5496 }
5497 }
5498
5499 next_offset += envelope_size;
5500
5501 while next_offset < end_offset {
5503 _next_ordinal_to_read += 1;
5504 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5505 next_offset += envelope_size;
5506 }
5507
5508 Ok(())
5509 }
5510 }
5511
5512 impl fidl::encoding::ValueTypeMarker for DeviceAddress {
5513 type Borrowed<'a> = &'a Self;
5514 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5515 value
5516 }
5517 }
5518
5519 unsafe impl fidl::encoding::TypeMarker for DeviceAddress {
5520 type Owned = Self;
5521
5522 #[inline(always)]
5523 fn inline_align(_context: fidl::encoding::Context) -> usize {
5524 8
5525 }
5526
5527 #[inline(always)]
5528 fn inline_size(_context: fidl::encoding::Context) -> usize {
5529 16
5530 }
5531 }
5532
5533 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceAddress, D>
5534 for &DeviceAddress
5535 {
5536 #[inline]
5537 unsafe fn encode(
5538 self,
5539 encoder: &mut fidl::encoding::Encoder<'_, D>,
5540 offset: usize,
5541 _depth: fidl::encoding::Depth,
5542 ) -> fidl::Result<()> {
5543 encoder.debug_check_bounds::<DeviceAddress>(offset);
5544 encoder.write_num::<u64>(self.ordinal(), offset);
5545 match self {
5546 DeviceAddress::IntValue(ref val) => {
5547 fidl::encoding::encode_in_envelope::<u8, D>(
5548 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
5549 encoder, offset + 8, _depth
5550 )
5551 }
5552 DeviceAddress::ArrayIntValue(ref val) => {
5553 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 10>, D>(
5554 <fidl::encoding::Vector<u8, 10> as fidl::encoding::ValueTypeMarker>::borrow(val),
5555 encoder, offset + 8, _depth
5556 )
5557 }
5558 DeviceAddress::CharIntValue(ref val) => {
5559 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<4>, D>(
5560 <fidl::encoding::BoundedString<4> as fidl::encoding::ValueTypeMarker>::borrow(val),
5561 encoder, offset + 8, _depth
5562 )
5563 }
5564 DeviceAddress::ArrayCharIntValue(ref val) => {
5565 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>, D>(
5566 <fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10> as fidl::encoding::ValueTypeMarker>::borrow(val),
5567 encoder, offset + 8, _depth
5568 )
5569 }
5570 DeviceAddress::StringValue(ref val) => {
5571 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<32>, D>(
5572 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(val),
5573 encoder, offset + 8, _depth
5574 )
5575 }
5576 DeviceAddress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5577 }
5578 }
5579 }
5580
5581 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceAddress {
5582 #[inline(always)]
5583 fn new_empty() -> Self {
5584 Self::__SourceBreaking { unknown_ordinal: 0 }
5585 }
5586
5587 #[inline]
5588 unsafe fn decode(
5589 &mut self,
5590 decoder: &mut fidl::encoding::Decoder<'_, D>,
5591 offset: usize,
5592 mut depth: fidl::encoding::Depth,
5593 ) -> fidl::Result<()> {
5594 decoder.debug_check_bounds::<Self>(offset);
5595 #[allow(unused_variables)]
5596 let next_out_of_line = decoder.next_out_of_line();
5597 let handles_before = decoder.remaining_handles();
5598 let (ordinal, inlined, num_bytes, num_handles) =
5599 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5600
5601 let member_inline_size = match ordinal {
5602 1 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5603 2 => <fidl::encoding::Vector<u8, 10> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5604 3 => <fidl::encoding::BoundedString<4> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5605 4 => <fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5606 5 => <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5607 0 => return Err(fidl::Error::UnknownUnionTag),
5608 _ => num_bytes as usize,
5609 };
5610
5611 if inlined != (member_inline_size <= 4) {
5612 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5613 }
5614 let _inner_offset;
5615 if inlined {
5616 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5617 _inner_offset = offset + 8;
5618 } else {
5619 depth.increment()?;
5620 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5621 }
5622 match ordinal {
5623 1 => {
5624 #[allow(irrefutable_let_patterns)]
5625 if let DeviceAddress::IntValue(_) = self {
5626 } else {
5628 *self = DeviceAddress::IntValue(fidl::new_empty!(u8, D));
5630 }
5631 #[allow(irrefutable_let_patterns)]
5632 if let DeviceAddress::IntValue(ref mut val) = self {
5633 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
5634 } else {
5635 unreachable!()
5636 }
5637 }
5638 2 => {
5639 #[allow(irrefutable_let_patterns)]
5640 if let DeviceAddress::ArrayIntValue(_) = self {
5641 } else {
5643 *self = DeviceAddress::ArrayIntValue(
5645 fidl::new_empty!(fidl::encoding::Vector<u8, 10>, D),
5646 );
5647 }
5648 #[allow(irrefutable_let_patterns)]
5649 if let DeviceAddress::ArrayIntValue(ref mut val) = self {
5650 fidl::decode!(fidl::encoding::Vector<u8, 10>, D, val, decoder, _inner_offset, depth)?;
5651 } else {
5652 unreachable!()
5653 }
5654 }
5655 3 => {
5656 #[allow(irrefutable_let_patterns)]
5657 if let DeviceAddress::CharIntValue(_) = self {
5658 } else {
5660 *self = DeviceAddress::CharIntValue(fidl::new_empty!(
5662 fidl::encoding::BoundedString<4>,
5663 D
5664 ));
5665 }
5666 #[allow(irrefutable_let_patterns)]
5667 if let DeviceAddress::CharIntValue(ref mut val) = self {
5668 fidl::decode!(
5669 fidl::encoding::BoundedString<4>,
5670 D,
5671 val,
5672 decoder,
5673 _inner_offset,
5674 depth
5675 )?;
5676 } else {
5677 unreachable!()
5678 }
5679 }
5680 4 => {
5681 #[allow(irrefutable_let_patterns)]
5682 if let DeviceAddress::ArrayCharIntValue(_) = self {
5683 } else {
5685 *self = DeviceAddress::ArrayCharIntValue(fidl::new_empty!(
5687 fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>,
5688 D
5689 ));
5690 }
5691 #[allow(irrefutable_let_patterns)]
5692 if let DeviceAddress::ArrayCharIntValue(ref mut val) = self {
5693 fidl::decode!(
5694 fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>,
5695 D,
5696 val,
5697 decoder,
5698 _inner_offset,
5699 depth
5700 )?;
5701 } else {
5702 unreachable!()
5703 }
5704 }
5705 5 => {
5706 #[allow(irrefutable_let_patterns)]
5707 if let DeviceAddress::StringValue(_) = self {
5708 } else {
5710 *self = DeviceAddress::StringValue(fidl::new_empty!(
5712 fidl::encoding::BoundedString<32>,
5713 D
5714 ));
5715 }
5716 #[allow(irrefutable_let_patterns)]
5717 if let DeviceAddress::StringValue(ref mut val) = self {
5718 fidl::decode!(
5719 fidl::encoding::BoundedString<32>,
5720 D,
5721 val,
5722 decoder,
5723 _inner_offset,
5724 depth
5725 )?;
5726 } else {
5727 unreachable!()
5728 }
5729 }
5730 #[allow(deprecated)]
5731 ordinal => {
5732 for _ in 0..num_handles {
5733 decoder.drop_next_handle()?;
5734 }
5735 *self = DeviceAddress::__SourceBreaking { unknown_ordinal: ordinal };
5736 }
5737 }
5738 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5739 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5740 }
5741 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5742 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5743 }
5744 Ok(())
5745 }
5746 }
5747
5748 impl fidl::encoding::ValueTypeMarker for NodePropertyKey {
5749 type Borrowed<'a> = &'a Self;
5750 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5751 value
5752 }
5753 }
5754
5755 unsafe impl fidl::encoding::TypeMarker for NodePropertyKey {
5756 type Owned = Self;
5757
5758 #[inline(always)]
5759 fn inline_align(_context: fidl::encoding::Context) -> usize {
5760 8
5761 }
5762
5763 #[inline(always)]
5764 fn inline_size(_context: fidl::encoding::Context) -> usize {
5765 16
5766 }
5767 }
5768
5769 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyKey, D>
5770 for &NodePropertyKey
5771 {
5772 #[inline]
5773 unsafe fn encode(
5774 self,
5775 encoder: &mut fidl::encoding::Encoder<'_, D>,
5776 offset: usize,
5777 _depth: fidl::encoding::Depth,
5778 ) -> fidl::Result<()> {
5779 encoder.debug_check_bounds::<NodePropertyKey>(offset);
5780 encoder.write_num::<u64>(self.ordinal(), offset);
5781 match self {
5782 NodePropertyKey::IntValue(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
5783 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
5784 encoder,
5785 offset + 8,
5786 _depth,
5787 ),
5788 NodePropertyKey::StringValue(ref val) => fidl::encoding::encode_in_envelope::<
5789 fidl::encoding::BoundedString<256>,
5790 D,
5791 >(
5792 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5793 val,
5794 ),
5795 encoder,
5796 offset + 8,
5797 _depth,
5798 ),
5799 }
5800 }
5801 }
5802
5803 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyKey {
5804 #[inline(always)]
5805 fn new_empty() -> Self {
5806 Self::IntValue(fidl::new_empty!(u32, D))
5807 }
5808
5809 #[inline]
5810 unsafe fn decode(
5811 &mut self,
5812 decoder: &mut fidl::encoding::Decoder<'_, D>,
5813 offset: usize,
5814 mut depth: fidl::encoding::Depth,
5815 ) -> fidl::Result<()> {
5816 decoder.debug_check_bounds::<Self>(offset);
5817 #[allow(unused_variables)]
5818 let next_out_of_line = decoder.next_out_of_line();
5819 let handles_before = decoder.remaining_handles();
5820 let (ordinal, inlined, num_bytes, num_handles) =
5821 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5822
5823 let member_inline_size = match ordinal {
5824 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5825 2 => {
5826 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5827 decoder.context,
5828 )
5829 }
5830 _ => return Err(fidl::Error::UnknownUnionTag),
5831 };
5832
5833 if inlined != (member_inline_size <= 4) {
5834 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5835 }
5836 let _inner_offset;
5837 if inlined {
5838 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5839 _inner_offset = offset + 8;
5840 } else {
5841 depth.increment()?;
5842 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5843 }
5844 match ordinal {
5845 1 => {
5846 #[allow(irrefutable_let_patterns)]
5847 if let NodePropertyKey::IntValue(_) = self {
5848 } else {
5850 *self = NodePropertyKey::IntValue(fidl::new_empty!(u32, D));
5852 }
5853 #[allow(irrefutable_let_patterns)]
5854 if let NodePropertyKey::IntValue(ref mut val) = self {
5855 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5856 } else {
5857 unreachable!()
5858 }
5859 }
5860 2 => {
5861 #[allow(irrefutable_let_patterns)]
5862 if let NodePropertyKey::StringValue(_) = self {
5863 } else {
5865 *self = NodePropertyKey::StringValue(fidl::new_empty!(
5867 fidl::encoding::BoundedString<256>,
5868 D
5869 ));
5870 }
5871 #[allow(irrefutable_let_patterns)]
5872 if let NodePropertyKey::StringValue(ref mut val) = self {
5873 fidl::decode!(
5874 fidl::encoding::BoundedString<256>,
5875 D,
5876 val,
5877 decoder,
5878 _inner_offset,
5879 depth
5880 )?;
5881 } else {
5882 unreachable!()
5883 }
5884 }
5885 ordinal => panic!("unexpected ordinal {:?}", ordinal),
5886 }
5887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5888 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5889 }
5890 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5891 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5892 }
5893 Ok(())
5894 }
5895 }
5896
5897 impl fidl::encoding::ValueTypeMarker for NodePropertyValue {
5898 type Borrowed<'a> = &'a Self;
5899 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5900 value
5901 }
5902 }
5903
5904 unsafe impl fidl::encoding::TypeMarker for NodePropertyValue {
5905 type Owned = Self;
5906
5907 #[inline(always)]
5908 fn inline_align(_context: fidl::encoding::Context) -> usize {
5909 8
5910 }
5911
5912 #[inline(always)]
5913 fn inline_size(_context: fidl::encoding::Context) -> usize {
5914 16
5915 }
5916 }
5917
5918 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyValue, D>
5919 for &NodePropertyValue
5920 {
5921 #[inline]
5922 unsafe fn encode(
5923 self,
5924 encoder: &mut fidl::encoding::Encoder<'_, D>,
5925 offset: usize,
5926 _depth: fidl::encoding::Depth,
5927 ) -> fidl::Result<()> {
5928 encoder.debug_check_bounds::<NodePropertyValue>(offset);
5929 encoder.write_num::<u64>(self.ordinal(), offset);
5930 match self {
5931 NodePropertyValue::IntValue(ref val) => {
5932 fidl::encoding::encode_in_envelope::<u32, D>(
5933 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
5934 encoder,
5935 offset + 8,
5936 _depth,
5937 )
5938 }
5939 NodePropertyValue::StringValue(ref val) => fidl::encoding::encode_in_envelope::<
5940 fidl::encoding::BoundedString<256>,
5941 D,
5942 >(
5943 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5944 val,
5945 ),
5946 encoder,
5947 offset + 8,
5948 _depth,
5949 ),
5950 NodePropertyValue::BoolValue(ref val) => {
5951 fidl::encoding::encode_in_envelope::<bool, D>(
5952 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
5953 encoder,
5954 offset + 8,
5955 _depth,
5956 )
5957 }
5958 NodePropertyValue::EnumValue(ref val) => fidl::encoding::encode_in_envelope::<
5959 fidl::encoding::BoundedString<256>,
5960 D,
5961 >(
5962 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5963 val,
5964 ),
5965 encoder,
5966 offset + 8,
5967 _depth,
5968 ),
5969 NodePropertyValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5970 }
5971 }
5972 }
5973
5974 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyValue {
5975 #[inline(always)]
5976 fn new_empty() -> Self {
5977 Self::__SourceBreaking { unknown_ordinal: 0 }
5978 }
5979
5980 #[inline]
5981 unsafe fn decode(
5982 &mut self,
5983 decoder: &mut fidl::encoding::Decoder<'_, D>,
5984 offset: usize,
5985 mut depth: fidl::encoding::Depth,
5986 ) -> fidl::Result<()> {
5987 decoder.debug_check_bounds::<Self>(offset);
5988 #[allow(unused_variables)]
5989 let next_out_of_line = decoder.next_out_of_line();
5990 let handles_before = decoder.remaining_handles();
5991 let (ordinal, inlined, num_bytes, num_handles) =
5992 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5993
5994 let member_inline_size = match ordinal {
5995 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5996 2 => {
5997 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5998 decoder.context,
5999 )
6000 }
6001 3 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6002 4 => {
6003 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
6004 decoder.context,
6005 )
6006 }
6007 0 => return Err(fidl::Error::UnknownUnionTag),
6008 _ => num_bytes as usize,
6009 };
6010
6011 if inlined != (member_inline_size <= 4) {
6012 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6013 }
6014 let _inner_offset;
6015 if inlined {
6016 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6017 _inner_offset = offset + 8;
6018 } else {
6019 depth.increment()?;
6020 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6021 }
6022 match ordinal {
6023 1 => {
6024 #[allow(irrefutable_let_patterns)]
6025 if let NodePropertyValue::IntValue(_) = self {
6026 } else {
6028 *self = NodePropertyValue::IntValue(fidl::new_empty!(u32, D));
6030 }
6031 #[allow(irrefutable_let_patterns)]
6032 if let NodePropertyValue::IntValue(ref mut val) = self {
6033 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
6034 } else {
6035 unreachable!()
6036 }
6037 }
6038 2 => {
6039 #[allow(irrefutable_let_patterns)]
6040 if let NodePropertyValue::StringValue(_) = self {
6041 } else {
6043 *self = NodePropertyValue::StringValue(fidl::new_empty!(
6045 fidl::encoding::BoundedString<256>,
6046 D
6047 ));
6048 }
6049 #[allow(irrefutable_let_patterns)]
6050 if let NodePropertyValue::StringValue(ref mut val) = self {
6051 fidl::decode!(
6052 fidl::encoding::BoundedString<256>,
6053 D,
6054 val,
6055 decoder,
6056 _inner_offset,
6057 depth
6058 )?;
6059 } else {
6060 unreachable!()
6061 }
6062 }
6063 3 => {
6064 #[allow(irrefutable_let_patterns)]
6065 if let NodePropertyValue::BoolValue(_) = self {
6066 } else {
6068 *self = NodePropertyValue::BoolValue(fidl::new_empty!(bool, D));
6070 }
6071 #[allow(irrefutable_let_patterns)]
6072 if let NodePropertyValue::BoolValue(ref mut val) = self {
6073 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
6074 } else {
6075 unreachable!()
6076 }
6077 }
6078 4 => {
6079 #[allow(irrefutable_let_patterns)]
6080 if let NodePropertyValue::EnumValue(_) = self {
6081 } else {
6083 *self = NodePropertyValue::EnumValue(fidl::new_empty!(
6085 fidl::encoding::BoundedString<256>,
6086 D
6087 ));
6088 }
6089 #[allow(irrefutable_let_patterns)]
6090 if let NodePropertyValue::EnumValue(ref mut val) = self {
6091 fidl::decode!(
6092 fidl::encoding::BoundedString<256>,
6093 D,
6094 val,
6095 decoder,
6096 _inner_offset,
6097 depth
6098 )?;
6099 } else {
6100 unreachable!()
6101 }
6102 }
6103 #[allow(deprecated)]
6104 ordinal => {
6105 for _ in 0..num_handles {
6106 decoder.drop_next_handle()?;
6107 }
6108 *self = NodePropertyValue::__SourceBreaking { unknown_ordinal: ordinal };
6109 }
6110 }
6111 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6112 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6113 }
6114 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6115 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6116 }
6117 Ok(())
6118 }
6119 }
6120
6121 impl fidl::encoding::ValueTypeMarker for Offer {
6122 type Borrowed<'a> = &'a Self;
6123 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6124 value
6125 }
6126 }
6127
6128 unsafe impl fidl::encoding::TypeMarker for Offer {
6129 type Owned = Self;
6130
6131 #[inline(always)]
6132 fn inline_align(_context: fidl::encoding::Context) -> usize {
6133 8
6134 }
6135
6136 #[inline(always)]
6137 fn inline_size(_context: fidl::encoding::Context) -> usize {
6138 16
6139 }
6140 }
6141
6142 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Offer, D> for &Offer {
6143 #[inline]
6144 unsafe fn encode(
6145 self,
6146 encoder: &mut fidl::encoding::Encoder<'_, D>,
6147 offset: usize,
6148 _depth: fidl::encoding::Depth,
6149 ) -> fidl::Result<()> {
6150 encoder.debug_check_bounds::<Offer>(offset);
6151 encoder.write_num::<u64>(self.ordinal(), offset);
6152 match self {
6153 Offer::ZirconTransport(ref val) => {
6154 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
6155 <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
6156 encoder, offset + 8, _depth
6157 )
6158 }
6159 Offer::DriverTransport(ref val) => {
6160 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
6161 <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
6162 encoder, offset + 8, _depth
6163 )
6164 }
6165 Offer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6166 }
6167 }
6168 }
6169
6170 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Offer {
6171 #[inline(always)]
6172 fn new_empty() -> Self {
6173 Self::__SourceBreaking { unknown_ordinal: 0 }
6174 }
6175
6176 #[inline]
6177 unsafe fn decode(
6178 &mut self,
6179 decoder: &mut fidl::encoding::Decoder<'_, D>,
6180 offset: usize,
6181 mut depth: fidl::encoding::Depth,
6182 ) -> fidl::Result<()> {
6183 decoder.debug_check_bounds::<Self>(offset);
6184 #[allow(unused_variables)]
6185 let next_out_of_line = decoder.next_out_of_line();
6186 let handles_before = decoder.remaining_handles();
6187 let (ordinal, inlined, num_bytes, num_handles) =
6188 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6189
6190 let member_inline_size = match ordinal {
6191 1 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6192 2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6193 0 => return Err(fidl::Error::UnknownUnionTag),
6194 _ => num_bytes as usize,
6195 };
6196
6197 if inlined != (member_inline_size <= 4) {
6198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6199 }
6200 let _inner_offset;
6201 if inlined {
6202 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6203 _inner_offset = offset + 8;
6204 } else {
6205 depth.increment()?;
6206 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6207 }
6208 match ordinal {
6209 1 => {
6210 #[allow(irrefutable_let_patterns)]
6211 if let Offer::ZirconTransport(_) = self {
6212 } else {
6214 *self = Offer::ZirconTransport(fidl::new_empty!(
6216 fidl_fuchsia_component_decl__common::Offer,
6217 D
6218 ));
6219 }
6220 #[allow(irrefutable_let_patterns)]
6221 if let Offer::ZirconTransport(ref mut val) = self {
6222 fidl::decode!(
6223 fidl_fuchsia_component_decl__common::Offer,
6224 D,
6225 val,
6226 decoder,
6227 _inner_offset,
6228 depth
6229 )?;
6230 } else {
6231 unreachable!()
6232 }
6233 }
6234 2 => {
6235 #[allow(irrefutable_let_patterns)]
6236 if let Offer::DriverTransport(_) = self {
6237 } else {
6239 *self = Offer::DriverTransport(fidl::new_empty!(
6241 fidl_fuchsia_component_decl__common::Offer,
6242 D
6243 ));
6244 }
6245 #[allow(irrefutable_let_patterns)]
6246 if let Offer::DriverTransport(ref mut val) = self {
6247 fidl::decode!(
6248 fidl_fuchsia_component_decl__common::Offer,
6249 D,
6250 val,
6251 decoder,
6252 _inner_offset,
6253 depth
6254 )?;
6255 } else {
6256 unreachable!()
6257 }
6258 }
6259 #[allow(deprecated)]
6260 ordinal => {
6261 for _ in 0..num_handles {
6262 decoder.drop_next_handle()?;
6263 }
6264 *self = Offer::__SourceBreaking { unknown_ordinal: ordinal };
6265 }
6266 }
6267 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6268 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6269 }
6270 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6271 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6272 }
6273 Ok(())
6274 }
6275 }
6276}