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