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
984mod internal {
985 use super::*;
986 unsafe impl fidl::encoding::TypeMarker for BusType {
987 type Owned = Self;
988
989 #[inline(always)]
990 fn inline_align(_context: fidl::encoding::Context) -> usize {
991 std::mem::align_of::<u32>()
992 }
993
994 #[inline(always)]
995 fn inline_size(_context: fidl::encoding::Context) -> usize {
996 std::mem::size_of::<u32>()
997 }
998
999 #[inline(always)]
1000 fn encode_is_copy() -> bool {
1001 false
1002 }
1003
1004 #[inline(always)]
1005 fn decode_is_copy() -> bool {
1006 false
1007 }
1008 }
1009
1010 impl fidl::encoding::ValueTypeMarker for BusType {
1011 type Borrowed<'a> = Self;
1012 #[inline(always)]
1013 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1014 *value
1015 }
1016 }
1017
1018 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BusType {
1019 #[inline]
1020 unsafe fn encode(
1021 self,
1022 encoder: &mut fidl::encoding::Encoder<'_, D>,
1023 offset: usize,
1024 _depth: fidl::encoding::Depth,
1025 ) -> fidl::Result<()> {
1026 encoder.debug_check_bounds::<Self>(offset);
1027 encoder.write_num(self.into_primitive(), offset);
1028 Ok(())
1029 }
1030 }
1031
1032 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BusType {
1033 #[inline(always)]
1034 fn new_empty() -> Self {
1035 Self::unknown()
1036 }
1037
1038 #[inline]
1039 unsafe fn decode(
1040 &mut self,
1041 decoder: &mut fidl::encoding::Decoder<'_, D>,
1042 offset: usize,
1043 _depth: fidl::encoding::Depth,
1044 ) -> fidl::Result<()> {
1045 decoder.debug_check_bounds::<Self>(offset);
1046 let prim = decoder.read_num::<u32>(offset);
1047
1048 *self = Self::from_primitive_allow_unknown(prim);
1049 Ok(())
1050 }
1051 }
1052 unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecError {
1053 type Owned = Self;
1054
1055 #[inline(always)]
1056 fn inline_align(_context: fidl::encoding::Context) -> usize {
1057 std::mem::align_of::<u32>()
1058 }
1059
1060 #[inline(always)]
1061 fn inline_size(_context: fidl::encoding::Context) -> usize {
1062 std::mem::size_of::<u32>()
1063 }
1064
1065 #[inline(always)]
1066 fn encode_is_copy() -> bool {
1067 false
1068 }
1069
1070 #[inline(always)]
1071 fn decode_is_copy() -> bool {
1072 false
1073 }
1074 }
1075
1076 impl fidl::encoding::ValueTypeMarker for CompositeNodeSpecError {
1077 type Borrowed<'a> = Self;
1078 #[inline(always)]
1079 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1080 *value
1081 }
1082 }
1083
1084 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1085 for CompositeNodeSpecError
1086 {
1087 #[inline]
1088 unsafe fn encode(
1089 self,
1090 encoder: &mut fidl::encoding::Encoder<'_, D>,
1091 offset: usize,
1092 _depth: fidl::encoding::Depth,
1093 ) -> fidl::Result<()> {
1094 encoder.debug_check_bounds::<Self>(offset);
1095 encoder.write_num(self.into_primitive(), offset);
1096 Ok(())
1097 }
1098 }
1099
1100 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1101 for CompositeNodeSpecError
1102 {
1103 #[inline(always)]
1104 fn new_empty() -> Self {
1105 Self::unknown()
1106 }
1107
1108 #[inline]
1109 unsafe fn decode(
1110 &mut self,
1111 decoder: &mut fidl::encoding::Decoder<'_, D>,
1112 offset: usize,
1113 _depth: fidl::encoding::Depth,
1114 ) -> fidl::Result<()> {
1115 decoder.debug_check_bounds::<Self>(offset);
1116 let prim = decoder.read_num::<u32>(offset);
1117
1118 *self = Self::from_primitive_allow_unknown(prim);
1119 Ok(())
1120 }
1121 }
1122 unsafe impl fidl::encoding::TypeMarker for Condition {
1123 type Owned = Self;
1124
1125 #[inline(always)]
1126 fn inline_align(_context: fidl::encoding::Context) -> usize {
1127 std::mem::align_of::<u32>()
1128 }
1129
1130 #[inline(always)]
1131 fn inline_size(_context: fidl::encoding::Context) -> usize {
1132 std::mem::size_of::<u32>()
1133 }
1134
1135 #[inline(always)]
1136 fn encode_is_copy() -> bool {
1137 true
1138 }
1139
1140 #[inline(always)]
1141 fn decode_is_copy() -> bool {
1142 false
1143 }
1144 }
1145
1146 impl fidl::encoding::ValueTypeMarker for Condition {
1147 type Borrowed<'a> = Self;
1148 #[inline(always)]
1149 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1150 *value
1151 }
1152 }
1153
1154 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Condition {
1155 #[inline]
1156 unsafe fn encode(
1157 self,
1158 encoder: &mut fidl::encoding::Encoder<'_, D>,
1159 offset: usize,
1160 _depth: fidl::encoding::Depth,
1161 ) -> fidl::Result<()> {
1162 encoder.debug_check_bounds::<Self>(offset);
1163 encoder.write_num(self.into_primitive(), offset);
1164 Ok(())
1165 }
1166 }
1167
1168 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Condition {
1169 #[inline(always)]
1170 fn new_empty() -> Self {
1171 Self::Unknown
1172 }
1173
1174 #[inline]
1175 unsafe fn decode(
1176 &mut self,
1177 decoder: &mut fidl::encoding::Decoder<'_, D>,
1178 offset: usize,
1179 _depth: fidl::encoding::Depth,
1180 ) -> fidl::Result<()> {
1181 decoder.debug_check_bounds::<Self>(offset);
1182 let prim = decoder.read_num::<u32>(offset);
1183
1184 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1185 Ok(())
1186 }
1187 }
1188 unsafe impl fidl::encoding::TypeMarker for DeviceAddressStability {
1189 type Owned = Self;
1190
1191 #[inline(always)]
1192 fn inline_align(_context: fidl::encoding::Context) -> usize {
1193 std::mem::align_of::<u32>()
1194 }
1195
1196 #[inline(always)]
1197 fn inline_size(_context: fidl::encoding::Context) -> usize {
1198 std::mem::size_of::<u32>()
1199 }
1200
1201 #[inline(always)]
1202 fn encode_is_copy() -> bool {
1203 false
1204 }
1205
1206 #[inline(always)]
1207 fn decode_is_copy() -> bool {
1208 false
1209 }
1210 }
1211
1212 impl fidl::encoding::ValueTypeMarker for DeviceAddressStability {
1213 type Borrowed<'a> = Self;
1214 #[inline(always)]
1215 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1216 *value
1217 }
1218 }
1219
1220 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1221 for DeviceAddressStability
1222 {
1223 #[inline]
1224 unsafe fn encode(
1225 self,
1226 encoder: &mut fidl::encoding::Encoder<'_, D>,
1227 offset: usize,
1228 _depth: fidl::encoding::Depth,
1229 ) -> fidl::Result<()> {
1230 encoder.debug_check_bounds::<Self>(offset);
1231 encoder.write_num(self.into_primitive(), offset);
1232 Ok(())
1233 }
1234 }
1235
1236 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1237 for DeviceAddressStability
1238 {
1239 #[inline(always)]
1240 fn new_empty() -> Self {
1241 Self::unknown()
1242 }
1243
1244 #[inline]
1245 unsafe fn decode(
1246 &mut self,
1247 decoder: &mut fidl::encoding::Decoder<'_, D>,
1248 offset: usize,
1249 _depth: fidl::encoding::Depth,
1250 ) -> fidl::Result<()> {
1251 decoder.debug_check_bounds::<Self>(offset);
1252 let prim = decoder.read_num::<u32>(offset);
1253
1254 *self = Self::from_primitive_allow_unknown(prim);
1255 Ok(())
1256 }
1257 }
1258 unsafe impl fidl::encoding::TypeMarker for DriverPackageType {
1259 type Owned = Self;
1260
1261 #[inline(always)]
1262 fn inline_align(_context: fidl::encoding::Context) -> usize {
1263 std::mem::align_of::<u8>()
1264 }
1265
1266 #[inline(always)]
1267 fn inline_size(_context: fidl::encoding::Context) -> usize {
1268 std::mem::size_of::<u8>()
1269 }
1270
1271 #[inline(always)]
1272 fn encode_is_copy() -> bool {
1273 false
1274 }
1275
1276 #[inline(always)]
1277 fn decode_is_copy() -> bool {
1278 false
1279 }
1280 }
1281
1282 impl fidl::encoding::ValueTypeMarker for DriverPackageType {
1283 type Borrowed<'a> = Self;
1284 #[inline(always)]
1285 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286 *value
1287 }
1288 }
1289
1290 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1291 for DriverPackageType
1292 {
1293 #[inline]
1294 unsafe fn encode(
1295 self,
1296 encoder: &mut fidl::encoding::Encoder<'_, D>,
1297 offset: usize,
1298 _depth: fidl::encoding::Depth,
1299 ) -> fidl::Result<()> {
1300 encoder.debug_check_bounds::<Self>(offset);
1301 encoder.write_num(self.into_primitive(), offset);
1302 Ok(())
1303 }
1304 }
1305
1306 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverPackageType {
1307 #[inline(always)]
1308 fn new_empty() -> Self {
1309 Self::unknown()
1310 }
1311
1312 #[inline]
1313 unsafe fn decode(
1314 &mut self,
1315 decoder: &mut fidl::encoding::Decoder<'_, D>,
1316 offset: usize,
1317 _depth: fidl::encoding::Depth,
1318 ) -> fidl::Result<()> {
1319 decoder.debug_check_bounds::<Self>(offset);
1320 let prim = decoder.read_num::<u8>(offset);
1321
1322 *self = Self::from_primitive_allow_unknown(prim);
1323 Ok(())
1324 }
1325 }
1326 unsafe impl fidl::encoding::TypeMarker for NodeError {
1327 type Owned = Self;
1328
1329 #[inline(always)]
1330 fn inline_align(_context: fidl::encoding::Context) -> usize {
1331 std::mem::align_of::<u32>()
1332 }
1333
1334 #[inline(always)]
1335 fn inline_size(_context: fidl::encoding::Context) -> usize {
1336 std::mem::size_of::<u32>()
1337 }
1338
1339 #[inline(always)]
1340 fn encode_is_copy() -> bool {
1341 false
1342 }
1343
1344 #[inline(always)]
1345 fn decode_is_copy() -> bool {
1346 false
1347 }
1348 }
1349
1350 impl fidl::encoding::ValueTypeMarker for NodeError {
1351 type Borrowed<'a> = Self;
1352 #[inline(always)]
1353 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1354 *value
1355 }
1356 }
1357
1358 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeError {
1359 #[inline]
1360 unsafe fn encode(
1361 self,
1362 encoder: &mut fidl::encoding::Encoder<'_, D>,
1363 offset: usize,
1364 _depth: fidl::encoding::Depth,
1365 ) -> fidl::Result<()> {
1366 encoder.debug_check_bounds::<Self>(offset);
1367 encoder.write_num(self.into_primitive(), offset);
1368 Ok(())
1369 }
1370 }
1371
1372 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeError {
1373 #[inline(always)]
1374 fn new_empty() -> Self {
1375 Self::unknown()
1376 }
1377
1378 #[inline]
1379 unsafe fn decode(
1380 &mut self,
1381 decoder: &mut fidl::encoding::Decoder<'_, D>,
1382 offset: usize,
1383 _depth: fidl::encoding::Depth,
1384 ) -> fidl::Result<()> {
1385 decoder.debug_check_bounds::<Self>(offset);
1386 let prim = decoder.read_num::<u32>(offset);
1387
1388 *self = Self::from_primitive_allow_unknown(prim);
1389 Ok(())
1390 }
1391 }
1392
1393 impl fidl::encoding::ValueTypeMarker for BindRule {
1394 type Borrowed<'a> = &'a Self;
1395 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1396 value
1397 }
1398 }
1399
1400 unsafe impl fidl::encoding::TypeMarker for BindRule {
1401 type Owned = Self;
1402
1403 #[inline(always)]
1404 fn inline_align(_context: fidl::encoding::Context) -> usize {
1405 8
1406 }
1407
1408 #[inline(always)]
1409 fn inline_size(_context: fidl::encoding::Context) -> usize {
1410 40
1411 }
1412 }
1413
1414 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindRule, D> for &BindRule {
1415 #[inline]
1416 unsafe fn encode(
1417 self,
1418 encoder: &mut fidl::encoding::Encoder<'_, D>,
1419 offset: usize,
1420 _depth: fidl::encoding::Depth,
1421 ) -> fidl::Result<()> {
1422 encoder.debug_check_bounds::<BindRule>(offset);
1423 fidl::encoding::Encode::<BindRule, D>::encode(
1425 (
1426 <NodePropertyKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1427 <Condition as fidl::encoding::ValueTypeMarker>::borrow(&self.condition),
1428 <fidl::encoding::Vector<NodePropertyValue, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.values),
1429 ),
1430 encoder, offset, _depth
1431 )
1432 }
1433 }
1434 unsafe impl<
1435 D: fidl::encoding::ResourceDialect,
1436 T0: fidl::encoding::Encode<NodePropertyKey, D>,
1437 T1: fidl::encoding::Encode<Condition, D>,
1438 T2: fidl::encoding::Encode<fidl::encoding::Vector<NodePropertyValue, 64>, D>,
1439 > fidl::encoding::Encode<BindRule, D> for (T0, T1, T2)
1440 {
1441 #[inline]
1442 unsafe fn encode(
1443 self,
1444 encoder: &mut fidl::encoding::Encoder<'_, D>,
1445 offset: usize,
1446 depth: fidl::encoding::Depth,
1447 ) -> fidl::Result<()> {
1448 encoder.debug_check_bounds::<BindRule>(offset);
1449 unsafe {
1452 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1453 (ptr as *mut u64).write_unaligned(0);
1454 }
1455 self.0.encode(encoder, offset + 0, depth)?;
1457 self.1.encode(encoder, offset + 16, depth)?;
1458 self.2.encode(encoder, offset + 24, depth)?;
1459 Ok(())
1460 }
1461 }
1462
1463 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BindRule {
1464 #[inline(always)]
1465 fn new_empty() -> Self {
1466 Self {
1467 key: fidl::new_empty!(NodePropertyKey, D),
1468 condition: fidl::new_empty!(Condition, D),
1469 values: fidl::new_empty!(fidl::encoding::Vector<NodePropertyValue, 64>, D),
1470 }
1471 }
1472
1473 #[inline]
1474 unsafe fn decode(
1475 &mut self,
1476 decoder: &mut fidl::encoding::Decoder<'_, D>,
1477 offset: usize,
1478 _depth: fidl::encoding::Depth,
1479 ) -> fidl::Result<()> {
1480 decoder.debug_check_bounds::<Self>(offset);
1481 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1483 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1484 let mask = 0xffffffff00000000u64;
1485 let maskedval = padval & mask;
1486 if maskedval != 0 {
1487 return Err(fidl::Error::NonZeroPadding {
1488 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1489 });
1490 }
1491 fidl::decode!(NodePropertyKey, D, &mut self.key, decoder, offset + 0, _depth)?;
1492 fidl::decode!(Condition, D, &mut self.condition, decoder, offset + 16, _depth)?;
1493 fidl::decode!(fidl::encoding::Vector<NodePropertyValue, 64>, D, &mut self.values, decoder, offset + 24, _depth)?;
1494 Ok(())
1495 }
1496 }
1497
1498 impl fidl::encoding::ValueTypeMarker for BindRule2 {
1499 type Borrowed<'a> = &'a Self;
1500 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1501 value
1502 }
1503 }
1504
1505 unsafe impl fidl::encoding::TypeMarker for BindRule2 {
1506 type Owned = Self;
1507
1508 #[inline(always)]
1509 fn inline_align(_context: fidl::encoding::Context) -> usize {
1510 8
1511 }
1512
1513 #[inline(always)]
1514 fn inline_size(_context: fidl::encoding::Context) -> usize {
1515 40
1516 }
1517 }
1518
1519 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindRule2, D>
1520 for &BindRule2
1521 {
1522 #[inline]
1523 unsafe fn encode(
1524 self,
1525 encoder: &mut fidl::encoding::Encoder<'_, D>,
1526 offset: usize,
1527 _depth: fidl::encoding::Depth,
1528 ) -> fidl::Result<()> {
1529 encoder.debug_check_bounds::<BindRule2>(offset);
1530 fidl::encoding::Encode::<BindRule2, D>::encode(
1532 (
1533 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1534 <Condition as fidl::encoding::ValueTypeMarker>::borrow(&self.condition),
1535 <fidl::encoding::Vector<NodePropertyValue, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.values),
1536 ),
1537 encoder, offset, _depth
1538 )
1539 }
1540 }
1541 unsafe impl<
1542 D: fidl::encoding::ResourceDialect,
1543 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1544 T1: fidl::encoding::Encode<Condition, D>,
1545 T2: fidl::encoding::Encode<fidl::encoding::Vector<NodePropertyValue, 64>, D>,
1546 > fidl::encoding::Encode<BindRule2, D> for (T0, T1, T2)
1547 {
1548 #[inline]
1549 unsafe fn encode(
1550 self,
1551 encoder: &mut fidl::encoding::Encoder<'_, D>,
1552 offset: usize,
1553 depth: fidl::encoding::Depth,
1554 ) -> fidl::Result<()> {
1555 encoder.debug_check_bounds::<BindRule2>(offset);
1556 unsafe {
1559 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1560 (ptr as *mut u64).write_unaligned(0);
1561 }
1562 self.0.encode(encoder, offset + 0, depth)?;
1564 self.1.encode(encoder, offset + 16, depth)?;
1565 self.2.encode(encoder, offset + 24, depth)?;
1566 Ok(())
1567 }
1568 }
1569
1570 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BindRule2 {
1571 #[inline(always)]
1572 fn new_empty() -> Self {
1573 Self {
1574 key: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1575 condition: fidl::new_empty!(Condition, D),
1576 values: fidl::new_empty!(fidl::encoding::Vector<NodePropertyValue, 64>, D),
1577 }
1578 }
1579
1580 #[inline]
1581 unsafe fn decode(
1582 &mut self,
1583 decoder: &mut fidl::encoding::Decoder<'_, D>,
1584 offset: usize,
1585 _depth: fidl::encoding::Depth,
1586 ) -> fidl::Result<()> {
1587 decoder.debug_check_bounds::<Self>(offset);
1588 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1590 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1591 let mask = 0xffffffff00000000u64;
1592 let maskedval = padval & mask;
1593 if maskedval != 0 {
1594 return Err(fidl::Error::NonZeroPadding {
1595 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1596 });
1597 }
1598 fidl::decode!(
1599 fidl::encoding::BoundedString<256>,
1600 D,
1601 &mut self.key,
1602 decoder,
1603 offset + 0,
1604 _depth
1605 )?;
1606 fidl::decode!(Condition, D, &mut self.condition, decoder, offset + 16, _depth)?;
1607 fidl::decode!(fidl::encoding::Vector<NodePropertyValue, 64>, D, &mut self.values, decoder, offset + 24, _depth)?;
1608 Ok(())
1609 }
1610 }
1611
1612 impl fidl::encoding::ValueTypeMarker for NodeProperty {
1613 type Borrowed<'a> = &'a Self;
1614 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1615 value
1616 }
1617 }
1618
1619 unsafe impl fidl::encoding::TypeMarker for NodeProperty {
1620 type Owned = Self;
1621
1622 #[inline(always)]
1623 fn inline_align(_context: fidl::encoding::Context) -> usize {
1624 8
1625 }
1626
1627 #[inline(always)]
1628 fn inline_size(_context: fidl::encoding::Context) -> usize {
1629 32
1630 }
1631 }
1632
1633 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProperty, D>
1634 for &NodeProperty
1635 {
1636 #[inline]
1637 unsafe fn encode(
1638 self,
1639 encoder: &mut fidl::encoding::Encoder<'_, D>,
1640 offset: usize,
1641 _depth: fidl::encoding::Depth,
1642 ) -> fidl::Result<()> {
1643 encoder.debug_check_bounds::<NodeProperty>(offset);
1644 fidl::encoding::Encode::<NodeProperty, D>::encode(
1646 (
1647 <NodePropertyKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1648 <NodePropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
1649 ),
1650 encoder,
1651 offset,
1652 _depth,
1653 )
1654 }
1655 }
1656 unsafe impl<
1657 D: fidl::encoding::ResourceDialect,
1658 T0: fidl::encoding::Encode<NodePropertyKey, D>,
1659 T1: fidl::encoding::Encode<NodePropertyValue, D>,
1660 > fidl::encoding::Encode<NodeProperty, D> for (T0, T1)
1661 {
1662 #[inline]
1663 unsafe fn encode(
1664 self,
1665 encoder: &mut fidl::encoding::Encoder<'_, D>,
1666 offset: usize,
1667 depth: fidl::encoding::Depth,
1668 ) -> fidl::Result<()> {
1669 encoder.debug_check_bounds::<NodeProperty>(offset);
1670 self.0.encode(encoder, offset + 0, depth)?;
1674 self.1.encode(encoder, offset + 16, depth)?;
1675 Ok(())
1676 }
1677 }
1678
1679 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProperty {
1680 #[inline(always)]
1681 fn new_empty() -> Self {
1682 Self {
1683 key: fidl::new_empty!(NodePropertyKey, D),
1684 value: fidl::new_empty!(NodePropertyValue, D),
1685 }
1686 }
1687
1688 #[inline]
1689 unsafe fn decode(
1690 &mut self,
1691 decoder: &mut fidl::encoding::Decoder<'_, D>,
1692 offset: usize,
1693 _depth: fidl::encoding::Depth,
1694 ) -> fidl::Result<()> {
1695 decoder.debug_check_bounds::<Self>(offset);
1696 fidl::decode!(NodePropertyKey, D, &mut self.key, decoder, offset + 0, _depth)?;
1698 fidl::decode!(NodePropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
1699 Ok(())
1700 }
1701 }
1702
1703 impl fidl::encoding::ValueTypeMarker for NodeProperty2 {
1704 type Borrowed<'a> = &'a Self;
1705 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1706 value
1707 }
1708 }
1709
1710 unsafe impl fidl::encoding::TypeMarker for NodeProperty2 {
1711 type Owned = Self;
1712
1713 #[inline(always)]
1714 fn inline_align(_context: fidl::encoding::Context) -> usize {
1715 8
1716 }
1717
1718 #[inline(always)]
1719 fn inline_size(_context: fidl::encoding::Context) -> usize {
1720 32
1721 }
1722 }
1723
1724 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProperty2, D>
1725 for &NodeProperty2
1726 {
1727 #[inline]
1728 unsafe fn encode(
1729 self,
1730 encoder: &mut fidl::encoding::Encoder<'_, D>,
1731 offset: usize,
1732 _depth: fidl::encoding::Depth,
1733 ) -> fidl::Result<()> {
1734 encoder.debug_check_bounds::<NodeProperty2>(offset);
1735 fidl::encoding::Encode::<NodeProperty2, D>::encode(
1737 (
1738 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
1739 &self.key,
1740 ),
1741 <NodePropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
1742 ),
1743 encoder,
1744 offset,
1745 _depth,
1746 )
1747 }
1748 }
1749 unsafe impl<
1750 D: fidl::encoding::ResourceDialect,
1751 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1752 T1: fidl::encoding::Encode<NodePropertyValue, D>,
1753 > fidl::encoding::Encode<NodeProperty2, D> for (T0, T1)
1754 {
1755 #[inline]
1756 unsafe fn encode(
1757 self,
1758 encoder: &mut fidl::encoding::Encoder<'_, D>,
1759 offset: usize,
1760 depth: fidl::encoding::Depth,
1761 ) -> fidl::Result<()> {
1762 encoder.debug_check_bounds::<NodeProperty2>(offset);
1763 self.0.encode(encoder, offset + 0, depth)?;
1767 self.1.encode(encoder, offset + 16, depth)?;
1768 Ok(())
1769 }
1770 }
1771
1772 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProperty2 {
1773 #[inline(always)]
1774 fn new_empty() -> Self {
1775 Self {
1776 key: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1777 value: fidl::new_empty!(NodePropertyValue, D),
1778 }
1779 }
1780
1781 #[inline]
1782 unsafe fn decode(
1783 &mut self,
1784 decoder: &mut fidl::encoding::Decoder<'_, D>,
1785 offset: usize,
1786 _depth: fidl::encoding::Depth,
1787 ) -> fidl::Result<()> {
1788 decoder.debug_check_bounds::<Self>(offset);
1789 fidl::decode!(
1791 fidl::encoding::BoundedString<256>,
1792 D,
1793 &mut self.key,
1794 decoder,
1795 offset + 0,
1796 _depth
1797 )?;
1798 fidl::decode!(NodePropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
1799 Ok(())
1800 }
1801 }
1802
1803 impl fidl::encoding::ValueTypeMarker for NodePropertyEntry {
1804 type Borrowed<'a> = &'a Self;
1805 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1806 value
1807 }
1808 }
1809
1810 unsafe impl fidl::encoding::TypeMarker for NodePropertyEntry {
1811 type Owned = Self;
1812
1813 #[inline(always)]
1814 fn inline_align(_context: fidl::encoding::Context) -> usize {
1815 8
1816 }
1817
1818 #[inline(always)]
1819 fn inline_size(_context: fidl::encoding::Context) -> usize {
1820 32
1821 }
1822 }
1823
1824 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyEntry, D>
1825 for &NodePropertyEntry
1826 {
1827 #[inline]
1828 unsafe fn encode(
1829 self,
1830 encoder: &mut fidl::encoding::Encoder<'_, D>,
1831 offset: usize,
1832 _depth: fidl::encoding::Depth,
1833 ) -> fidl::Result<()> {
1834 encoder.debug_check_bounds::<NodePropertyEntry>(offset);
1835 fidl::encoding::Encode::<NodePropertyEntry, D>::encode(
1837 (
1838 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1839 <fidl::encoding::Vector<NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
1840 ),
1841 encoder, offset, _depth
1842 )
1843 }
1844 }
1845 unsafe impl<
1846 D: fidl::encoding::ResourceDialect,
1847 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1848 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty, 64>, D>,
1849 > fidl::encoding::Encode<NodePropertyEntry, D> for (T0, T1)
1850 {
1851 #[inline]
1852 unsafe fn encode(
1853 self,
1854 encoder: &mut fidl::encoding::Encoder<'_, D>,
1855 offset: usize,
1856 depth: fidl::encoding::Depth,
1857 ) -> fidl::Result<()> {
1858 encoder.debug_check_bounds::<NodePropertyEntry>(offset);
1859 self.0.encode(encoder, offset + 0, depth)?;
1863 self.1.encode(encoder, offset + 16, depth)?;
1864 Ok(())
1865 }
1866 }
1867
1868 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyEntry {
1869 #[inline(always)]
1870 fn new_empty() -> Self {
1871 Self {
1872 name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1873 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty, 64>, D),
1874 }
1875 }
1876
1877 #[inline]
1878 unsafe fn decode(
1879 &mut self,
1880 decoder: &mut fidl::encoding::Decoder<'_, D>,
1881 offset: usize,
1882 _depth: fidl::encoding::Depth,
1883 ) -> fidl::Result<()> {
1884 decoder.debug_check_bounds::<Self>(offset);
1885 fidl::decode!(
1887 fidl::encoding::BoundedString<128>,
1888 D,
1889 &mut self.name,
1890 decoder,
1891 offset + 0,
1892 _depth
1893 )?;
1894 fidl::decode!(fidl::encoding::Vector<NodeProperty, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
1895 Ok(())
1896 }
1897 }
1898
1899 impl fidl::encoding::ValueTypeMarker for NodePropertyEntry2 {
1900 type Borrowed<'a> = &'a Self;
1901 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1902 value
1903 }
1904 }
1905
1906 unsafe impl fidl::encoding::TypeMarker for NodePropertyEntry2 {
1907 type Owned = Self;
1908
1909 #[inline(always)]
1910 fn inline_align(_context: fidl::encoding::Context) -> usize {
1911 8
1912 }
1913
1914 #[inline(always)]
1915 fn inline_size(_context: fidl::encoding::Context) -> usize {
1916 32
1917 }
1918 }
1919
1920 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyEntry2, D>
1921 for &NodePropertyEntry2
1922 {
1923 #[inline]
1924 unsafe fn encode(
1925 self,
1926 encoder: &mut fidl::encoding::Encoder<'_, D>,
1927 offset: usize,
1928 _depth: fidl::encoding::Depth,
1929 ) -> fidl::Result<()> {
1930 encoder.debug_check_bounds::<NodePropertyEntry2>(offset);
1931 fidl::encoding::Encode::<NodePropertyEntry2, D>::encode(
1933 (
1934 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1935 <fidl::encoding::Vector<NodeProperty2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
1936 ),
1937 encoder, offset, _depth
1938 )
1939 }
1940 }
1941 unsafe impl<
1942 D: fidl::encoding::ResourceDialect,
1943 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1944 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty2, 64>, D>,
1945 > fidl::encoding::Encode<NodePropertyEntry2, D> for (T0, T1)
1946 {
1947 #[inline]
1948 unsafe fn encode(
1949 self,
1950 encoder: &mut fidl::encoding::Encoder<'_, D>,
1951 offset: usize,
1952 depth: fidl::encoding::Depth,
1953 ) -> fidl::Result<()> {
1954 encoder.debug_check_bounds::<NodePropertyEntry2>(offset);
1955 self.0.encode(encoder, offset + 0, depth)?;
1959 self.1.encode(encoder, offset + 16, depth)?;
1960 Ok(())
1961 }
1962 }
1963
1964 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyEntry2 {
1965 #[inline(always)]
1966 fn new_empty() -> Self {
1967 Self {
1968 name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1969 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty2, 64>, D),
1970 }
1971 }
1972
1973 #[inline]
1974 unsafe fn decode(
1975 &mut self,
1976 decoder: &mut fidl::encoding::Decoder<'_, D>,
1977 offset: usize,
1978 _depth: fidl::encoding::Depth,
1979 ) -> fidl::Result<()> {
1980 decoder.debug_check_bounds::<Self>(offset);
1981 fidl::decode!(
1983 fidl::encoding::BoundedString<128>,
1984 D,
1985 &mut self.name,
1986 decoder,
1987 offset + 0,
1988 _depth
1989 )?;
1990 fidl::decode!(fidl::encoding::Vector<NodeProperty2, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
1991 Ok(())
1992 }
1993 }
1994
1995 impl fidl::encoding::ValueTypeMarker for ParentSpec {
1996 type Borrowed<'a> = &'a Self;
1997 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1998 value
1999 }
2000 }
2001
2002 unsafe impl fidl::encoding::TypeMarker for ParentSpec {
2003 type Owned = Self;
2004
2005 #[inline(always)]
2006 fn inline_align(_context: fidl::encoding::Context) -> usize {
2007 8
2008 }
2009
2010 #[inline(always)]
2011 fn inline_size(_context: fidl::encoding::Context) -> usize {
2012 32
2013 }
2014 }
2015
2016 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentSpec, D>
2017 for &ParentSpec
2018 {
2019 #[inline]
2020 unsafe fn encode(
2021 self,
2022 encoder: &mut fidl::encoding::Encoder<'_, D>,
2023 offset: usize,
2024 _depth: fidl::encoding::Depth,
2025 ) -> fidl::Result<()> {
2026 encoder.debug_check_bounds::<ParentSpec>(offset);
2027 fidl::encoding::Encode::<ParentSpec, D>::encode(
2029 (
2030 <fidl::encoding::Vector<BindRule, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.bind_rules),
2031 <fidl::encoding::Vector<NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
2032 ),
2033 encoder, offset, _depth
2034 )
2035 }
2036 }
2037 unsafe impl<
2038 D: fidl::encoding::ResourceDialect,
2039 T0: fidl::encoding::Encode<fidl::encoding::Vector<BindRule, 64>, D>,
2040 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty, 64>, D>,
2041 > fidl::encoding::Encode<ParentSpec, D> for (T0, T1)
2042 {
2043 #[inline]
2044 unsafe fn encode(
2045 self,
2046 encoder: &mut fidl::encoding::Encoder<'_, D>,
2047 offset: usize,
2048 depth: fidl::encoding::Depth,
2049 ) -> fidl::Result<()> {
2050 encoder.debug_check_bounds::<ParentSpec>(offset);
2051 self.0.encode(encoder, offset + 0, depth)?;
2055 self.1.encode(encoder, offset + 16, depth)?;
2056 Ok(())
2057 }
2058 }
2059
2060 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentSpec {
2061 #[inline(always)]
2062 fn new_empty() -> Self {
2063 Self {
2064 bind_rules: fidl::new_empty!(fidl::encoding::Vector<BindRule, 64>, D),
2065 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty, 64>, D),
2066 }
2067 }
2068
2069 #[inline]
2070 unsafe fn decode(
2071 &mut self,
2072 decoder: &mut fidl::encoding::Decoder<'_, D>,
2073 offset: usize,
2074 _depth: fidl::encoding::Depth,
2075 ) -> fidl::Result<()> {
2076 decoder.debug_check_bounds::<Self>(offset);
2077 fidl::decode!(fidl::encoding::Vector<BindRule, 64>, D, &mut self.bind_rules, decoder, offset + 0, _depth)?;
2079 fidl::decode!(fidl::encoding::Vector<NodeProperty, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2080 Ok(())
2081 }
2082 }
2083
2084 impl fidl::encoding::ValueTypeMarker for ParentSpec2 {
2085 type Borrowed<'a> = &'a Self;
2086 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2087 value
2088 }
2089 }
2090
2091 unsafe impl fidl::encoding::TypeMarker for ParentSpec2 {
2092 type Owned = Self;
2093
2094 #[inline(always)]
2095 fn inline_align(_context: fidl::encoding::Context) -> usize {
2096 8
2097 }
2098
2099 #[inline(always)]
2100 fn inline_size(_context: fidl::encoding::Context) -> usize {
2101 32
2102 }
2103 }
2104
2105 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentSpec2, D>
2106 for &ParentSpec2
2107 {
2108 #[inline]
2109 unsafe fn encode(
2110 self,
2111 encoder: &mut fidl::encoding::Encoder<'_, D>,
2112 offset: usize,
2113 _depth: fidl::encoding::Depth,
2114 ) -> fidl::Result<()> {
2115 encoder.debug_check_bounds::<ParentSpec2>(offset);
2116 fidl::encoding::Encode::<ParentSpec2, D>::encode(
2118 (
2119 <fidl::encoding::Vector<BindRule2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.bind_rules),
2120 <fidl::encoding::Vector<NodeProperty2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
2121 ),
2122 encoder, offset, _depth
2123 )
2124 }
2125 }
2126 unsafe impl<
2127 D: fidl::encoding::ResourceDialect,
2128 T0: fidl::encoding::Encode<fidl::encoding::Vector<BindRule2, 64>, D>,
2129 T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty2, 64>, D>,
2130 > fidl::encoding::Encode<ParentSpec2, D> for (T0, T1)
2131 {
2132 #[inline]
2133 unsafe fn encode(
2134 self,
2135 encoder: &mut fidl::encoding::Encoder<'_, D>,
2136 offset: usize,
2137 depth: fidl::encoding::Depth,
2138 ) -> fidl::Result<()> {
2139 encoder.debug_check_bounds::<ParentSpec2>(offset);
2140 self.0.encode(encoder, offset + 0, depth)?;
2144 self.1.encode(encoder, offset + 16, depth)?;
2145 Ok(())
2146 }
2147 }
2148
2149 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentSpec2 {
2150 #[inline(always)]
2151 fn new_empty() -> Self {
2152 Self {
2153 bind_rules: fidl::new_empty!(fidl::encoding::Vector<BindRule2, 64>, D),
2154 properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty2, 64>, D),
2155 }
2156 }
2157
2158 #[inline]
2159 unsafe fn decode(
2160 &mut self,
2161 decoder: &mut fidl::encoding::Decoder<'_, D>,
2162 offset: usize,
2163 _depth: fidl::encoding::Depth,
2164 ) -> fidl::Result<()> {
2165 decoder.debug_check_bounds::<Self>(offset);
2166 fidl::decode!(fidl::encoding::Vector<BindRule2, 64>, D, &mut self.bind_rules, decoder, offset + 0, _depth)?;
2168 fidl::decode!(fidl::encoding::Vector<NodeProperty2, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2169 Ok(())
2170 }
2171 }
2172
2173 impl BusInfo {
2174 #[inline(always)]
2175 fn max_ordinal_present(&self) -> u64 {
2176 if let Some(_) = self.address_stability {
2177 return 3;
2178 }
2179 if let Some(_) = self.address {
2180 return 2;
2181 }
2182 if let Some(_) = self.bus {
2183 return 1;
2184 }
2185 0
2186 }
2187 }
2188
2189 impl fidl::encoding::ValueTypeMarker for BusInfo {
2190 type Borrowed<'a> = &'a Self;
2191 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2192 value
2193 }
2194 }
2195
2196 unsafe impl fidl::encoding::TypeMarker for BusInfo {
2197 type Owned = Self;
2198
2199 #[inline(always)]
2200 fn inline_align(_context: fidl::encoding::Context) -> usize {
2201 8
2202 }
2203
2204 #[inline(always)]
2205 fn inline_size(_context: fidl::encoding::Context) -> usize {
2206 16
2207 }
2208 }
2209
2210 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BusInfo, D> for &BusInfo {
2211 unsafe fn encode(
2212 self,
2213 encoder: &mut fidl::encoding::Encoder<'_, D>,
2214 offset: usize,
2215 mut depth: fidl::encoding::Depth,
2216 ) -> fidl::Result<()> {
2217 encoder.debug_check_bounds::<BusInfo>(offset);
2218 let max_ordinal: u64 = self.max_ordinal_present();
2220 encoder.write_num(max_ordinal, offset);
2221 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2222 if max_ordinal == 0 {
2224 return Ok(());
2225 }
2226 depth.increment()?;
2227 let envelope_size = 8;
2228 let bytes_len = max_ordinal as usize * envelope_size;
2229 #[allow(unused_variables)]
2230 let offset = encoder.out_of_line_offset(bytes_len);
2231 let mut _prev_end_offset: usize = 0;
2232 if 1 > max_ordinal {
2233 return Ok(());
2234 }
2235
2236 let cur_offset: usize = (1 - 1) * envelope_size;
2239
2240 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2242
2243 fidl::encoding::encode_in_envelope_optional::<BusType, D>(
2248 self.bus.as_ref().map(<BusType as fidl::encoding::ValueTypeMarker>::borrow),
2249 encoder,
2250 offset + cur_offset,
2251 depth,
2252 )?;
2253
2254 _prev_end_offset = cur_offset + envelope_size;
2255 if 2 > max_ordinal {
2256 return Ok(());
2257 }
2258
2259 let cur_offset: usize = (2 - 1) * envelope_size;
2262
2263 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2265
2266 fidl::encoding::encode_in_envelope_optional::<DeviceAddress, D>(
2271 self.address
2272 .as_ref()
2273 .map(<DeviceAddress as fidl::encoding::ValueTypeMarker>::borrow),
2274 encoder,
2275 offset + cur_offset,
2276 depth,
2277 )?;
2278
2279 _prev_end_offset = cur_offset + envelope_size;
2280 if 3 > max_ordinal {
2281 return Ok(());
2282 }
2283
2284 let cur_offset: usize = (3 - 1) * envelope_size;
2287
2288 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2290
2291 fidl::encoding::encode_in_envelope_optional::<DeviceAddressStability, D>(
2296 self.address_stability
2297 .as_ref()
2298 .map(<DeviceAddressStability as fidl::encoding::ValueTypeMarker>::borrow),
2299 encoder,
2300 offset + cur_offset,
2301 depth,
2302 )?;
2303
2304 _prev_end_offset = cur_offset + envelope_size;
2305
2306 Ok(())
2307 }
2308 }
2309
2310 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BusInfo {
2311 #[inline(always)]
2312 fn new_empty() -> Self {
2313 Self::default()
2314 }
2315
2316 unsafe fn decode(
2317 &mut self,
2318 decoder: &mut fidl::encoding::Decoder<'_, D>,
2319 offset: usize,
2320 mut depth: fidl::encoding::Depth,
2321 ) -> fidl::Result<()> {
2322 decoder.debug_check_bounds::<Self>(offset);
2323 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2324 None => return Err(fidl::Error::NotNullable),
2325 Some(len) => len,
2326 };
2327 if len == 0 {
2329 return Ok(());
2330 };
2331 depth.increment()?;
2332 let envelope_size = 8;
2333 let bytes_len = len * envelope_size;
2334 let offset = decoder.out_of_line_offset(bytes_len)?;
2335 let mut _next_ordinal_to_read = 0;
2337 let mut next_offset = offset;
2338 let end_offset = offset + bytes_len;
2339 _next_ordinal_to_read += 1;
2340 if next_offset >= end_offset {
2341 return Ok(());
2342 }
2343
2344 while _next_ordinal_to_read < 1 {
2346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2347 _next_ordinal_to_read += 1;
2348 next_offset += envelope_size;
2349 }
2350
2351 let next_out_of_line = decoder.next_out_of_line();
2352 let handles_before = decoder.remaining_handles();
2353 if let Some((inlined, num_bytes, num_handles)) =
2354 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2355 {
2356 let member_inline_size =
2357 <BusType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2358 if inlined != (member_inline_size <= 4) {
2359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2360 }
2361 let inner_offset;
2362 let mut inner_depth = depth.clone();
2363 if inlined {
2364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2365 inner_offset = next_offset;
2366 } else {
2367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2368 inner_depth.increment()?;
2369 }
2370 let val_ref = self.bus.get_or_insert_with(|| fidl::new_empty!(BusType, D));
2371 fidl::decode!(BusType, D, val_ref, decoder, inner_offset, inner_depth)?;
2372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2373 {
2374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2375 }
2376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2378 }
2379 }
2380
2381 next_offset += envelope_size;
2382 _next_ordinal_to_read += 1;
2383 if next_offset >= end_offset {
2384 return Ok(());
2385 }
2386
2387 while _next_ordinal_to_read < 2 {
2389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2390 _next_ordinal_to_read += 1;
2391 next_offset += envelope_size;
2392 }
2393
2394 let next_out_of_line = decoder.next_out_of_line();
2395 let handles_before = decoder.remaining_handles();
2396 if let Some((inlined, num_bytes, num_handles)) =
2397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2398 {
2399 let member_inline_size =
2400 <DeviceAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2401 if inlined != (member_inline_size <= 4) {
2402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2403 }
2404 let inner_offset;
2405 let mut inner_depth = depth.clone();
2406 if inlined {
2407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2408 inner_offset = next_offset;
2409 } else {
2410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2411 inner_depth.increment()?;
2412 }
2413 let val_ref =
2414 self.address.get_or_insert_with(|| fidl::new_empty!(DeviceAddress, D));
2415 fidl::decode!(DeviceAddress, D, val_ref, decoder, inner_offset, inner_depth)?;
2416 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2417 {
2418 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2419 }
2420 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2421 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2422 }
2423 }
2424
2425 next_offset += envelope_size;
2426 _next_ordinal_to_read += 1;
2427 if next_offset >= end_offset {
2428 return Ok(());
2429 }
2430
2431 while _next_ordinal_to_read < 3 {
2433 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2434 _next_ordinal_to_read += 1;
2435 next_offset += envelope_size;
2436 }
2437
2438 let next_out_of_line = decoder.next_out_of_line();
2439 let handles_before = decoder.remaining_handles();
2440 if let Some((inlined, num_bytes, num_handles)) =
2441 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2442 {
2443 let member_inline_size =
2444 <DeviceAddressStability as fidl::encoding::TypeMarker>::inline_size(
2445 decoder.context,
2446 );
2447 if inlined != (member_inline_size <= 4) {
2448 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2449 }
2450 let inner_offset;
2451 let mut inner_depth = depth.clone();
2452 if inlined {
2453 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2454 inner_offset = next_offset;
2455 } else {
2456 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2457 inner_depth.increment()?;
2458 }
2459 let val_ref = self
2460 .address_stability
2461 .get_or_insert_with(|| fidl::new_empty!(DeviceAddressStability, D));
2462 fidl::decode!(
2463 DeviceAddressStability,
2464 D,
2465 val_ref,
2466 decoder,
2467 inner_offset,
2468 inner_depth
2469 )?;
2470 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2471 {
2472 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2473 }
2474 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2475 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2476 }
2477 }
2478
2479 next_offset += envelope_size;
2480
2481 while next_offset < end_offset {
2483 _next_ordinal_to_read += 1;
2484 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2485 next_offset += envelope_size;
2486 }
2487
2488 Ok(())
2489 }
2490 }
2491
2492 impl CompositeDriverInfo {
2493 #[inline(always)]
2494 fn max_ordinal_present(&self) -> u64 {
2495 if let Some(_) = self.driver_info {
2496 return 2;
2497 }
2498 if let Some(_) = self.composite_name {
2499 return 1;
2500 }
2501 0
2502 }
2503 }
2504
2505 impl fidl::encoding::ValueTypeMarker for CompositeDriverInfo {
2506 type Borrowed<'a> = &'a Self;
2507 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2508 value
2509 }
2510 }
2511
2512 unsafe impl fidl::encoding::TypeMarker for CompositeDriverInfo {
2513 type Owned = Self;
2514
2515 #[inline(always)]
2516 fn inline_align(_context: fidl::encoding::Context) -> usize {
2517 8
2518 }
2519
2520 #[inline(always)]
2521 fn inline_size(_context: fidl::encoding::Context) -> usize {
2522 16
2523 }
2524 }
2525
2526 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeDriverInfo, D>
2527 for &CompositeDriverInfo
2528 {
2529 unsafe fn encode(
2530 self,
2531 encoder: &mut fidl::encoding::Encoder<'_, D>,
2532 offset: usize,
2533 mut depth: fidl::encoding::Depth,
2534 ) -> fidl::Result<()> {
2535 encoder.debug_check_bounds::<CompositeDriverInfo>(offset);
2536 let max_ordinal: u64 = self.max_ordinal_present();
2538 encoder.write_num(max_ordinal, offset);
2539 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2540 if max_ordinal == 0 {
2542 return Ok(());
2543 }
2544 depth.increment()?;
2545 let envelope_size = 8;
2546 let bytes_len = max_ordinal as usize * envelope_size;
2547 #[allow(unused_variables)]
2548 let offset = encoder.out_of_line_offset(bytes_len);
2549 let mut _prev_end_offset: usize = 0;
2550 if 1 > max_ordinal {
2551 return Ok(());
2552 }
2553
2554 let cur_offset: usize = (1 - 1) * envelope_size;
2557
2558 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2560
2561 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
2566 self.composite_name.as_ref().map(
2567 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
2568 ),
2569 encoder,
2570 offset + cur_offset,
2571 depth,
2572 )?;
2573
2574 _prev_end_offset = cur_offset + envelope_size;
2575 if 2 > max_ordinal {
2576 return Ok(());
2577 }
2578
2579 let cur_offset: usize = (2 - 1) * envelope_size;
2582
2583 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2585
2586 fidl::encoding::encode_in_envelope_optional::<DriverInfo, D>(
2591 self.driver_info
2592 .as_ref()
2593 .map(<DriverInfo as fidl::encoding::ValueTypeMarker>::borrow),
2594 encoder,
2595 offset + cur_offset,
2596 depth,
2597 )?;
2598
2599 _prev_end_offset = cur_offset + envelope_size;
2600
2601 Ok(())
2602 }
2603 }
2604
2605 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeDriverInfo {
2606 #[inline(always)]
2607 fn new_empty() -> Self {
2608 Self::default()
2609 }
2610
2611 unsafe fn decode(
2612 &mut self,
2613 decoder: &mut fidl::encoding::Decoder<'_, D>,
2614 offset: usize,
2615 mut depth: fidl::encoding::Depth,
2616 ) -> fidl::Result<()> {
2617 decoder.debug_check_bounds::<Self>(offset);
2618 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2619 None => return Err(fidl::Error::NotNullable),
2620 Some(len) => len,
2621 };
2622 if len == 0 {
2624 return Ok(());
2625 };
2626 depth.increment()?;
2627 let envelope_size = 8;
2628 let bytes_len = len * envelope_size;
2629 let offset = decoder.out_of_line_offset(bytes_len)?;
2630 let mut _next_ordinal_to_read = 0;
2632 let mut next_offset = offset;
2633 let end_offset = offset + bytes_len;
2634 _next_ordinal_to_read += 1;
2635 if next_offset >= end_offset {
2636 return Ok(());
2637 }
2638
2639 while _next_ordinal_to_read < 1 {
2641 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2642 _next_ordinal_to_read += 1;
2643 next_offset += envelope_size;
2644 }
2645
2646 let next_out_of_line = decoder.next_out_of_line();
2647 let handles_before = decoder.remaining_handles();
2648 if let Some((inlined, num_bytes, num_handles)) =
2649 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2650 {
2651 let member_inline_size =
2652 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2653 decoder.context,
2654 );
2655 if inlined != (member_inline_size <= 4) {
2656 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2657 }
2658 let inner_offset;
2659 let mut inner_depth = depth.clone();
2660 if inlined {
2661 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2662 inner_offset = next_offset;
2663 } else {
2664 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2665 inner_depth.increment()?;
2666 }
2667 let val_ref = self
2668 .composite_name
2669 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2670 fidl::decode!(
2671 fidl::encoding::UnboundedString,
2672 D,
2673 val_ref,
2674 decoder,
2675 inner_offset,
2676 inner_depth
2677 )?;
2678 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2679 {
2680 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2681 }
2682 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2683 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2684 }
2685 }
2686
2687 next_offset += envelope_size;
2688 _next_ordinal_to_read += 1;
2689 if next_offset >= end_offset {
2690 return Ok(());
2691 }
2692
2693 while _next_ordinal_to_read < 2 {
2695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2696 _next_ordinal_to_read += 1;
2697 next_offset += envelope_size;
2698 }
2699
2700 let next_out_of_line = decoder.next_out_of_line();
2701 let handles_before = decoder.remaining_handles();
2702 if let Some((inlined, num_bytes, num_handles)) =
2703 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2704 {
2705 let member_inline_size =
2706 <DriverInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2707 if inlined != (member_inline_size <= 4) {
2708 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2709 }
2710 let inner_offset;
2711 let mut inner_depth = depth.clone();
2712 if inlined {
2713 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2714 inner_offset = next_offset;
2715 } else {
2716 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2717 inner_depth.increment()?;
2718 }
2719 let val_ref =
2720 self.driver_info.get_or_insert_with(|| fidl::new_empty!(DriverInfo, D));
2721 fidl::decode!(DriverInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2722 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2723 {
2724 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2725 }
2726 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2727 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2728 }
2729 }
2730
2731 next_offset += envelope_size;
2732
2733 while next_offset < end_offset {
2735 _next_ordinal_to_read += 1;
2736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2737 next_offset += envelope_size;
2738 }
2739
2740 Ok(())
2741 }
2742 }
2743
2744 impl CompositeDriverMatch {
2745 #[inline(always)]
2746 fn max_ordinal_present(&self) -> u64 {
2747 if let Some(_) = self.primary_parent_index {
2748 return 3;
2749 }
2750 if let Some(_) = self.parent_names {
2751 return 2;
2752 }
2753 if let Some(_) = self.composite_driver {
2754 return 1;
2755 }
2756 0
2757 }
2758 }
2759
2760 impl fidl::encoding::ValueTypeMarker for CompositeDriverMatch {
2761 type Borrowed<'a> = &'a Self;
2762 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2763 value
2764 }
2765 }
2766
2767 unsafe impl fidl::encoding::TypeMarker for CompositeDriverMatch {
2768 type Owned = Self;
2769
2770 #[inline(always)]
2771 fn inline_align(_context: fidl::encoding::Context) -> usize {
2772 8
2773 }
2774
2775 #[inline(always)]
2776 fn inline_size(_context: fidl::encoding::Context) -> usize {
2777 16
2778 }
2779 }
2780
2781 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeDriverMatch, D>
2782 for &CompositeDriverMatch
2783 {
2784 unsafe fn encode(
2785 self,
2786 encoder: &mut fidl::encoding::Encoder<'_, D>,
2787 offset: usize,
2788 mut depth: fidl::encoding::Depth,
2789 ) -> fidl::Result<()> {
2790 encoder.debug_check_bounds::<CompositeDriverMatch>(offset);
2791 let max_ordinal: u64 = self.max_ordinal_present();
2793 encoder.write_num(max_ordinal, offset);
2794 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2795 if max_ordinal == 0 {
2797 return Ok(());
2798 }
2799 depth.increment()?;
2800 let envelope_size = 8;
2801 let bytes_len = max_ordinal as usize * envelope_size;
2802 #[allow(unused_variables)]
2803 let offset = encoder.out_of_line_offset(bytes_len);
2804 let mut _prev_end_offset: usize = 0;
2805 if 1 > max_ordinal {
2806 return Ok(());
2807 }
2808
2809 let cur_offset: usize = (1 - 1) * envelope_size;
2812
2813 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2815
2816 fidl::encoding::encode_in_envelope_optional::<CompositeDriverInfo, D>(
2821 self.composite_driver
2822 .as_ref()
2823 .map(<CompositeDriverInfo as fidl::encoding::ValueTypeMarker>::borrow),
2824 encoder,
2825 offset + cur_offset,
2826 depth,
2827 )?;
2828
2829 _prev_end_offset = cur_offset + envelope_size;
2830 if 2 > max_ordinal {
2831 return Ok(());
2832 }
2833
2834 let cur_offset: usize = (2 - 1) * envelope_size;
2837
2838 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2840
2841 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, D>(
2846 self.parent_names.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow),
2847 encoder, offset + cur_offset, depth
2848 )?;
2849
2850 _prev_end_offset = cur_offset + envelope_size;
2851 if 3 > max_ordinal {
2852 return Ok(());
2853 }
2854
2855 let cur_offset: usize = (3 - 1) * envelope_size;
2858
2859 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2861
2862 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2867 self.primary_parent_index
2868 .as_ref()
2869 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2870 encoder,
2871 offset + cur_offset,
2872 depth,
2873 )?;
2874
2875 _prev_end_offset = cur_offset + envelope_size;
2876
2877 Ok(())
2878 }
2879 }
2880
2881 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeDriverMatch {
2882 #[inline(always)]
2883 fn new_empty() -> Self {
2884 Self::default()
2885 }
2886
2887 unsafe fn decode(
2888 &mut self,
2889 decoder: &mut fidl::encoding::Decoder<'_, D>,
2890 offset: usize,
2891 mut depth: fidl::encoding::Depth,
2892 ) -> fidl::Result<()> {
2893 decoder.debug_check_bounds::<Self>(offset);
2894 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2895 None => return Err(fidl::Error::NotNullable),
2896 Some(len) => len,
2897 };
2898 if len == 0 {
2900 return Ok(());
2901 };
2902 depth.increment()?;
2903 let envelope_size = 8;
2904 let bytes_len = len * envelope_size;
2905 let offset = decoder.out_of_line_offset(bytes_len)?;
2906 let mut _next_ordinal_to_read = 0;
2908 let mut next_offset = offset;
2909 let end_offset = offset + bytes_len;
2910 _next_ordinal_to_read += 1;
2911 if next_offset >= end_offset {
2912 return Ok(());
2913 }
2914
2915 while _next_ordinal_to_read < 1 {
2917 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2918 _next_ordinal_to_read += 1;
2919 next_offset += envelope_size;
2920 }
2921
2922 let next_out_of_line = decoder.next_out_of_line();
2923 let handles_before = decoder.remaining_handles();
2924 if let Some((inlined, num_bytes, num_handles)) =
2925 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2926 {
2927 let member_inline_size =
2928 <CompositeDriverInfo as fidl::encoding::TypeMarker>::inline_size(
2929 decoder.context,
2930 );
2931 if inlined != (member_inline_size <= 4) {
2932 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2933 }
2934 let inner_offset;
2935 let mut inner_depth = depth.clone();
2936 if inlined {
2937 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2938 inner_offset = next_offset;
2939 } else {
2940 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2941 inner_depth.increment()?;
2942 }
2943 let val_ref = self
2944 .composite_driver
2945 .get_or_insert_with(|| fidl::new_empty!(CompositeDriverInfo, D));
2946 fidl::decode!(CompositeDriverInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2947 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2948 {
2949 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2950 }
2951 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2952 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2953 }
2954 }
2955
2956 next_offset += envelope_size;
2957 _next_ordinal_to_read += 1;
2958 if next_offset >= end_offset {
2959 return Ok(());
2960 }
2961
2962 while _next_ordinal_to_read < 2 {
2964 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2965 _next_ordinal_to_read += 1;
2966 next_offset += envelope_size;
2967 }
2968
2969 let next_out_of_line = decoder.next_out_of_line();
2970 let handles_before = decoder.remaining_handles();
2971 if let Some((inlined, num_bytes, num_handles)) =
2972 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2973 {
2974 let member_inline_size = <fidl::encoding::UnboundedVector<
2975 fidl::encoding::UnboundedString,
2976 > as fidl::encoding::TypeMarker>::inline_size(
2977 decoder.context
2978 );
2979 if inlined != (member_inline_size <= 4) {
2980 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2981 }
2982 let inner_offset;
2983 let mut inner_depth = depth.clone();
2984 if inlined {
2985 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2986 inner_offset = next_offset;
2987 } else {
2988 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2989 inner_depth.increment()?;
2990 }
2991 let val_ref = self.parent_names.get_or_insert_with(|| {
2992 fidl::new_empty!(
2993 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2994 D
2995 )
2996 });
2997 fidl::decode!(
2998 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2999 D,
3000 val_ref,
3001 decoder,
3002 inner_offset,
3003 inner_depth
3004 )?;
3005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3006 {
3007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3008 }
3009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3011 }
3012 }
3013
3014 next_offset += envelope_size;
3015 _next_ordinal_to_read += 1;
3016 if next_offset >= end_offset {
3017 return Ok(());
3018 }
3019
3020 while _next_ordinal_to_read < 3 {
3022 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3023 _next_ordinal_to_read += 1;
3024 next_offset += envelope_size;
3025 }
3026
3027 let next_out_of_line = decoder.next_out_of_line();
3028 let handles_before = decoder.remaining_handles();
3029 if let Some((inlined, num_bytes, num_handles)) =
3030 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3031 {
3032 let member_inline_size =
3033 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3034 if inlined != (member_inline_size <= 4) {
3035 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3036 }
3037 let inner_offset;
3038 let mut inner_depth = depth.clone();
3039 if inlined {
3040 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3041 inner_offset = next_offset;
3042 } else {
3043 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3044 inner_depth.increment()?;
3045 }
3046 let val_ref =
3047 self.primary_parent_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
3048 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3049 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3050 {
3051 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3052 }
3053 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3054 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3055 }
3056 }
3057
3058 next_offset += envelope_size;
3059
3060 while next_offset < end_offset {
3062 _next_ordinal_to_read += 1;
3063 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3064 next_offset += envelope_size;
3065 }
3066
3067 Ok(())
3068 }
3069 }
3070
3071 impl CompositeInfo {
3072 #[inline(always)]
3073 fn max_ordinal_present(&self) -> u64 {
3074 if let Some(_) = self.matched_driver {
3075 return 2;
3076 }
3077 if let Some(_) = self.spec {
3078 return 1;
3079 }
3080 0
3081 }
3082 }
3083
3084 impl fidl::encoding::ValueTypeMarker for CompositeInfo {
3085 type Borrowed<'a> = &'a Self;
3086 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3087 value
3088 }
3089 }
3090
3091 unsafe impl fidl::encoding::TypeMarker for CompositeInfo {
3092 type Owned = Self;
3093
3094 #[inline(always)]
3095 fn inline_align(_context: fidl::encoding::Context) -> usize {
3096 8
3097 }
3098
3099 #[inline(always)]
3100 fn inline_size(_context: fidl::encoding::Context) -> usize {
3101 16
3102 }
3103 }
3104
3105 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeInfo, D>
3106 for &CompositeInfo
3107 {
3108 unsafe fn encode(
3109 self,
3110 encoder: &mut fidl::encoding::Encoder<'_, D>,
3111 offset: usize,
3112 mut depth: fidl::encoding::Depth,
3113 ) -> fidl::Result<()> {
3114 encoder.debug_check_bounds::<CompositeInfo>(offset);
3115 let max_ordinal: u64 = self.max_ordinal_present();
3117 encoder.write_num(max_ordinal, offset);
3118 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3119 if max_ordinal == 0 {
3121 return Ok(());
3122 }
3123 depth.increment()?;
3124 let envelope_size = 8;
3125 let bytes_len = max_ordinal as usize * envelope_size;
3126 #[allow(unused_variables)]
3127 let offset = encoder.out_of_line_offset(bytes_len);
3128 let mut _prev_end_offset: usize = 0;
3129 if 1 > max_ordinal {
3130 return Ok(());
3131 }
3132
3133 let cur_offset: usize = (1 - 1) * envelope_size;
3136
3137 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3139
3140 fidl::encoding::encode_in_envelope_optional::<CompositeNodeSpec, D>(
3145 self.spec
3146 .as_ref()
3147 .map(<CompositeNodeSpec as fidl::encoding::ValueTypeMarker>::borrow),
3148 encoder,
3149 offset + cur_offset,
3150 depth,
3151 )?;
3152
3153 _prev_end_offset = cur_offset + envelope_size;
3154 if 2 > max_ordinal {
3155 return Ok(());
3156 }
3157
3158 let cur_offset: usize = (2 - 1) * envelope_size;
3161
3162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3164
3165 fidl::encoding::encode_in_envelope_optional::<CompositeDriverMatch, D>(
3170 self.matched_driver
3171 .as_ref()
3172 .map(<CompositeDriverMatch as fidl::encoding::ValueTypeMarker>::borrow),
3173 encoder,
3174 offset + cur_offset,
3175 depth,
3176 )?;
3177
3178 _prev_end_offset = cur_offset + envelope_size;
3179
3180 Ok(())
3181 }
3182 }
3183
3184 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeInfo {
3185 #[inline(always)]
3186 fn new_empty() -> Self {
3187 Self::default()
3188 }
3189
3190 unsafe fn decode(
3191 &mut self,
3192 decoder: &mut fidl::encoding::Decoder<'_, D>,
3193 offset: usize,
3194 mut depth: fidl::encoding::Depth,
3195 ) -> fidl::Result<()> {
3196 decoder.debug_check_bounds::<Self>(offset);
3197 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3198 None => return Err(fidl::Error::NotNullable),
3199 Some(len) => len,
3200 };
3201 if len == 0 {
3203 return Ok(());
3204 };
3205 depth.increment()?;
3206 let envelope_size = 8;
3207 let bytes_len = len * envelope_size;
3208 let offset = decoder.out_of_line_offset(bytes_len)?;
3209 let mut _next_ordinal_to_read = 0;
3211 let mut next_offset = offset;
3212 let end_offset = offset + bytes_len;
3213 _next_ordinal_to_read += 1;
3214 if next_offset >= end_offset {
3215 return Ok(());
3216 }
3217
3218 while _next_ordinal_to_read < 1 {
3220 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3221 _next_ordinal_to_read += 1;
3222 next_offset += envelope_size;
3223 }
3224
3225 let next_out_of_line = decoder.next_out_of_line();
3226 let handles_before = decoder.remaining_handles();
3227 if let Some((inlined, num_bytes, num_handles)) =
3228 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3229 {
3230 let member_inline_size =
3231 <CompositeNodeSpec as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3232 if inlined != (member_inline_size <= 4) {
3233 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3234 }
3235 let inner_offset;
3236 let mut inner_depth = depth.clone();
3237 if inlined {
3238 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3239 inner_offset = next_offset;
3240 } else {
3241 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3242 inner_depth.increment()?;
3243 }
3244 let val_ref =
3245 self.spec.get_or_insert_with(|| fidl::new_empty!(CompositeNodeSpec, D));
3246 fidl::decode!(CompositeNodeSpec, D, val_ref, decoder, inner_offset, inner_depth)?;
3247 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3248 {
3249 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3250 }
3251 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3252 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3253 }
3254 }
3255
3256 next_offset += envelope_size;
3257 _next_ordinal_to_read += 1;
3258 if next_offset >= end_offset {
3259 return Ok(());
3260 }
3261
3262 while _next_ordinal_to_read < 2 {
3264 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3265 _next_ordinal_to_read += 1;
3266 next_offset += envelope_size;
3267 }
3268
3269 let next_out_of_line = decoder.next_out_of_line();
3270 let handles_before = decoder.remaining_handles();
3271 if let Some((inlined, num_bytes, num_handles)) =
3272 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3273 {
3274 let member_inline_size =
3275 <CompositeDriverMatch as fidl::encoding::TypeMarker>::inline_size(
3276 decoder.context,
3277 );
3278 if inlined != (member_inline_size <= 4) {
3279 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3280 }
3281 let inner_offset;
3282 let mut inner_depth = depth.clone();
3283 if inlined {
3284 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3285 inner_offset = next_offset;
3286 } else {
3287 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3288 inner_depth.increment()?;
3289 }
3290 let val_ref = self
3291 .matched_driver
3292 .get_or_insert_with(|| fidl::new_empty!(CompositeDriverMatch, D));
3293 fidl::decode!(
3294 CompositeDriverMatch,
3295 D,
3296 val_ref,
3297 decoder,
3298 inner_offset,
3299 inner_depth
3300 )?;
3301 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3302 {
3303 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3304 }
3305 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3306 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3307 }
3308 }
3309
3310 next_offset += envelope_size;
3311
3312 while next_offset < end_offset {
3314 _next_ordinal_to_read += 1;
3315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3316 next_offset += envelope_size;
3317 }
3318
3319 Ok(())
3320 }
3321 }
3322
3323 impl CompositeNodeSpec {
3324 #[inline(always)]
3325 fn max_ordinal_present(&self) -> u64 {
3326 if let Some(_) = self.parents2 {
3327 return 3;
3328 }
3329 if let Some(_) = self.parents {
3330 return 2;
3331 }
3332 if let Some(_) = self.name {
3333 return 1;
3334 }
3335 0
3336 }
3337 }
3338
3339 impl fidl::encoding::ValueTypeMarker for CompositeNodeSpec {
3340 type Borrowed<'a> = &'a Self;
3341 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3342 value
3343 }
3344 }
3345
3346 unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpec {
3347 type Owned = Self;
3348
3349 #[inline(always)]
3350 fn inline_align(_context: fidl::encoding::Context) -> usize {
3351 8
3352 }
3353
3354 #[inline(always)]
3355 fn inline_size(_context: fidl::encoding::Context) -> usize {
3356 16
3357 }
3358 }
3359
3360 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeNodeSpec, D>
3361 for &CompositeNodeSpec
3362 {
3363 unsafe fn encode(
3364 self,
3365 encoder: &mut fidl::encoding::Encoder<'_, D>,
3366 offset: usize,
3367 mut depth: fidl::encoding::Depth,
3368 ) -> fidl::Result<()> {
3369 encoder.debug_check_bounds::<CompositeNodeSpec>(offset);
3370 let max_ordinal: u64 = self.max_ordinal_present();
3372 encoder.write_num(max_ordinal, offset);
3373 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3374 if max_ordinal == 0 {
3376 return Ok(());
3377 }
3378 depth.increment()?;
3379 let envelope_size = 8;
3380 let bytes_len = max_ordinal as usize * envelope_size;
3381 #[allow(unused_variables)]
3382 let offset = encoder.out_of_line_offset(bytes_len);
3383 let mut _prev_end_offset: usize = 0;
3384 if 1 > max_ordinal {
3385 return Ok(());
3386 }
3387
3388 let cur_offset: usize = (1 - 1) * envelope_size;
3391
3392 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3394
3395 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3400 self.name.as_ref().map(
3401 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3402 ),
3403 encoder,
3404 offset + cur_offset,
3405 depth,
3406 )?;
3407
3408 _prev_end_offset = cur_offset + envelope_size;
3409 if 2 > max_ordinal {
3410 return Ok(());
3411 }
3412
3413 let cur_offset: usize = (2 - 1) * envelope_size;
3416
3417 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3419
3420 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ParentSpec>, D>(
3425 self.parents.as_ref().map(<fidl::encoding::UnboundedVector<ParentSpec> as fidl::encoding::ValueTypeMarker>::borrow),
3426 encoder, offset + cur_offset, depth
3427 )?;
3428
3429 _prev_end_offset = cur_offset + envelope_size;
3430 if 3 > max_ordinal {
3431 return Ok(());
3432 }
3433
3434 let cur_offset: usize = (3 - 1) * envelope_size;
3437
3438 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3440
3441 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ParentSpec2>, D>(
3446 self.parents2.as_ref().map(<fidl::encoding::UnboundedVector<ParentSpec2> as fidl::encoding::ValueTypeMarker>::borrow),
3447 encoder, offset + cur_offset, depth
3448 )?;
3449
3450 _prev_end_offset = cur_offset + envelope_size;
3451
3452 Ok(())
3453 }
3454 }
3455
3456 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeNodeSpec {
3457 #[inline(always)]
3458 fn new_empty() -> Self {
3459 Self::default()
3460 }
3461
3462 unsafe fn decode(
3463 &mut self,
3464 decoder: &mut fidl::encoding::Decoder<'_, D>,
3465 offset: usize,
3466 mut depth: fidl::encoding::Depth,
3467 ) -> fidl::Result<()> {
3468 decoder.debug_check_bounds::<Self>(offset);
3469 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3470 None => return Err(fidl::Error::NotNullable),
3471 Some(len) => len,
3472 };
3473 if len == 0 {
3475 return Ok(());
3476 };
3477 depth.increment()?;
3478 let envelope_size = 8;
3479 let bytes_len = len * envelope_size;
3480 let offset = decoder.out_of_line_offset(bytes_len)?;
3481 let mut _next_ordinal_to_read = 0;
3483 let mut next_offset = offset;
3484 let end_offset = offset + bytes_len;
3485 _next_ordinal_to_read += 1;
3486 if next_offset >= end_offset {
3487 return Ok(());
3488 }
3489
3490 while _next_ordinal_to_read < 1 {
3492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3493 _next_ordinal_to_read += 1;
3494 next_offset += envelope_size;
3495 }
3496
3497 let next_out_of_line = decoder.next_out_of_line();
3498 let handles_before = decoder.remaining_handles();
3499 if let Some((inlined, num_bytes, num_handles)) =
3500 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3501 {
3502 let member_inline_size =
3503 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
3504 decoder.context,
3505 );
3506 if inlined != (member_inline_size <= 4) {
3507 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3508 }
3509 let inner_offset;
3510 let mut inner_depth = depth.clone();
3511 if inlined {
3512 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3513 inner_offset = next_offset;
3514 } else {
3515 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3516 inner_depth.increment()?;
3517 }
3518 let val_ref = self
3519 .name
3520 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3521 fidl::decode!(
3522 fidl::encoding::UnboundedString,
3523 D,
3524 val_ref,
3525 decoder,
3526 inner_offset,
3527 inner_depth
3528 )?;
3529 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3530 {
3531 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3532 }
3533 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3534 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3535 }
3536 }
3537
3538 next_offset += envelope_size;
3539 _next_ordinal_to_read += 1;
3540 if next_offset >= end_offset {
3541 return Ok(());
3542 }
3543
3544 while _next_ordinal_to_read < 2 {
3546 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3547 _next_ordinal_to_read += 1;
3548 next_offset += envelope_size;
3549 }
3550
3551 let next_out_of_line = decoder.next_out_of_line();
3552 let handles_before = decoder.remaining_handles();
3553 if let Some((inlined, num_bytes, num_handles)) =
3554 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3555 {
3556 let member_inline_size = <fidl::encoding::UnboundedVector<ParentSpec> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3557 if inlined != (member_inline_size <= 4) {
3558 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3559 }
3560 let inner_offset;
3561 let mut inner_depth = depth.clone();
3562 if inlined {
3563 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3564 inner_offset = next_offset;
3565 } else {
3566 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3567 inner_depth.increment()?;
3568 }
3569 let val_ref = self.parents.get_or_insert_with(|| {
3570 fidl::new_empty!(fidl::encoding::UnboundedVector<ParentSpec>, D)
3571 });
3572 fidl::decode!(
3573 fidl::encoding::UnboundedVector<ParentSpec>,
3574 D,
3575 val_ref,
3576 decoder,
3577 inner_offset,
3578 inner_depth
3579 )?;
3580 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3581 {
3582 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3583 }
3584 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3585 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3586 }
3587 }
3588
3589 next_offset += envelope_size;
3590 _next_ordinal_to_read += 1;
3591 if next_offset >= end_offset {
3592 return Ok(());
3593 }
3594
3595 while _next_ordinal_to_read < 3 {
3597 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3598 _next_ordinal_to_read += 1;
3599 next_offset += envelope_size;
3600 }
3601
3602 let next_out_of_line = decoder.next_out_of_line();
3603 let handles_before = decoder.remaining_handles();
3604 if let Some((inlined, num_bytes, num_handles)) =
3605 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3606 {
3607 let member_inline_size = <fidl::encoding::UnboundedVector<ParentSpec2> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3608 if inlined != (member_inline_size <= 4) {
3609 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3610 }
3611 let inner_offset;
3612 let mut inner_depth = depth.clone();
3613 if inlined {
3614 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3615 inner_offset = next_offset;
3616 } else {
3617 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3618 inner_depth.increment()?;
3619 }
3620 let val_ref = self.parents2.get_or_insert_with(|| {
3621 fidl::new_empty!(fidl::encoding::UnboundedVector<ParentSpec2>, D)
3622 });
3623 fidl::decode!(
3624 fidl::encoding::UnboundedVector<ParentSpec2>,
3625 D,
3626 val_ref,
3627 decoder,
3628 inner_offset,
3629 inner_depth
3630 )?;
3631 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3632 {
3633 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3634 }
3635 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3636 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3637 }
3638 }
3639
3640 next_offset += envelope_size;
3641
3642 while next_offset < end_offset {
3644 _next_ordinal_to_read += 1;
3645 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3646 next_offset += envelope_size;
3647 }
3648
3649 Ok(())
3650 }
3651 }
3652
3653 impl CompositeParent {
3654 #[inline(always)]
3655 fn max_ordinal_present(&self) -> u64 {
3656 if let Some(_) = self.index {
3657 return 2;
3658 }
3659 if let Some(_) = self.composite {
3660 return 1;
3661 }
3662 0
3663 }
3664 }
3665
3666 impl fidl::encoding::ValueTypeMarker for CompositeParent {
3667 type Borrowed<'a> = &'a Self;
3668 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3669 value
3670 }
3671 }
3672
3673 unsafe impl fidl::encoding::TypeMarker for CompositeParent {
3674 type Owned = Self;
3675
3676 #[inline(always)]
3677 fn inline_align(_context: fidl::encoding::Context) -> usize {
3678 8
3679 }
3680
3681 #[inline(always)]
3682 fn inline_size(_context: fidl::encoding::Context) -> usize {
3683 16
3684 }
3685 }
3686
3687 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeParent, D>
3688 for &CompositeParent
3689 {
3690 unsafe fn encode(
3691 self,
3692 encoder: &mut fidl::encoding::Encoder<'_, D>,
3693 offset: usize,
3694 mut depth: fidl::encoding::Depth,
3695 ) -> fidl::Result<()> {
3696 encoder.debug_check_bounds::<CompositeParent>(offset);
3697 let max_ordinal: u64 = self.max_ordinal_present();
3699 encoder.write_num(max_ordinal, offset);
3700 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3701 if max_ordinal == 0 {
3703 return Ok(());
3704 }
3705 depth.increment()?;
3706 let envelope_size = 8;
3707 let bytes_len = max_ordinal as usize * envelope_size;
3708 #[allow(unused_variables)]
3709 let offset = encoder.out_of_line_offset(bytes_len);
3710 let mut _prev_end_offset: usize = 0;
3711 if 1 > max_ordinal {
3712 return Ok(());
3713 }
3714
3715 let cur_offset: usize = (1 - 1) * envelope_size;
3718
3719 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3721
3722 fidl::encoding::encode_in_envelope_optional::<CompositeInfo, D>(
3727 self.composite
3728 .as_ref()
3729 .map(<CompositeInfo as fidl::encoding::ValueTypeMarker>::borrow),
3730 encoder,
3731 offset + cur_offset,
3732 depth,
3733 )?;
3734
3735 _prev_end_offset = cur_offset + envelope_size;
3736 if 2 > max_ordinal {
3737 return Ok(());
3738 }
3739
3740 let cur_offset: usize = (2 - 1) * envelope_size;
3743
3744 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3746
3747 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3752 self.index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3753 encoder,
3754 offset + cur_offset,
3755 depth,
3756 )?;
3757
3758 _prev_end_offset = cur_offset + envelope_size;
3759
3760 Ok(())
3761 }
3762 }
3763
3764 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeParent {
3765 #[inline(always)]
3766 fn new_empty() -> Self {
3767 Self::default()
3768 }
3769
3770 unsafe fn decode(
3771 &mut self,
3772 decoder: &mut fidl::encoding::Decoder<'_, D>,
3773 offset: usize,
3774 mut depth: fidl::encoding::Depth,
3775 ) -> fidl::Result<()> {
3776 decoder.debug_check_bounds::<Self>(offset);
3777 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3778 None => return Err(fidl::Error::NotNullable),
3779 Some(len) => len,
3780 };
3781 if len == 0 {
3783 return Ok(());
3784 };
3785 depth.increment()?;
3786 let envelope_size = 8;
3787 let bytes_len = len * envelope_size;
3788 let offset = decoder.out_of_line_offset(bytes_len)?;
3789 let mut _next_ordinal_to_read = 0;
3791 let mut next_offset = offset;
3792 let end_offset = offset + bytes_len;
3793 _next_ordinal_to_read += 1;
3794 if next_offset >= end_offset {
3795 return Ok(());
3796 }
3797
3798 while _next_ordinal_to_read < 1 {
3800 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3801 _next_ordinal_to_read += 1;
3802 next_offset += envelope_size;
3803 }
3804
3805 let next_out_of_line = decoder.next_out_of_line();
3806 let handles_before = decoder.remaining_handles();
3807 if let Some((inlined, num_bytes, num_handles)) =
3808 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3809 {
3810 let member_inline_size =
3811 <CompositeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3812 if inlined != (member_inline_size <= 4) {
3813 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3814 }
3815 let inner_offset;
3816 let mut inner_depth = depth.clone();
3817 if inlined {
3818 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3819 inner_offset = next_offset;
3820 } else {
3821 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3822 inner_depth.increment()?;
3823 }
3824 let val_ref =
3825 self.composite.get_or_insert_with(|| fidl::new_empty!(CompositeInfo, D));
3826 fidl::decode!(CompositeInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3827 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3828 {
3829 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3830 }
3831 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3832 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3833 }
3834 }
3835
3836 next_offset += envelope_size;
3837 _next_ordinal_to_read += 1;
3838 if next_offset >= end_offset {
3839 return Ok(());
3840 }
3841
3842 while _next_ordinal_to_read < 2 {
3844 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3845 _next_ordinal_to_read += 1;
3846 next_offset += envelope_size;
3847 }
3848
3849 let next_out_of_line = decoder.next_out_of_line();
3850 let handles_before = decoder.remaining_handles();
3851 if let Some((inlined, num_bytes, num_handles)) =
3852 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3853 {
3854 let member_inline_size =
3855 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3856 if inlined != (member_inline_size <= 4) {
3857 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3858 }
3859 let inner_offset;
3860 let mut inner_depth = depth.clone();
3861 if inlined {
3862 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3863 inner_offset = next_offset;
3864 } else {
3865 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3866 inner_depth.increment()?;
3867 }
3868 let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u32, D));
3869 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3870 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3871 {
3872 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3873 }
3874 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3875 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3876 }
3877 }
3878
3879 next_offset += envelope_size;
3880
3881 while next_offset < end_offset {
3883 _next_ordinal_to_read += 1;
3884 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3885 next_offset += envelope_size;
3886 }
3887
3888 Ok(())
3889 }
3890 }
3891
3892 impl DeviceCategory {
3893 #[inline(always)]
3894 fn max_ordinal_present(&self) -> u64 {
3895 if let Some(_) = self.subcategory {
3896 return 2;
3897 }
3898 if let Some(_) = self.category {
3899 return 1;
3900 }
3901 0
3902 }
3903 }
3904
3905 impl fidl::encoding::ValueTypeMarker for DeviceCategory {
3906 type Borrowed<'a> = &'a Self;
3907 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3908 value
3909 }
3910 }
3911
3912 unsafe impl fidl::encoding::TypeMarker for DeviceCategory {
3913 type Owned = Self;
3914
3915 #[inline(always)]
3916 fn inline_align(_context: fidl::encoding::Context) -> usize {
3917 8
3918 }
3919
3920 #[inline(always)]
3921 fn inline_size(_context: fidl::encoding::Context) -> usize {
3922 16
3923 }
3924 }
3925
3926 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceCategory, D>
3927 for &DeviceCategory
3928 {
3929 unsafe fn encode(
3930 self,
3931 encoder: &mut fidl::encoding::Encoder<'_, D>,
3932 offset: usize,
3933 mut depth: fidl::encoding::Depth,
3934 ) -> fidl::Result<()> {
3935 encoder.debug_check_bounds::<DeviceCategory>(offset);
3936 let max_ordinal: u64 = self.max_ordinal_present();
3938 encoder.write_num(max_ordinal, offset);
3939 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3940 if max_ordinal == 0 {
3942 return Ok(());
3943 }
3944 depth.increment()?;
3945 let envelope_size = 8;
3946 let bytes_len = max_ordinal as usize * envelope_size;
3947 #[allow(unused_variables)]
3948 let offset = encoder.out_of_line_offset(bytes_len);
3949 let mut _prev_end_offset: usize = 0;
3950 if 1 > max_ordinal {
3951 return Ok(());
3952 }
3953
3954 let cur_offset: usize = (1 - 1) * envelope_size;
3957
3958 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3960
3961 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3966 self.category.as_ref().map(
3967 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3968 ),
3969 encoder,
3970 offset + cur_offset,
3971 depth,
3972 )?;
3973
3974 _prev_end_offset = cur_offset + envelope_size;
3975 if 2 > max_ordinal {
3976 return Ok(());
3977 }
3978
3979 let cur_offset: usize = (2 - 1) * envelope_size;
3982
3983 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3985
3986 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3991 self.subcategory.as_ref().map(
3992 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3993 ),
3994 encoder,
3995 offset + cur_offset,
3996 depth,
3997 )?;
3998
3999 _prev_end_offset = cur_offset + envelope_size;
4000
4001 Ok(())
4002 }
4003 }
4004
4005 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceCategory {
4006 #[inline(always)]
4007 fn new_empty() -> Self {
4008 Self::default()
4009 }
4010
4011 unsafe fn decode(
4012 &mut self,
4013 decoder: &mut fidl::encoding::Decoder<'_, D>,
4014 offset: usize,
4015 mut depth: fidl::encoding::Depth,
4016 ) -> fidl::Result<()> {
4017 decoder.debug_check_bounds::<Self>(offset);
4018 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4019 None => return Err(fidl::Error::NotNullable),
4020 Some(len) => len,
4021 };
4022 if len == 0 {
4024 return Ok(());
4025 };
4026 depth.increment()?;
4027 let envelope_size = 8;
4028 let bytes_len = len * envelope_size;
4029 let offset = decoder.out_of_line_offset(bytes_len)?;
4030 let mut _next_ordinal_to_read = 0;
4032 let mut next_offset = offset;
4033 let end_offset = offset + bytes_len;
4034 _next_ordinal_to_read += 1;
4035 if next_offset >= end_offset {
4036 return Ok(());
4037 }
4038
4039 while _next_ordinal_to_read < 1 {
4041 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4042 _next_ordinal_to_read += 1;
4043 next_offset += envelope_size;
4044 }
4045
4046 let next_out_of_line = decoder.next_out_of_line();
4047 let handles_before = decoder.remaining_handles();
4048 if let Some((inlined, num_bytes, num_handles)) =
4049 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4050 {
4051 let member_inline_size =
4052 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4053 decoder.context,
4054 );
4055 if inlined != (member_inline_size <= 4) {
4056 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4057 }
4058 let inner_offset;
4059 let mut inner_depth = depth.clone();
4060 if inlined {
4061 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4062 inner_offset = next_offset;
4063 } else {
4064 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4065 inner_depth.increment()?;
4066 }
4067 let val_ref = self
4068 .category
4069 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4070 fidl::decode!(
4071 fidl::encoding::UnboundedString,
4072 D,
4073 val_ref,
4074 decoder,
4075 inner_offset,
4076 inner_depth
4077 )?;
4078 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4079 {
4080 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4081 }
4082 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4083 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4084 }
4085 }
4086
4087 next_offset += envelope_size;
4088 _next_ordinal_to_read += 1;
4089 if next_offset >= end_offset {
4090 return Ok(());
4091 }
4092
4093 while _next_ordinal_to_read < 2 {
4095 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4096 _next_ordinal_to_read += 1;
4097 next_offset += envelope_size;
4098 }
4099
4100 let next_out_of_line = decoder.next_out_of_line();
4101 let handles_before = decoder.remaining_handles();
4102 if let Some((inlined, num_bytes, num_handles)) =
4103 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4104 {
4105 let member_inline_size =
4106 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4107 decoder.context,
4108 );
4109 if inlined != (member_inline_size <= 4) {
4110 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4111 }
4112 let inner_offset;
4113 let mut inner_depth = depth.clone();
4114 if inlined {
4115 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4116 inner_offset = next_offset;
4117 } else {
4118 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4119 inner_depth.increment()?;
4120 }
4121 let val_ref = self
4122 .subcategory
4123 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4124 fidl::decode!(
4125 fidl::encoding::UnboundedString,
4126 D,
4127 val_ref,
4128 decoder,
4129 inner_offset,
4130 inner_depth
4131 )?;
4132 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4133 {
4134 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4135 }
4136 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4137 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4138 }
4139 }
4140
4141 next_offset += envelope_size;
4142
4143 while next_offset < end_offset {
4145 _next_ordinal_to_read += 1;
4146 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4147 next_offset += envelope_size;
4148 }
4149
4150 Ok(())
4151 }
4152 }
4153
4154 impl DriverInfo {
4155 #[inline(always)]
4156 fn max_ordinal_present(&self) -> u64 {
4157 if let Some(_) = self.is_disabled {
4158 return 9;
4159 }
4160 if let Some(_) = self.driver_framework_version {
4161 return 8;
4162 }
4163 if let Some(_) = self.bind_rules_bytecode {
4164 return 7;
4165 }
4166 if let Some(_) = self.device_categories {
4167 return 6;
4168 }
4169 if let Some(_) = self.is_fallback {
4170 return 5;
4171 }
4172 if let Some(_) = self.package_type {
4173 return 4;
4174 }
4175 if let Some(_) = self.colocate {
4176 return 3;
4177 }
4178 if let Some(_) = self.name {
4179 return 2;
4180 }
4181 if let Some(_) = self.url {
4182 return 1;
4183 }
4184 0
4185 }
4186 }
4187
4188 impl fidl::encoding::ValueTypeMarker for DriverInfo {
4189 type Borrowed<'a> = &'a Self;
4190 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4191 value
4192 }
4193 }
4194
4195 unsafe impl fidl::encoding::TypeMarker for DriverInfo {
4196 type Owned = Self;
4197
4198 #[inline(always)]
4199 fn inline_align(_context: fidl::encoding::Context) -> usize {
4200 8
4201 }
4202
4203 #[inline(always)]
4204 fn inline_size(_context: fidl::encoding::Context) -> usize {
4205 16
4206 }
4207 }
4208
4209 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DriverInfo, D>
4210 for &DriverInfo
4211 {
4212 unsafe fn encode(
4213 self,
4214 encoder: &mut fidl::encoding::Encoder<'_, D>,
4215 offset: usize,
4216 mut depth: fidl::encoding::Depth,
4217 ) -> fidl::Result<()> {
4218 encoder.debug_check_bounds::<DriverInfo>(offset);
4219 let max_ordinal: u64 = self.max_ordinal_present();
4221 encoder.write_num(max_ordinal, offset);
4222 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4223 if max_ordinal == 0 {
4225 return Ok(());
4226 }
4227 depth.increment()?;
4228 let envelope_size = 8;
4229 let bytes_len = max_ordinal as usize * envelope_size;
4230 #[allow(unused_variables)]
4231 let offset = encoder.out_of_line_offset(bytes_len);
4232 let mut _prev_end_offset: usize = 0;
4233 if 1 > max_ordinal {
4234 return Ok(());
4235 }
4236
4237 let cur_offset: usize = (1 - 1) * envelope_size;
4240
4241 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4243
4244 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4249 self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4250 encoder, offset + cur_offset, depth
4251 )?;
4252
4253 _prev_end_offset = cur_offset + envelope_size;
4254 if 2 > max_ordinal {
4255 return Ok(());
4256 }
4257
4258 let cur_offset: usize = (2 - 1) * envelope_size;
4261
4262 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4264
4265 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4270 self.name.as_ref().map(
4271 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4272 ),
4273 encoder,
4274 offset + cur_offset,
4275 depth,
4276 )?;
4277
4278 _prev_end_offset = cur_offset + envelope_size;
4279 if 3 > max_ordinal {
4280 return Ok(());
4281 }
4282
4283 let cur_offset: usize = (3 - 1) * envelope_size;
4286
4287 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4289
4290 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4295 self.colocate.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4296 encoder,
4297 offset + cur_offset,
4298 depth,
4299 )?;
4300
4301 _prev_end_offset = cur_offset + envelope_size;
4302 if 4 > max_ordinal {
4303 return Ok(());
4304 }
4305
4306 let cur_offset: usize = (4 - 1) * envelope_size;
4309
4310 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4312
4313 fidl::encoding::encode_in_envelope_optional::<DriverPackageType, D>(
4318 self.package_type
4319 .as_ref()
4320 .map(<DriverPackageType as fidl::encoding::ValueTypeMarker>::borrow),
4321 encoder,
4322 offset + cur_offset,
4323 depth,
4324 )?;
4325
4326 _prev_end_offset = cur_offset + envelope_size;
4327 if 5 > max_ordinal {
4328 return Ok(());
4329 }
4330
4331 let cur_offset: usize = (5 - 1) * envelope_size;
4334
4335 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4337
4338 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4343 self.is_fallback.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4344 encoder,
4345 offset + cur_offset,
4346 depth,
4347 )?;
4348
4349 _prev_end_offset = cur_offset + envelope_size;
4350 if 6 > max_ordinal {
4351 return Ok(());
4352 }
4353
4354 let cur_offset: usize = (6 - 1) * envelope_size;
4357
4358 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4360
4361 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<DeviceCategory>, D>(
4366 self.device_categories.as_ref().map(<fidl::encoding::UnboundedVector<DeviceCategory> as fidl::encoding::ValueTypeMarker>::borrow),
4367 encoder, offset + cur_offset, depth
4368 )?;
4369
4370 _prev_end_offset = cur_offset + envelope_size;
4371 if 7 > max_ordinal {
4372 return Ok(());
4373 }
4374
4375 let cur_offset: usize = (7 - 1) * envelope_size;
4378
4379 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4381
4382 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4387 self.bind_rules_bytecode.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4388 encoder, offset + cur_offset, depth
4389 )?;
4390
4391 _prev_end_offset = cur_offset + envelope_size;
4392 if 8 > max_ordinal {
4393 return Ok(());
4394 }
4395
4396 let cur_offset: usize = (8 - 1) * envelope_size;
4399
4400 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4402
4403 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4408 self.driver_framework_version
4409 .as_ref()
4410 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4411 encoder,
4412 offset + cur_offset,
4413 depth,
4414 )?;
4415
4416 _prev_end_offset = cur_offset + envelope_size;
4417 if 9 > max_ordinal {
4418 return Ok(());
4419 }
4420
4421 let cur_offset: usize = (9 - 1) * envelope_size;
4424
4425 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4427
4428 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4433 self.is_disabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4434 encoder,
4435 offset + cur_offset,
4436 depth,
4437 )?;
4438
4439 _prev_end_offset = cur_offset + envelope_size;
4440
4441 Ok(())
4442 }
4443 }
4444
4445 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverInfo {
4446 #[inline(always)]
4447 fn new_empty() -> Self {
4448 Self::default()
4449 }
4450
4451 unsafe fn decode(
4452 &mut self,
4453 decoder: &mut fidl::encoding::Decoder<'_, D>,
4454 offset: usize,
4455 mut depth: fidl::encoding::Depth,
4456 ) -> fidl::Result<()> {
4457 decoder.debug_check_bounds::<Self>(offset);
4458 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4459 None => return Err(fidl::Error::NotNullable),
4460 Some(len) => len,
4461 };
4462 if len == 0 {
4464 return Ok(());
4465 };
4466 depth.increment()?;
4467 let envelope_size = 8;
4468 let bytes_len = len * envelope_size;
4469 let offset = decoder.out_of_line_offset(bytes_len)?;
4470 let mut _next_ordinal_to_read = 0;
4472 let mut next_offset = offset;
4473 let end_offset = offset + bytes_len;
4474 _next_ordinal_to_read += 1;
4475 if next_offset >= end_offset {
4476 return Ok(());
4477 }
4478
4479 while _next_ordinal_to_read < 1 {
4481 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4482 _next_ordinal_to_read += 1;
4483 next_offset += envelope_size;
4484 }
4485
4486 let next_out_of_line = decoder.next_out_of_line();
4487 let handles_before = decoder.remaining_handles();
4488 if let Some((inlined, num_bytes, num_handles)) =
4489 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4490 {
4491 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4492 if inlined != (member_inline_size <= 4) {
4493 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4494 }
4495 let inner_offset;
4496 let mut inner_depth = depth.clone();
4497 if inlined {
4498 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4499 inner_offset = next_offset;
4500 } else {
4501 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4502 inner_depth.increment()?;
4503 }
4504 let val_ref = self.url.get_or_insert_with(|| {
4505 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4506 });
4507 fidl::decode!(
4508 fidl::encoding::BoundedString<4096>,
4509 D,
4510 val_ref,
4511 decoder,
4512 inner_offset,
4513 inner_depth
4514 )?;
4515 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4516 {
4517 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4518 }
4519 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4520 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4521 }
4522 }
4523
4524 next_offset += envelope_size;
4525 _next_ordinal_to_read += 1;
4526 if next_offset >= end_offset {
4527 return Ok(());
4528 }
4529
4530 while _next_ordinal_to_read < 2 {
4532 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4533 _next_ordinal_to_read += 1;
4534 next_offset += envelope_size;
4535 }
4536
4537 let next_out_of_line = decoder.next_out_of_line();
4538 let handles_before = decoder.remaining_handles();
4539 if let Some((inlined, num_bytes, num_handles)) =
4540 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4541 {
4542 let member_inline_size =
4543 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4544 decoder.context,
4545 );
4546 if inlined != (member_inline_size <= 4) {
4547 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4548 }
4549 let inner_offset;
4550 let mut inner_depth = depth.clone();
4551 if inlined {
4552 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4553 inner_offset = next_offset;
4554 } else {
4555 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4556 inner_depth.increment()?;
4557 }
4558 let val_ref = self
4559 .name
4560 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4561 fidl::decode!(
4562 fidl::encoding::UnboundedString,
4563 D,
4564 val_ref,
4565 decoder,
4566 inner_offset,
4567 inner_depth
4568 )?;
4569 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4570 {
4571 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4572 }
4573 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4574 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4575 }
4576 }
4577
4578 next_offset += envelope_size;
4579 _next_ordinal_to_read += 1;
4580 if next_offset >= end_offset {
4581 return Ok(());
4582 }
4583
4584 while _next_ordinal_to_read < 3 {
4586 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4587 _next_ordinal_to_read += 1;
4588 next_offset += envelope_size;
4589 }
4590
4591 let next_out_of_line = decoder.next_out_of_line();
4592 let handles_before = decoder.remaining_handles();
4593 if let Some((inlined, num_bytes, num_handles)) =
4594 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4595 {
4596 let member_inline_size =
4597 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4598 if inlined != (member_inline_size <= 4) {
4599 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4600 }
4601 let inner_offset;
4602 let mut inner_depth = depth.clone();
4603 if inlined {
4604 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4605 inner_offset = next_offset;
4606 } else {
4607 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4608 inner_depth.increment()?;
4609 }
4610 let val_ref = self.colocate.get_or_insert_with(|| fidl::new_empty!(bool, D));
4611 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4612 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4613 {
4614 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4615 }
4616 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4617 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4618 }
4619 }
4620
4621 next_offset += envelope_size;
4622 _next_ordinal_to_read += 1;
4623 if next_offset >= end_offset {
4624 return Ok(());
4625 }
4626
4627 while _next_ordinal_to_read < 4 {
4629 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4630 _next_ordinal_to_read += 1;
4631 next_offset += envelope_size;
4632 }
4633
4634 let next_out_of_line = decoder.next_out_of_line();
4635 let handles_before = decoder.remaining_handles();
4636 if let Some((inlined, num_bytes, num_handles)) =
4637 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4638 {
4639 let member_inline_size =
4640 <DriverPackageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4641 if inlined != (member_inline_size <= 4) {
4642 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4643 }
4644 let inner_offset;
4645 let mut inner_depth = depth.clone();
4646 if inlined {
4647 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4648 inner_offset = next_offset;
4649 } else {
4650 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4651 inner_depth.increment()?;
4652 }
4653 let val_ref =
4654 self.package_type.get_or_insert_with(|| fidl::new_empty!(DriverPackageType, D));
4655 fidl::decode!(DriverPackageType, D, val_ref, decoder, inner_offset, inner_depth)?;
4656 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4657 {
4658 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4659 }
4660 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4661 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4662 }
4663 }
4664
4665 next_offset += envelope_size;
4666 _next_ordinal_to_read += 1;
4667 if next_offset >= end_offset {
4668 return Ok(());
4669 }
4670
4671 while _next_ordinal_to_read < 5 {
4673 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4674 _next_ordinal_to_read += 1;
4675 next_offset += envelope_size;
4676 }
4677
4678 let next_out_of_line = decoder.next_out_of_line();
4679 let handles_before = decoder.remaining_handles();
4680 if let Some((inlined, num_bytes, num_handles)) =
4681 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4682 {
4683 let member_inline_size =
4684 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4685 if inlined != (member_inline_size <= 4) {
4686 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4687 }
4688 let inner_offset;
4689 let mut inner_depth = depth.clone();
4690 if inlined {
4691 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4692 inner_offset = next_offset;
4693 } else {
4694 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4695 inner_depth.increment()?;
4696 }
4697 let val_ref = self.is_fallback.get_or_insert_with(|| fidl::new_empty!(bool, D));
4698 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4699 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4700 {
4701 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4702 }
4703 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4704 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4705 }
4706 }
4707
4708 next_offset += envelope_size;
4709 _next_ordinal_to_read += 1;
4710 if next_offset >= end_offset {
4711 return Ok(());
4712 }
4713
4714 while _next_ordinal_to_read < 6 {
4716 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4717 _next_ordinal_to_read += 1;
4718 next_offset += envelope_size;
4719 }
4720
4721 let next_out_of_line = decoder.next_out_of_line();
4722 let handles_before = decoder.remaining_handles();
4723 if let Some((inlined, num_bytes, num_handles)) =
4724 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4725 {
4726 let member_inline_size = <fidl::encoding::UnboundedVector<DeviceCategory> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4727 if inlined != (member_inline_size <= 4) {
4728 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4729 }
4730 let inner_offset;
4731 let mut inner_depth = depth.clone();
4732 if inlined {
4733 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4734 inner_offset = next_offset;
4735 } else {
4736 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4737 inner_depth.increment()?;
4738 }
4739 let val_ref = self.device_categories.get_or_insert_with(|| {
4740 fidl::new_empty!(fidl::encoding::UnboundedVector<DeviceCategory>, D)
4741 });
4742 fidl::decode!(
4743 fidl::encoding::UnboundedVector<DeviceCategory>,
4744 D,
4745 val_ref,
4746 decoder,
4747 inner_offset,
4748 inner_depth
4749 )?;
4750 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4751 {
4752 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4753 }
4754 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4755 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4756 }
4757 }
4758
4759 next_offset += envelope_size;
4760 _next_ordinal_to_read += 1;
4761 if next_offset >= end_offset {
4762 return Ok(());
4763 }
4764
4765 while _next_ordinal_to_read < 7 {
4767 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4768 _next_ordinal_to_read += 1;
4769 next_offset += envelope_size;
4770 }
4771
4772 let next_out_of_line = decoder.next_out_of_line();
4773 let handles_before = decoder.remaining_handles();
4774 if let Some((inlined, num_bytes, num_handles)) =
4775 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4776 {
4777 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4778 if inlined != (member_inline_size <= 4) {
4779 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4780 }
4781 let inner_offset;
4782 let mut inner_depth = depth.clone();
4783 if inlined {
4784 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4785 inner_offset = next_offset;
4786 } else {
4787 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4788 inner_depth.increment()?;
4789 }
4790 let val_ref = self.bind_rules_bytecode.get_or_insert_with(|| {
4791 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
4792 });
4793 fidl::decode!(
4794 fidl::encoding::UnboundedVector<u8>,
4795 D,
4796 val_ref,
4797 decoder,
4798 inner_offset,
4799 inner_depth
4800 )?;
4801 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4802 {
4803 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4804 }
4805 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4806 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4807 }
4808 }
4809
4810 next_offset += envelope_size;
4811 _next_ordinal_to_read += 1;
4812 if next_offset >= end_offset {
4813 return Ok(());
4814 }
4815
4816 while _next_ordinal_to_read < 8 {
4818 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4819 _next_ordinal_to_read += 1;
4820 next_offset += envelope_size;
4821 }
4822
4823 let next_out_of_line = decoder.next_out_of_line();
4824 let handles_before = decoder.remaining_handles();
4825 if let Some((inlined, num_bytes, num_handles)) =
4826 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4827 {
4828 let member_inline_size =
4829 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4830 if inlined != (member_inline_size <= 4) {
4831 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4832 }
4833 let inner_offset;
4834 let mut inner_depth = depth.clone();
4835 if inlined {
4836 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4837 inner_offset = next_offset;
4838 } else {
4839 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4840 inner_depth.increment()?;
4841 }
4842 let val_ref =
4843 self.driver_framework_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4844 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4845 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4846 {
4847 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4848 }
4849 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4850 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4851 }
4852 }
4853
4854 next_offset += envelope_size;
4855 _next_ordinal_to_read += 1;
4856 if next_offset >= end_offset {
4857 return Ok(());
4858 }
4859
4860 while _next_ordinal_to_read < 9 {
4862 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4863 _next_ordinal_to_read += 1;
4864 next_offset += envelope_size;
4865 }
4866
4867 let next_out_of_line = decoder.next_out_of_line();
4868 let handles_before = decoder.remaining_handles();
4869 if let Some((inlined, num_bytes, num_handles)) =
4870 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4871 {
4872 let member_inline_size =
4873 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4874 if inlined != (member_inline_size <= 4) {
4875 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4876 }
4877 let inner_offset;
4878 let mut inner_depth = depth.clone();
4879 if inlined {
4880 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4881 inner_offset = next_offset;
4882 } else {
4883 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4884 inner_depth.increment()?;
4885 }
4886 let val_ref = self.is_disabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
4887 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4888 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4889 {
4890 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4891 }
4892 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4893 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4894 }
4895 }
4896
4897 next_offset += envelope_size;
4898
4899 while next_offset < end_offset {
4901 _next_ordinal_to_read += 1;
4902 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4903 next_offset += envelope_size;
4904 }
4905
4906 Ok(())
4907 }
4908 }
4909
4910 impl NodeControllerRequestBindRequest {
4911 #[inline(always)]
4912 fn max_ordinal_present(&self) -> u64 {
4913 if let Some(_) = self.driver_url_suffix {
4914 return 2;
4915 }
4916 if let Some(_) = self.force_rebind {
4917 return 1;
4918 }
4919 0
4920 }
4921 }
4922
4923 impl fidl::encoding::ValueTypeMarker for NodeControllerRequestBindRequest {
4924 type Borrowed<'a> = &'a Self;
4925 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4926 value
4927 }
4928 }
4929
4930 unsafe impl fidl::encoding::TypeMarker for NodeControllerRequestBindRequest {
4931 type Owned = Self;
4932
4933 #[inline(always)]
4934 fn inline_align(_context: fidl::encoding::Context) -> usize {
4935 8
4936 }
4937
4938 #[inline(always)]
4939 fn inline_size(_context: fidl::encoding::Context) -> usize {
4940 16
4941 }
4942 }
4943
4944 unsafe impl<D: fidl::encoding::ResourceDialect>
4945 fidl::encoding::Encode<NodeControllerRequestBindRequest, D>
4946 for &NodeControllerRequestBindRequest
4947 {
4948 unsafe fn encode(
4949 self,
4950 encoder: &mut fidl::encoding::Encoder<'_, D>,
4951 offset: usize,
4952 mut depth: fidl::encoding::Depth,
4953 ) -> fidl::Result<()> {
4954 encoder.debug_check_bounds::<NodeControllerRequestBindRequest>(offset);
4955 let max_ordinal: u64 = self.max_ordinal_present();
4957 encoder.write_num(max_ordinal, offset);
4958 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4959 if max_ordinal == 0 {
4961 return Ok(());
4962 }
4963 depth.increment()?;
4964 let envelope_size = 8;
4965 let bytes_len = max_ordinal as usize * envelope_size;
4966 #[allow(unused_variables)]
4967 let offset = encoder.out_of_line_offset(bytes_len);
4968 let mut _prev_end_offset: usize = 0;
4969 if 1 > max_ordinal {
4970 return Ok(());
4971 }
4972
4973 let cur_offset: usize = (1 - 1) * envelope_size;
4976
4977 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4979
4980 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4985 self.force_rebind.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4986 encoder,
4987 offset + cur_offset,
4988 depth,
4989 )?;
4990
4991 _prev_end_offset = cur_offset + envelope_size;
4992 if 2 > max_ordinal {
4993 return Ok(());
4994 }
4995
4996 let cur_offset: usize = (2 - 1) * envelope_size;
4999
5000 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5002
5003 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
5008 self.driver_url_suffix.as_ref().map(
5009 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
5010 ),
5011 encoder,
5012 offset + cur_offset,
5013 depth,
5014 )?;
5015
5016 _prev_end_offset = cur_offset + envelope_size;
5017
5018 Ok(())
5019 }
5020 }
5021
5022 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5023 for NodeControllerRequestBindRequest
5024 {
5025 #[inline(always)]
5026 fn new_empty() -> Self {
5027 Self::default()
5028 }
5029
5030 unsafe fn decode(
5031 &mut self,
5032 decoder: &mut fidl::encoding::Decoder<'_, D>,
5033 offset: usize,
5034 mut depth: fidl::encoding::Depth,
5035 ) -> fidl::Result<()> {
5036 decoder.debug_check_bounds::<Self>(offset);
5037 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5038 None => return Err(fidl::Error::NotNullable),
5039 Some(len) => len,
5040 };
5041 if len == 0 {
5043 return Ok(());
5044 };
5045 depth.increment()?;
5046 let envelope_size = 8;
5047 let bytes_len = len * envelope_size;
5048 let offset = decoder.out_of_line_offset(bytes_len)?;
5049 let mut _next_ordinal_to_read = 0;
5051 let mut next_offset = offset;
5052 let end_offset = offset + bytes_len;
5053 _next_ordinal_to_read += 1;
5054 if next_offset >= end_offset {
5055 return Ok(());
5056 }
5057
5058 while _next_ordinal_to_read < 1 {
5060 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5061 _next_ordinal_to_read += 1;
5062 next_offset += envelope_size;
5063 }
5064
5065 let next_out_of_line = decoder.next_out_of_line();
5066 let handles_before = decoder.remaining_handles();
5067 if let Some((inlined, num_bytes, num_handles)) =
5068 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5069 {
5070 let member_inline_size =
5071 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5072 if inlined != (member_inline_size <= 4) {
5073 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5074 }
5075 let inner_offset;
5076 let mut inner_depth = depth.clone();
5077 if inlined {
5078 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5079 inner_offset = next_offset;
5080 } else {
5081 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5082 inner_depth.increment()?;
5083 }
5084 let val_ref = self.force_rebind.get_or_insert_with(|| fidl::new_empty!(bool, D));
5085 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5086 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5087 {
5088 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5089 }
5090 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5091 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5092 }
5093 }
5094
5095 next_offset += envelope_size;
5096 _next_ordinal_to_read += 1;
5097 if next_offset >= end_offset {
5098 return Ok(());
5099 }
5100
5101 while _next_ordinal_to_read < 2 {
5103 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5104 _next_ordinal_to_read += 1;
5105 next_offset += envelope_size;
5106 }
5107
5108 let next_out_of_line = decoder.next_out_of_line();
5109 let handles_before = decoder.remaining_handles();
5110 if let Some((inlined, num_bytes, num_handles)) =
5111 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5112 {
5113 let member_inline_size =
5114 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5115 decoder.context,
5116 );
5117 if inlined != (member_inline_size <= 4) {
5118 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5119 }
5120 let inner_offset;
5121 let mut inner_depth = depth.clone();
5122 if inlined {
5123 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5124 inner_offset = next_offset;
5125 } else {
5126 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5127 inner_depth.increment()?;
5128 }
5129 let val_ref = self
5130 .driver_url_suffix
5131 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5132 fidl::decode!(
5133 fidl::encoding::UnboundedString,
5134 D,
5135 val_ref,
5136 decoder,
5137 inner_offset,
5138 inner_depth
5139 )?;
5140 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5141 {
5142 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5143 }
5144 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5145 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5146 }
5147 }
5148
5149 next_offset += envelope_size;
5150
5151 while next_offset < end_offset {
5153 _next_ordinal_to_read += 1;
5154 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5155 next_offset += envelope_size;
5156 }
5157
5158 Ok(())
5159 }
5160 }
5161
5162 impl NodeSymbol {
5163 #[inline(always)]
5164 fn max_ordinal_present(&self) -> u64 {
5165 if let Some(_) = self.module_name {
5166 return 3;
5167 }
5168 if let Some(_) = self.address {
5169 return 2;
5170 }
5171 if let Some(_) = self.name {
5172 return 1;
5173 }
5174 0
5175 }
5176 }
5177
5178 impl fidl::encoding::ValueTypeMarker for NodeSymbol {
5179 type Borrowed<'a> = &'a Self;
5180 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5181 value
5182 }
5183 }
5184
5185 unsafe impl fidl::encoding::TypeMarker for NodeSymbol {
5186 type Owned = Self;
5187
5188 #[inline(always)]
5189 fn inline_align(_context: fidl::encoding::Context) -> usize {
5190 8
5191 }
5192
5193 #[inline(always)]
5194 fn inline_size(_context: fidl::encoding::Context) -> usize {
5195 16
5196 }
5197 }
5198
5199 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSymbol, D>
5200 for &NodeSymbol
5201 {
5202 unsafe fn encode(
5203 self,
5204 encoder: &mut fidl::encoding::Encoder<'_, D>,
5205 offset: usize,
5206 mut depth: fidl::encoding::Depth,
5207 ) -> fidl::Result<()> {
5208 encoder.debug_check_bounds::<NodeSymbol>(offset);
5209 let max_ordinal: u64 = self.max_ordinal_present();
5211 encoder.write_num(max_ordinal, offset);
5212 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5213 if max_ordinal == 0 {
5215 return Ok(());
5216 }
5217 depth.increment()?;
5218 let envelope_size = 8;
5219 let bytes_len = max_ordinal as usize * envelope_size;
5220 #[allow(unused_variables)]
5221 let offset = encoder.out_of_line_offset(bytes_len);
5222 let mut _prev_end_offset: usize = 0;
5223 if 1 > max_ordinal {
5224 return Ok(());
5225 }
5226
5227 let cur_offset: usize = (1 - 1) * envelope_size;
5230
5231 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5233
5234 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
5239 self.name.as_ref().map(
5240 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
5241 ),
5242 encoder,
5243 offset + cur_offset,
5244 depth,
5245 )?;
5246
5247 _prev_end_offset = cur_offset + envelope_size;
5248 if 2 > max_ordinal {
5249 return Ok(());
5250 }
5251
5252 let cur_offset: usize = (2 - 1) * envelope_size;
5255
5256 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5258
5259 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5264 self.address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5265 encoder,
5266 offset + cur_offset,
5267 depth,
5268 )?;
5269
5270 _prev_end_offset = cur_offset + envelope_size;
5271 if 3 > max_ordinal {
5272 return Ok(());
5273 }
5274
5275 let cur_offset: usize = (3 - 1) * envelope_size;
5278
5279 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5281
5282 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
5287 self.module_name.as_ref().map(
5288 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
5289 ),
5290 encoder,
5291 offset + cur_offset,
5292 depth,
5293 )?;
5294
5295 _prev_end_offset = cur_offset + envelope_size;
5296
5297 Ok(())
5298 }
5299 }
5300
5301 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSymbol {
5302 #[inline(always)]
5303 fn new_empty() -> Self {
5304 Self::default()
5305 }
5306
5307 unsafe fn decode(
5308 &mut self,
5309 decoder: &mut fidl::encoding::Decoder<'_, D>,
5310 offset: usize,
5311 mut depth: fidl::encoding::Depth,
5312 ) -> fidl::Result<()> {
5313 decoder.debug_check_bounds::<Self>(offset);
5314 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5315 None => return Err(fidl::Error::NotNullable),
5316 Some(len) => len,
5317 };
5318 if len == 0 {
5320 return Ok(());
5321 };
5322 depth.increment()?;
5323 let envelope_size = 8;
5324 let bytes_len = len * envelope_size;
5325 let offset = decoder.out_of_line_offset(bytes_len)?;
5326 let mut _next_ordinal_to_read = 0;
5328 let mut next_offset = offset;
5329 let end_offset = offset + bytes_len;
5330 _next_ordinal_to_read += 1;
5331 if next_offset >= end_offset {
5332 return Ok(());
5333 }
5334
5335 while _next_ordinal_to_read < 1 {
5337 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5338 _next_ordinal_to_read += 1;
5339 next_offset += envelope_size;
5340 }
5341
5342 let next_out_of_line = decoder.next_out_of_line();
5343 let handles_before = decoder.remaining_handles();
5344 if let Some((inlined, num_bytes, num_handles)) =
5345 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5346 {
5347 let member_inline_size =
5348 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5349 decoder.context,
5350 );
5351 if inlined != (member_inline_size <= 4) {
5352 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5353 }
5354 let inner_offset;
5355 let mut inner_depth = depth.clone();
5356 if inlined {
5357 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5358 inner_offset = next_offset;
5359 } else {
5360 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5361 inner_depth.increment()?;
5362 }
5363 let val_ref = self
5364 .name
5365 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5366 fidl::decode!(
5367 fidl::encoding::BoundedString<128>,
5368 D,
5369 val_ref,
5370 decoder,
5371 inner_offset,
5372 inner_depth
5373 )?;
5374 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5375 {
5376 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5377 }
5378 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5379 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5380 }
5381 }
5382
5383 next_offset += envelope_size;
5384 _next_ordinal_to_read += 1;
5385 if next_offset >= end_offset {
5386 return Ok(());
5387 }
5388
5389 while _next_ordinal_to_read < 2 {
5391 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5392 _next_ordinal_to_read += 1;
5393 next_offset += envelope_size;
5394 }
5395
5396 let next_out_of_line = decoder.next_out_of_line();
5397 let handles_before = decoder.remaining_handles();
5398 if let Some((inlined, num_bytes, num_handles)) =
5399 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5400 {
5401 let member_inline_size =
5402 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5403 if inlined != (member_inline_size <= 4) {
5404 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5405 }
5406 let inner_offset;
5407 let mut inner_depth = depth.clone();
5408 if inlined {
5409 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5410 inner_offset = next_offset;
5411 } else {
5412 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5413 inner_depth.increment()?;
5414 }
5415 let val_ref = self.address.get_or_insert_with(|| fidl::new_empty!(u64, D));
5416 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5417 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5418 {
5419 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5420 }
5421 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5422 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5423 }
5424 }
5425
5426 next_offset += envelope_size;
5427 _next_ordinal_to_read += 1;
5428 if next_offset >= end_offset {
5429 return Ok(());
5430 }
5431
5432 while _next_ordinal_to_read < 3 {
5434 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5435 _next_ordinal_to_read += 1;
5436 next_offset += envelope_size;
5437 }
5438
5439 let next_out_of_line = decoder.next_out_of_line();
5440 let handles_before = decoder.remaining_handles();
5441 if let Some((inlined, num_bytes, num_handles)) =
5442 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5443 {
5444 let member_inline_size =
5445 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5446 decoder.context,
5447 );
5448 if inlined != (member_inline_size <= 4) {
5449 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5450 }
5451 let inner_offset;
5452 let mut inner_depth = depth.clone();
5453 if inlined {
5454 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5455 inner_offset = next_offset;
5456 } else {
5457 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5458 inner_depth.increment()?;
5459 }
5460 let val_ref = self
5461 .module_name
5462 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5463 fidl::decode!(
5464 fidl::encoding::BoundedString<128>,
5465 D,
5466 val_ref,
5467 decoder,
5468 inner_offset,
5469 inner_depth
5470 )?;
5471 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5472 {
5473 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5474 }
5475 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5476 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5477 }
5478 }
5479
5480 next_offset += envelope_size;
5481
5482 while next_offset < end_offset {
5484 _next_ordinal_to_read += 1;
5485 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5486 next_offset += envelope_size;
5487 }
5488
5489 Ok(())
5490 }
5491 }
5492
5493 impl fidl::encoding::ValueTypeMarker for DeviceAddress {
5494 type Borrowed<'a> = &'a Self;
5495 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5496 value
5497 }
5498 }
5499
5500 unsafe impl fidl::encoding::TypeMarker for DeviceAddress {
5501 type Owned = Self;
5502
5503 #[inline(always)]
5504 fn inline_align(_context: fidl::encoding::Context) -> usize {
5505 8
5506 }
5507
5508 #[inline(always)]
5509 fn inline_size(_context: fidl::encoding::Context) -> usize {
5510 16
5511 }
5512 }
5513
5514 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceAddress, D>
5515 for &DeviceAddress
5516 {
5517 #[inline]
5518 unsafe fn encode(
5519 self,
5520 encoder: &mut fidl::encoding::Encoder<'_, D>,
5521 offset: usize,
5522 _depth: fidl::encoding::Depth,
5523 ) -> fidl::Result<()> {
5524 encoder.debug_check_bounds::<DeviceAddress>(offset);
5525 encoder.write_num::<u64>(self.ordinal(), offset);
5526 match self {
5527 DeviceAddress::IntValue(ref val) => {
5528 fidl::encoding::encode_in_envelope::<u8, D>(
5529 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
5530 encoder, offset + 8, _depth
5531 )
5532 }
5533 DeviceAddress::ArrayIntValue(ref val) => {
5534 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 10>, D>(
5535 <fidl::encoding::Vector<u8, 10> as fidl::encoding::ValueTypeMarker>::borrow(val),
5536 encoder, offset + 8, _depth
5537 )
5538 }
5539 DeviceAddress::CharIntValue(ref val) => {
5540 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<4>, D>(
5541 <fidl::encoding::BoundedString<4> as fidl::encoding::ValueTypeMarker>::borrow(val),
5542 encoder, offset + 8, _depth
5543 )
5544 }
5545 DeviceAddress::ArrayCharIntValue(ref val) => {
5546 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>, D>(
5547 <fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10> as fidl::encoding::ValueTypeMarker>::borrow(val),
5548 encoder, offset + 8, _depth
5549 )
5550 }
5551 DeviceAddress::StringValue(ref val) => {
5552 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<32>, D>(
5553 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(val),
5554 encoder, offset + 8, _depth
5555 )
5556 }
5557 DeviceAddress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5558 }
5559 }
5560 }
5561
5562 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceAddress {
5563 #[inline(always)]
5564 fn new_empty() -> Self {
5565 Self::__SourceBreaking { unknown_ordinal: 0 }
5566 }
5567
5568 #[inline]
5569 unsafe fn decode(
5570 &mut self,
5571 decoder: &mut fidl::encoding::Decoder<'_, D>,
5572 offset: usize,
5573 mut depth: fidl::encoding::Depth,
5574 ) -> fidl::Result<()> {
5575 decoder.debug_check_bounds::<Self>(offset);
5576 #[allow(unused_variables)]
5577 let next_out_of_line = decoder.next_out_of_line();
5578 let handles_before = decoder.remaining_handles();
5579 let (ordinal, inlined, num_bytes, num_handles) =
5580 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5581
5582 let member_inline_size = match ordinal {
5583 1 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5584 2 => <fidl::encoding::Vector<u8, 10> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5585 3 => <fidl::encoding::BoundedString<4> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5586 4 => <fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5587 5 => <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5588 0 => return Err(fidl::Error::UnknownUnionTag),
5589 _ => num_bytes as usize,
5590 };
5591
5592 if inlined != (member_inline_size <= 4) {
5593 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5594 }
5595 let _inner_offset;
5596 if inlined {
5597 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5598 _inner_offset = offset + 8;
5599 } else {
5600 depth.increment()?;
5601 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5602 }
5603 match ordinal {
5604 1 => {
5605 #[allow(irrefutable_let_patterns)]
5606 if let DeviceAddress::IntValue(_) = self {
5607 } else {
5609 *self = DeviceAddress::IntValue(fidl::new_empty!(u8, D));
5611 }
5612 #[allow(irrefutable_let_patterns)]
5613 if let DeviceAddress::IntValue(ref mut val) = self {
5614 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
5615 } else {
5616 unreachable!()
5617 }
5618 }
5619 2 => {
5620 #[allow(irrefutable_let_patterns)]
5621 if let DeviceAddress::ArrayIntValue(_) = self {
5622 } else {
5624 *self = DeviceAddress::ArrayIntValue(
5626 fidl::new_empty!(fidl::encoding::Vector<u8, 10>, D),
5627 );
5628 }
5629 #[allow(irrefutable_let_patterns)]
5630 if let DeviceAddress::ArrayIntValue(ref mut val) = self {
5631 fidl::decode!(fidl::encoding::Vector<u8, 10>, D, val, decoder, _inner_offset, depth)?;
5632 } else {
5633 unreachable!()
5634 }
5635 }
5636 3 => {
5637 #[allow(irrefutable_let_patterns)]
5638 if let DeviceAddress::CharIntValue(_) = self {
5639 } else {
5641 *self = DeviceAddress::CharIntValue(fidl::new_empty!(
5643 fidl::encoding::BoundedString<4>,
5644 D
5645 ));
5646 }
5647 #[allow(irrefutable_let_patterns)]
5648 if let DeviceAddress::CharIntValue(ref mut val) = self {
5649 fidl::decode!(
5650 fidl::encoding::BoundedString<4>,
5651 D,
5652 val,
5653 decoder,
5654 _inner_offset,
5655 depth
5656 )?;
5657 } else {
5658 unreachable!()
5659 }
5660 }
5661 4 => {
5662 #[allow(irrefutable_let_patterns)]
5663 if let DeviceAddress::ArrayCharIntValue(_) = self {
5664 } else {
5666 *self = DeviceAddress::ArrayCharIntValue(fidl::new_empty!(
5668 fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>,
5669 D
5670 ));
5671 }
5672 #[allow(irrefutable_let_patterns)]
5673 if let DeviceAddress::ArrayCharIntValue(ref mut val) = self {
5674 fidl::decode!(
5675 fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>,
5676 D,
5677 val,
5678 decoder,
5679 _inner_offset,
5680 depth
5681 )?;
5682 } else {
5683 unreachable!()
5684 }
5685 }
5686 5 => {
5687 #[allow(irrefutable_let_patterns)]
5688 if let DeviceAddress::StringValue(_) = self {
5689 } else {
5691 *self = DeviceAddress::StringValue(fidl::new_empty!(
5693 fidl::encoding::BoundedString<32>,
5694 D
5695 ));
5696 }
5697 #[allow(irrefutable_let_patterns)]
5698 if let DeviceAddress::StringValue(ref mut val) = self {
5699 fidl::decode!(
5700 fidl::encoding::BoundedString<32>,
5701 D,
5702 val,
5703 decoder,
5704 _inner_offset,
5705 depth
5706 )?;
5707 } else {
5708 unreachable!()
5709 }
5710 }
5711 #[allow(deprecated)]
5712 ordinal => {
5713 for _ in 0..num_handles {
5714 decoder.drop_next_handle()?;
5715 }
5716 *self = DeviceAddress::__SourceBreaking { unknown_ordinal: ordinal };
5717 }
5718 }
5719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5720 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5721 }
5722 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5723 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5724 }
5725 Ok(())
5726 }
5727 }
5728
5729 impl fidl::encoding::ValueTypeMarker for NodePropertyKey {
5730 type Borrowed<'a> = &'a Self;
5731 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5732 value
5733 }
5734 }
5735
5736 unsafe impl fidl::encoding::TypeMarker for NodePropertyKey {
5737 type Owned = Self;
5738
5739 #[inline(always)]
5740 fn inline_align(_context: fidl::encoding::Context) -> usize {
5741 8
5742 }
5743
5744 #[inline(always)]
5745 fn inline_size(_context: fidl::encoding::Context) -> usize {
5746 16
5747 }
5748 }
5749
5750 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyKey, D>
5751 for &NodePropertyKey
5752 {
5753 #[inline]
5754 unsafe fn encode(
5755 self,
5756 encoder: &mut fidl::encoding::Encoder<'_, D>,
5757 offset: usize,
5758 _depth: fidl::encoding::Depth,
5759 ) -> fidl::Result<()> {
5760 encoder.debug_check_bounds::<NodePropertyKey>(offset);
5761 encoder.write_num::<u64>(self.ordinal(), offset);
5762 match self {
5763 NodePropertyKey::IntValue(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
5764 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
5765 encoder,
5766 offset + 8,
5767 _depth,
5768 ),
5769 NodePropertyKey::StringValue(ref val) => fidl::encoding::encode_in_envelope::<
5770 fidl::encoding::BoundedString<256>,
5771 D,
5772 >(
5773 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5774 val,
5775 ),
5776 encoder,
5777 offset + 8,
5778 _depth,
5779 ),
5780 }
5781 }
5782 }
5783
5784 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyKey {
5785 #[inline(always)]
5786 fn new_empty() -> Self {
5787 Self::IntValue(fidl::new_empty!(u32, D))
5788 }
5789
5790 #[inline]
5791 unsafe fn decode(
5792 &mut self,
5793 decoder: &mut fidl::encoding::Decoder<'_, D>,
5794 offset: usize,
5795 mut depth: fidl::encoding::Depth,
5796 ) -> fidl::Result<()> {
5797 decoder.debug_check_bounds::<Self>(offset);
5798 #[allow(unused_variables)]
5799 let next_out_of_line = decoder.next_out_of_line();
5800 let handles_before = decoder.remaining_handles();
5801 let (ordinal, inlined, num_bytes, num_handles) =
5802 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5803
5804 let member_inline_size = match ordinal {
5805 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5806 2 => {
5807 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5808 decoder.context,
5809 )
5810 }
5811 _ => return Err(fidl::Error::UnknownUnionTag),
5812 };
5813
5814 if inlined != (member_inline_size <= 4) {
5815 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5816 }
5817 let _inner_offset;
5818 if inlined {
5819 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5820 _inner_offset = offset + 8;
5821 } else {
5822 depth.increment()?;
5823 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5824 }
5825 match ordinal {
5826 1 => {
5827 #[allow(irrefutable_let_patterns)]
5828 if let NodePropertyKey::IntValue(_) = self {
5829 } else {
5831 *self = NodePropertyKey::IntValue(fidl::new_empty!(u32, D));
5833 }
5834 #[allow(irrefutable_let_patterns)]
5835 if let NodePropertyKey::IntValue(ref mut val) = self {
5836 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5837 } else {
5838 unreachable!()
5839 }
5840 }
5841 2 => {
5842 #[allow(irrefutable_let_patterns)]
5843 if let NodePropertyKey::StringValue(_) = self {
5844 } else {
5846 *self = NodePropertyKey::StringValue(fidl::new_empty!(
5848 fidl::encoding::BoundedString<256>,
5849 D
5850 ));
5851 }
5852 #[allow(irrefutable_let_patterns)]
5853 if let NodePropertyKey::StringValue(ref mut val) = self {
5854 fidl::decode!(
5855 fidl::encoding::BoundedString<256>,
5856 D,
5857 val,
5858 decoder,
5859 _inner_offset,
5860 depth
5861 )?;
5862 } else {
5863 unreachable!()
5864 }
5865 }
5866 ordinal => panic!("unexpected ordinal {:?}", ordinal),
5867 }
5868 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5869 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5870 }
5871 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5872 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5873 }
5874 Ok(())
5875 }
5876 }
5877
5878 impl fidl::encoding::ValueTypeMarker for NodePropertyValue {
5879 type Borrowed<'a> = &'a Self;
5880 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5881 value
5882 }
5883 }
5884
5885 unsafe impl fidl::encoding::TypeMarker for NodePropertyValue {
5886 type Owned = Self;
5887
5888 #[inline(always)]
5889 fn inline_align(_context: fidl::encoding::Context) -> usize {
5890 8
5891 }
5892
5893 #[inline(always)]
5894 fn inline_size(_context: fidl::encoding::Context) -> usize {
5895 16
5896 }
5897 }
5898
5899 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyValue, D>
5900 for &NodePropertyValue
5901 {
5902 #[inline]
5903 unsafe fn encode(
5904 self,
5905 encoder: &mut fidl::encoding::Encoder<'_, D>,
5906 offset: usize,
5907 _depth: fidl::encoding::Depth,
5908 ) -> fidl::Result<()> {
5909 encoder.debug_check_bounds::<NodePropertyValue>(offset);
5910 encoder.write_num::<u64>(self.ordinal(), offset);
5911 match self {
5912 NodePropertyValue::IntValue(ref val) => {
5913 fidl::encoding::encode_in_envelope::<u32, D>(
5914 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
5915 encoder,
5916 offset + 8,
5917 _depth,
5918 )
5919 }
5920 NodePropertyValue::StringValue(ref val) => fidl::encoding::encode_in_envelope::<
5921 fidl::encoding::BoundedString<256>,
5922 D,
5923 >(
5924 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5925 val,
5926 ),
5927 encoder,
5928 offset + 8,
5929 _depth,
5930 ),
5931 NodePropertyValue::BoolValue(ref val) => {
5932 fidl::encoding::encode_in_envelope::<bool, D>(
5933 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
5934 encoder,
5935 offset + 8,
5936 _depth,
5937 )
5938 }
5939 NodePropertyValue::EnumValue(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::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5951 }
5952 }
5953 }
5954
5955 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyValue {
5956 #[inline(always)]
5957 fn new_empty() -> Self {
5958 Self::__SourceBreaking { unknown_ordinal: 0 }
5959 }
5960
5961 #[inline]
5962 unsafe fn decode(
5963 &mut self,
5964 decoder: &mut fidl::encoding::Decoder<'_, D>,
5965 offset: usize,
5966 mut depth: fidl::encoding::Depth,
5967 ) -> fidl::Result<()> {
5968 decoder.debug_check_bounds::<Self>(offset);
5969 #[allow(unused_variables)]
5970 let next_out_of_line = decoder.next_out_of_line();
5971 let handles_before = decoder.remaining_handles();
5972 let (ordinal, inlined, num_bytes, num_handles) =
5973 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5974
5975 let member_inline_size = match ordinal {
5976 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5977 2 => {
5978 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5979 decoder.context,
5980 )
5981 }
5982 3 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5983 4 => {
5984 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5985 decoder.context,
5986 )
5987 }
5988 0 => return Err(fidl::Error::UnknownUnionTag),
5989 _ => num_bytes as usize,
5990 };
5991
5992 if inlined != (member_inline_size <= 4) {
5993 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5994 }
5995 let _inner_offset;
5996 if inlined {
5997 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5998 _inner_offset = offset + 8;
5999 } else {
6000 depth.increment()?;
6001 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6002 }
6003 match ordinal {
6004 1 => {
6005 #[allow(irrefutable_let_patterns)]
6006 if let NodePropertyValue::IntValue(_) = self {
6007 } else {
6009 *self = NodePropertyValue::IntValue(fidl::new_empty!(u32, D));
6011 }
6012 #[allow(irrefutable_let_patterns)]
6013 if let NodePropertyValue::IntValue(ref mut val) = self {
6014 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
6015 } else {
6016 unreachable!()
6017 }
6018 }
6019 2 => {
6020 #[allow(irrefutable_let_patterns)]
6021 if let NodePropertyValue::StringValue(_) = self {
6022 } else {
6024 *self = NodePropertyValue::StringValue(fidl::new_empty!(
6026 fidl::encoding::BoundedString<256>,
6027 D
6028 ));
6029 }
6030 #[allow(irrefutable_let_patterns)]
6031 if let NodePropertyValue::StringValue(ref mut val) = self {
6032 fidl::decode!(
6033 fidl::encoding::BoundedString<256>,
6034 D,
6035 val,
6036 decoder,
6037 _inner_offset,
6038 depth
6039 )?;
6040 } else {
6041 unreachable!()
6042 }
6043 }
6044 3 => {
6045 #[allow(irrefutable_let_patterns)]
6046 if let NodePropertyValue::BoolValue(_) = self {
6047 } else {
6049 *self = NodePropertyValue::BoolValue(fidl::new_empty!(bool, D));
6051 }
6052 #[allow(irrefutable_let_patterns)]
6053 if let NodePropertyValue::BoolValue(ref mut val) = self {
6054 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
6055 } else {
6056 unreachable!()
6057 }
6058 }
6059 4 => {
6060 #[allow(irrefutable_let_patterns)]
6061 if let NodePropertyValue::EnumValue(_) = self {
6062 } else {
6064 *self = NodePropertyValue::EnumValue(fidl::new_empty!(
6066 fidl::encoding::BoundedString<256>,
6067 D
6068 ));
6069 }
6070 #[allow(irrefutable_let_patterns)]
6071 if let NodePropertyValue::EnumValue(ref mut val) = self {
6072 fidl::decode!(
6073 fidl::encoding::BoundedString<256>,
6074 D,
6075 val,
6076 decoder,
6077 _inner_offset,
6078 depth
6079 )?;
6080 } else {
6081 unreachable!()
6082 }
6083 }
6084 #[allow(deprecated)]
6085 ordinal => {
6086 for _ in 0..num_handles {
6087 decoder.drop_next_handle()?;
6088 }
6089 *self = NodePropertyValue::__SourceBreaking { unknown_ordinal: ordinal };
6090 }
6091 }
6092 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6093 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6094 }
6095 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6096 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6097 }
6098 Ok(())
6099 }
6100 }
6101
6102 impl fidl::encoding::ValueTypeMarker for Offer {
6103 type Borrowed<'a> = &'a Self;
6104 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6105 value
6106 }
6107 }
6108
6109 unsafe impl fidl::encoding::TypeMarker for Offer {
6110 type Owned = Self;
6111
6112 #[inline(always)]
6113 fn inline_align(_context: fidl::encoding::Context) -> usize {
6114 8
6115 }
6116
6117 #[inline(always)]
6118 fn inline_size(_context: fidl::encoding::Context) -> usize {
6119 16
6120 }
6121 }
6122
6123 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Offer, D> for &Offer {
6124 #[inline]
6125 unsafe fn encode(
6126 self,
6127 encoder: &mut fidl::encoding::Encoder<'_, D>,
6128 offset: usize,
6129 _depth: fidl::encoding::Depth,
6130 ) -> fidl::Result<()> {
6131 encoder.debug_check_bounds::<Offer>(offset);
6132 encoder.write_num::<u64>(self.ordinal(), offset);
6133 match self {
6134 Offer::ZirconTransport(ref val) => {
6135 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
6136 <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
6137 encoder, offset + 8, _depth
6138 )
6139 }
6140 Offer::DriverTransport(ref val) => {
6141 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
6142 <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
6143 encoder, offset + 8, _depth
6144 )
6145 }
6146 Offer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6147 }
6148 }
6149 }
6150
6151 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Offer {
6152 #[inline(always)]
6153 fn new_empty() -> Self {
6154 Self::__SourceBreaking { unknown_ordinal: 0 }
6155 }
6156
6157 #[inline]
6158 unsafe fn decode(
6159 &mut self,
6160 decoder: &mut fidl::encoding::Decoder<'_, D>,
6161 offset: usize,
6162 mut depth: fidl::encoding::Depth,
6163 ) -> fidl::Result<()> {
6164 decoder.debug_check_bounds::<Self>(offset);
6165 #[allow(unused_variables)]
6166 let next_out_of_line = decoder.next_out_of_line();
6167 let handles_before = decoder.remaining_handles();
6168 let (ordinal, inlined, num_bytes, num_handles) =
6169 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6170
6171 let member_inline_size = match ordinal {
6172 1 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6173 2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6174 0 => return Err(fidl::Error::UnknownUnionTag),
6175 _ => num_bytes as usize,
6176 };
6177
6178 if inlined != (member_inline_size <= 4) {
6179 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6180 }
6181 let _inner_offset;
6182 if inlined {
6183 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6184 _inner_offset = offset + 8;
6185 } else {
6186 depth.increment()?;
6187 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6188 }
6189 match ordinal {
6190 1 => {
6191 #[allow(irrefutable_let_patterns)]
6192 if let Offer::ZirconTransport(_) = self {
6193 } else {
6195 *self = Offer::ZirconTransport(fidl::new_empty!(
6197 fidl_fuchsia_component_decl__common::Offer,
6198 D
6199 ));
6200 }
6201 #[allow(irrefutable_let_patterns)]
6202 if let Offer::ZirconTransport(ref mut val) = self {
6203 fidl::decode!(
6204 fidl_fuchsia_component_decl__common::Offer,
6205 D,
6206 val,
6207 decoder,
6208 _inner_offset,
6209 depth
6210 )?;
6211 } else {
6212 unreachable!()
6213 }
6214 }
6215 2 => {
6216 #[allow(irrefutable_let_patterns)]
6217 if let Offer::DriverTransport(_) = self {
6218 } else {
6220 *self = Offer::DriverTransport(fidl::new_empty!(
6222 fidl_fuchsia_component_decl__common::Offer,
6223 D
6224 ));
6225 }
6226 #[allow(irrefutable_let_patterns)]
6227 if let Offer::DriverTransport(ref mut val) = self {
6228 fidl::decode!(
6229 fidl_fuchsia_component_decl__common::Offer,
6230 D,
6231 val,
6232 decoder,
6233 _inner_offset,
6234 depth
6235 )?;
6236 } else {
6237 unreachable!()
6238 }
6239 }
6240 #[allow(deprecated)]
6241 ordinal => {
6242 for _ in 0..num_handles {
6243 decoder.drop_next_handle()?;
6244 }
6245 *self = Offer::__SourceBreaking { unknown_ordinal: ordinal };
6246 }
6247 }
6248 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6249 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6250 }
6251 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6252 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6253 }
6254 Ok(())
6255 }
6256 }
6257}