1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[doc = " Describes the expected availability of the capability.\n\n Some capabilities may not be present on all system configurations. In those\n cases, the availability will be declared as `OPTIONAL` along the chains of\n exposes/offers/uses, and the capability would be routed from `void` on\n system configurations where it does not make sense to route or provide a\n particular capability (e.g. graphical capabilities on a headless system).\n"]
8 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9 #[repr(u32)]
10 pub enum Availability {
11 Required = 1,
12 Optional = 2,
13 SameAsTarget = 3,
14 Transitional = 4,
15 }
16 impl ::core::convert::TryFrom<u32> for Availability {
17 type Error = ::fidl_next::UnknownStrictEnumMemberError;
18 fn try_from(
19 value: u32,
20 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
21 match value {
22 1 => Ok(Self::Required),
23 2 => Ok(Self::Optional),
24 3 => Ok(Self::SameAsTarget),
25 4 => Ok(Self::Transitional),
26
27 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
28 }
29 }
30 }
31
32 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Availability, ___E> for Availability
33 where
34 ___E: ?Sized,
35 {
36 #[inline]
37 fn encode(
38 self,
39 encoder: &mut ___E,
40 out: &mut ::core::mem::MaybeUninit<crate::wire::Availability>,
41 _: (),
42 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
43 ::fidl_next::Encode::encode(&self, encoder, out, ())
44 }
45 }
46
47 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Availability, ___E> for &'a Availability
48 where
49 ___E: ?Sized,
50 {
51 #[inline]
52 fn encode(
53 self,
54 encoder: &mut ___E,
55 out: &mut ::core::mem::MaybeUninit<crate::wire::Availability>,
56 _: (),
57 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
58 ::fidl_next::munge!(let crate::wire::Availability { value } = out);
59 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
60 Availability::Required => 1,
61
62 Availability::Optional => 2,
63
64 Availability::SameAsTarget => 3,
65
66 Availability::Transitional => 4,
67 }));
68
69 Ok(())
70 }
71 }
72
73 impl ::core::convert::From<crate::wire::Availability> for Availability {
74 fn from(wire: crate::wire::Availability) -> Self {
75 match u32::from(wire.value) {
76 1 => Self::Required,
77
78 2 => Self::Optional,
79
80 3 => Self::SameAsTarget,
81
82 4 => Self::Transitional,
83
84 _ => unsafe { ::core::hint::unreachable_unchecked() },
85 }
86 }
87 }
88
89 impl ::fidl_next::FromWire<crate::wire::Availability> for Availability {
90 #[inline]
91 fn from_wire(wire: crate::wire::Availability) -> Self {
92 Self::from(wire)
93 }
94 }
95
96 impl ::fidl_next::FromWireRef<crate::wire::Availability> for Availability {
97 #[inline]
98 fn from_wire_ref(wire: &crate::wire::Availability) -> Self {
99 Self::from(*wire)
100 }
101 }
102
103 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
104 #[repr(C)]
105 pub struct Unit {}
106
107 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Unit, ___E> for Unit
108 where
109 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
110 {
111 #[inline]
112 fn encode(
113 self,
114 encoder_: &mut ___E,
115 out_: &mut ::core::mem::MaybeUninit<crate::wire::Unit>,
116 _: (),
117 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
118 ::fidl_next::munge! {
119 let crate::wire::Unit {
120
121 _empty,
122
123 } = out_;
124 }
125
126 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
127
128 Ok(())
129 }
130 }
131
132 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Unit, ___E> for &'a Unit
133 where
134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
135 {
136 #[inline]
137 fn encode(
138 self,
139 encoder_: &mut ___E,
140 out_: &mut ::core::mem::MaybeUninit<crate::wire::Unit>,
141 _: (),
142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
143 ::fidl_next::munge! {
144 let crate::wire::Unit {
145
146 _empty,
147
148
149 } = out_;
150 }
151
152 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
153
154 Ok(())
155 }
156 }
157
158 unsafe impl<___E>
159 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Unit>, ___E> for Unit
160 where
161 ___E: ::fidl_next::Encoder + ?Sized,
162 Unit: ::fidl_next::Encode<crate::wire::Unit, ___E>,
163 {
164 #[inline]
165 fn encode_option(
166 this: ::core::option::Option<Self>,
167 encoder: &mut ___E,
168 out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::Unit>>,
169 _: (),
170 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
171 if let Some(inner) = this {
172 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
173 ::fidl_next::wire::Box::encode_present(out);
174 } else {
175 ::fidl_next::wire::Box::encode_absent(out);
176 }
177
178 Ok(())
179 }
180 }
181
182 unsafe impl<'a, ___E>
183 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Unit>, ___E>
184 for &'a Unit
185 where
186 ___E: ::fidl_next::Encoder + ?Sized,
187 &'a Unit: ::fidl_next::Encode<crate::wire::Unit, ___E>,
188 {
189 #[inline]
190 fn encode_option(
191 this: ::core::option::Option<Self>,
192 encoder: &mut ___E,
193 out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::Unit>>,
194 _: (),
195 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
196 if let Some(inner) = this {
197 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
198 ::fidl_next::wire::Box::encode_present(out);
199 } else {
200 ::fidl_next::wire::Box::encode_absent(out);
201 }
202
203 Ok(())
204 }
205 }
206
207 impl ::fidl_next::FromWire<crate::wire::Unit> for Unit {
208 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Unit, Self> =
209 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
210
211 #[inline]
212 fn from_wire(wire: crate::wire::Unit) -> Self {
213 Self {}
214 }
215 }
216
217 impl ::fidl_next::FromWireRef<crate::wire::Unit> for Unit {
218 #[inline]
219 fn from_wire_ref(wire: &crate::wire::Unit) -> Self {
220 Self {}
221 }
222 }
223
224 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
225 pub enum Data {
226 Bytes(::std::vec::Vec<u8>),
227
228 String(::std::string::String),
229
230 Int64(i64),
231
232 Uint64(u64),
233
234 UnknownOrdinal_(u64),
235 }
236
237 impl Data {
238 pub fn is_unknown(&self) -> bool {
239 #[allow(unreachable_patterns)]
240 match self {
241 Self::UnknownOrdinal_(_) => true,
242 _ => false,
243 }
244 }
245 }
246
247 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Data<'static>, ___E> for Data
248 where
249 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
250 ___E: ::fidl_next::Encoder,
251 {
252 #[inline]
253 fn encode(
254 self,
255 encoder: &mut ___E,
256 out: &mut ::core::mem::MaybeUninit<crate::wire::Data<'static>>,
257 _: (),
258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
259 ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
260
261 match self {
262 Self::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
263 ___E,
264 ::fidl_next::wire::Vector<'static, u8>,
265 >(value, 1, encoder, raw, (8192, ()))?,
266
267 Self::String(value) => ::fidl_next::wire::Union::encode_as::<
268 ___E,
269 ::fidl_next::wire::String<'static>,
270 >(value, 2, encoder, raw, 8192)?,
271
272 Self::Int64(value) => ::fidl_next::wire::Union::encode_as::<
273 ___E,
274 ::fidl_next::wire::Int64,
275 >(value, 3, encoder, raw, ())?,
276
277 Self::Uint64(value) => ::fidl_next::wire::Union::encode_as::<
278 ___E,
279 ::fidl_next::wire::Uint64,
280 >(value, 4, encoder, raw, ())?,
281
282 Self::UnknownOrdinal_(ordinal) => {
283 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
284 }
285 }
286
287 Ok(())
288 }
289 }
290
291 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Data<'static>, ___E> for &'a Data
292 where
293 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
294 ___E: ::fidl_next::Encoder,
295 {
296 #[inline]
297 fn encode(
298 self,
299 encoder: &mut ___E,
300 out: &mut ::core::mem::MaybeUninit<crate::wire::Data<'static>>,
301 _: (),
302 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
303 ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
304
305 match self {
306 Data::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
307 ___E,
308 ::fidl_next::wire::Vector<'static, u8>,
309 >(value, 1, encoder, raw, (8192, ()))?,
310
311 Data::String(value) => ::fidl_next::wire::Union::encode_as::<
312 ___E,
313 ::fidl_next::wire::String<'static>,
314 >(value, 2, encoder, raw, 8192)?,
315
316 Data::Int64(value) => ::fidl_next::wire::Union::encode_as::<
317 ___E,
318 ::fidl_next::wire::Int64,
319 >(value, 3, encoder, raw, ())?,
320
321 Data::Uint64(value) => ::fidl_next::wire::Union::encode_as::<
322 ___E,
323 ::fidl_next::wire::Uint64,
324 >(value, 4, encoder, raw, ())?,
325
326 Data::UnknownOrdinal_(ordinal) => {
327 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
328 }
329 }
330
331 Ok(())
332 }
333 }
334
335 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Data<'static>, ___E> for Data
336 where
337 ___E: ?Sized,
338 Data: ::fidl_next::Encode<crate::wire::Data<'static>, ___E>,
339 {
340 #[inline]
341 fn encode_option(
342 this: ::core::option::Option<Self>,
343 encoder: &mut ___E,
344 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Data<'static>>,
345 _: (),
346 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
347 ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
348
349 if let Some(inner) = this {
350 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
351 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
352 } else {
353 ::fidl_next::wire::Union::encode_absent(raw);
354 }
355
356 Ok(())
357 }
358 }
359
360 unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::Data<'static>, ___E>
361 for &'a Data
362 where
363 ___E: ?Sized,
364 &'a Data: ::fidl_next::Encode<crate::wire::Data<'static>, ___E>,
365 {
366 #[inline]
367 fn encode_option(
368 this: ::core::option::Option<Self>,
369 encoder: &mut ___E,
370 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Data<'static>>,
371 _: (),
372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
373 ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
374
375 if let Some(inner) = this {
376 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
377 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
378 } else {
379 ::fidl_next::wire::Union::encode_absent(raw);
380 }
381
382 Ok(())
383 }
384 }
385
386 impl<'de> ::fidl_next::FromWire<crate::wire::Data<'de>> for Data {
387 #[inline]
388 fn from_wire(wire: crate::wire::Data<'de>) -> Self {
389 let wire = ::core::mem::ManuallyDrop::new(wire);
390 match wire.raw.ordinal() {
391 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
392 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
393 })),
394
395 2 => Self::String(::fidl_next::FromWire::from_wire(unsafe {
396 wire.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
397 })),
398
399 3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
400 wire.raw.get().read_unchecked::<::fidl_next::wire::Int64>()
401 })),
402
403 4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
404 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint64>()
405 })),
406
407 ord => return Self::UnknownOrdinal_(ord as u64),
408 }
409 }
410 }
411
412 impl<'de> ::fidl_next::FromWireRef<crate::wire::Data<'de>> for Data {
413 #[inline]
414 fn from_wire_ref(wire: &crate::wire::Data<'de>) -> Self {
415 match wire.raw.ordinal() {
416 1 => Self::Bytes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
417 wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
418 })),
419
420 2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
421 wire.raw.get().deref_unchecked::<::fidl_next::wire::String<'de>>()
422 })),
423
424 3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
425 wire.raw.get().deref_unchecked::<::fidl_next::wire::Int64>()
426 })),
427
428 4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
429 wire.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>()
430 })),
431
432 ord => return Self::UnknownOrdinal_(ord as u64),
433 }
434 }
435 }
436
437 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Data {
438 #[inline]
439 fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
440 if let Some(inner) = wire.into_option() {
441 Some(::fidl_next::FromWire::from_wire(inner))
442 } else {
443 None
444 }
445 }
446 }
447
448 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Box<Data> {
449 #[inline]
450 fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
451 <
452 Data as ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>>
453 >::from_wire_option(wire).map(Box::new)
454 }
455 }
456
457 impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::Data<'de>> for Box<Data> {
458 #[inline]
459 fn from_wire_option_ref(
460 wire: &crate::wire_optional::Data<'de>,
461 ) -> ::core::option::Option<Self> {
462 if let Some(inner) = wire.as_ref() {
463 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
464 } else {
465 None
466 }
467 }
468 }
469
470 #[doc = " A client-assigned id of a [Capability] in a [CapabilityStore].\n\n The id is relative to the [CapabilityStore]. In the case where two\n [CapabilityStore]s have a capability / assigned to the same id, there is\n no relation between them\n"]
471 pub type CapabilityId = u64;
472
473 #[doc = " A client-assigned id of a new [Capability] in a [CapabilityStore]. Same as [CapabilityId],\n but used to distinguish output parameters in [CapabilityStore] methods.\n"]
474 pub type NewCapabilityId = u64;
475
476 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
477 #[repr(C)]
478 pub struct CapabilityStoreDuplicateRequest {
479 pub id: u64,
480
481 pub dest_id: u64,
482 }
483
484 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>
485 for CapabilityStoreDuplicateRequest
486 where
487 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
488 {
489 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
490 Self,
491 crate::wire::CapabilityStoreDuplicateRequest,
492 > = unsafe {
493 ::fidl_next::CopyOptimization::enable_if(
494 true
495
496 && <
497 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
498 >::COPY_OPTIMIZATION.is_enabled()
499
500 && <
501 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
502 >::COPY_OPTIMIZATION.is_enabled()
503
504 )
505 };
506
507 #[inline]
508 fn encode(
509 self,
510 encoder_: &mut ___E,
511 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateRequest>,
512 _: (),
513 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
514 ::fidl_next::munge! {
515 let crate::wire::CapabilityStoreDuplicateRequest {
516 id,
517 dest_id,
518
519 } = out_;
520 }
521
522 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
523
524 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
525
526 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
527
528 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
529
530 Ok(())
531 }
532 }
533
534 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>
535 for &'a CapabilityStoreDuplicateRequest
536 where
537 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
538 {
539 #[inline]
540 fn encode(
541 self,
542 encoder_: &mut ___E,
543 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateRequest>,
544 _: (),
545 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
546 ::fidl_next::munge! {
547 let crate::wire::CapabilityStoreDuplicateRequest {
548
549 id,
550 dest_id,
551
552 } = out_;
553 }
554
555 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
556
557 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
558
559 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
560
561 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
562
563 Ok(())
564 }
565 }
566
567 unsafe impl<___E>
568 ::fidl_next::EncodeOption<
569 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
570 ___E,
571 > for CapabilityStoreDuplicateRequest
572 where
573 ___E: ::fidl_next::Encoder + ?Sized,
574 CapabilityStoreDuplicateRequest:
575 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>,
576 {
577 #[inline]
578 fn encode_option(
579 this: ::core::option::Option<Self>,
580 encoder: &mut ___E,
581 out: &mut ::core::mem::MaybeUninit<
582 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
583 >,
584 _: (),
585 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
586 if let Some(inner) = this {
587 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
588 ::fidl_next::wire::Box::encode_present(out);
589 } else {
590 ::fidl_next::wire::Box::encode_absent(out);
591 }
592
593 Ok(())
594 }
595 }
596
597 unsafe impl<'a, ___E>
598 ::fidl_next::EncodeOption<
599 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
600 ___E,
601 > for &'a CapabilityStoreDuplicateRequest
602 where
603 ___E: ::fidl_next::Encoder + ?Sized,
604 &'a CapabilityStoreDuplicateRequest:
605 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>,
606 {
607 #[inline]
608 fn encode_option(
609 this: ::core::option::Option<Self>,
610 encoder: &mut ___E,
611 out: &mut ::core::mem::MaybeUninit<
612 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
613 >,
614 _: (),
615 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
616 if let Some(inner) = this {
617 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
618 ::fidl_next::wire::Box::encode_present(out);
619 } else {
620 ::fidl_next::wire::Box::encode_absent(out);
621 }
622
623 Ok(())
624 }
625 }
626
627 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateRequest>
628 for CapabilityStoreDuplicateRequest
629 {
630 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
631 crate::wire::CapabilityStoreDuplicateRequest,
632 Self,
633 > = unsafe {
634 ::fidl_next::CopyOptimization::enable_if(
635 true
636 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
637 .is_enabled()
638 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
639 .is_enabled(),
640 )
641 };
642
643 #[inline]
644 fn from_wire(wire: crate::wire::CapabilityStoreDuplicateRequest) -> Self {
645 Self {
646 id: ::fidl_next::FromWire::from_wire(wire.id),
647
648 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
649 }
650 }
651 }
652
653 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateRequest>
654 for CapabilityStoreDuplicateRequest
655 {
656 #[inline]
657 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateRequest) -> Self {
658 Self {
659 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
660
661 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
662 }
663 }
664 }
665
666 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
667 #[repr(C)]
668 pub struct CapabilityStoreDuplicateResponse {}
669
670 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateResponse, ___E>
671 for CapabilityStoreDuplicateResponse
672 where
673 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
674 {
675 #[inline]
676 fn encode(
677 self,
678 encoder_: &mut ___E,
679 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateResponse>,
680 _: (),
681 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
682 ::fidl_next::munge! {
683 let crate::wire::CapabilityStoreDuplicateResponse {
684
685 _empty,
686
687 } = out_;
688 }
689
690 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
691
692 Ok(())
693 }
694 }
695
696 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateResponse, ___E>
697 for &'a CapabilityStoreDuplicateResponse
698 where
699 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
700 {
701 #[inline]
702 fn encode(
703 self,
704 encoder_: &mut ___E,
705 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateResponse>,
706 _: (),
707 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
708 ::fidl_next::munge! {
709 let crate::wire::CapabilityStoreDuplicateResponse {
710
711 _empty,
712
713
714 } = out_;
715 }
716
717 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
718
719 Ok(())
720 }
721 }
722
723 unsafe impl<___E>
724 ::fidl_next::EncodeOption<
725 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateResponse>,
726 ___E,
727 > for CapabilityStoreDuplicateResponse
728 where
729 ___E: ::fidl_next::Encoder + ?Sized,
730 CapabilityStoreDuplicateResponse:
731 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateResponse, ___E>,
732 {
733 #[inline]
734 fn encode_option(
735 this: ::core::option::Option<Self>,
736 encoder: &mut ___E,
737 out: &mut ::core::mem::MaybeUninit<
738 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateResponse>,
739 >,
740 _: (),
741 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
742 if let Some(inner) = this {
743 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
744 ::fidl_next::wire::Box::encode_present(out);
745 } else {
746 ::fidl_next::wire::Box::encode_absent(out);
747 }
748
749 Ok(())
750 }
751 }
752
753 unsafe impl<'a, ___E>
754 ::fidl_next::EncodeOption<
755 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateResponse>,
756 ___E,
757 > for &'a CapabilityStoreDuplicateResponse
758 where
759 ___E: ::fidl_next::Encoder + ?Sized,
760 &'a CapabilityStoreDuplicateResponse:
761 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateResponse, ___E>,
762 {
763 #[inline]
764 fn encode_option(
765 this: ::core::option::Option<Self>,
766 encoder: &mut ___E,
767 out: &mut ::core::mem::MaybeUninit<
768 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateResponse>,
769 >,
770 _: (),
771 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
772 if let Some(inner) = this {
773 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
774 ::fidl_next::wire::Box::encode_present(out);
775 } else {
776 ::fidl_next::wire::Box::encode_absent(out);
777 }
778
779 Ok(())
780 }
781 }
782
783 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateResponse>
784 for CapabilityStoreDuplicateResponse
785 {
786 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
787 crate::wire::CapabilityStoreDuplicateResponse,
788 Self,
789 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
790
791 #[inline]
792 fn from_wire(wire: crate::wire::CapabilityStoreDuplicateResponse) -> Self {
793 Self {}
794 }
795 }
796
797 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateResponse>
798 for CapabilityStoreDuplicateResponse
799 {
800 #[inline]
801 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateResponse) -> Self {
802 Self {}
803 }
804 }
805
806 #[doc = " Error returned from methods in [CapabilityStore].\n"]
807 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
808 #[repr(u32)]
809 pub enum CapabilityStoreError {
810 IdNotFound = 1,
811 IdAlreadyExists = 2,
812 BadCapability = 3,
813 WrongType = 4,
814 NotDuplicatable = 5,
815 ItemNotFound = 6,
816 ItemAlreadyExists = 7,
817 InvalidKey = 8,
818 InvalidArgs = 9,
819 UnknownOrdinal_(u32) = 10,
820 }
821 impl ::std::convert::From<u32> for CapabilityStoreError {
822 fn from(value: u32) -> Self {
823 match value {
824 1 => Self::IdNotFound,
825 2 => Self::IdAlreadyExists,
826 3 => Self::BadCapability,
827 4 => Self::WrongType,
828 5 => Self::NotDuplicatable,
829 6 => Self::ItemNotFound,
830 7 => Self::ItemAlreadyExists,
831 8 => Self::InvalidKey,
832 9 => Self::InvalidArgs,
833
834 _ => Self::UnknownOrdinal_(value),
835 }
836 }
837 }
838
839 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreError, ___E>
840 for CapabilityStoreError
841 where
842 ___E: ?Sized,
843 {
844 #[inline]
845 fn encode(
846 self,
847 encoder: &mut ___E,
848 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreError>,
849 _: (),
850 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
851 ::fidl_next::Encode::encode(&self, encoder, out, ())
852 }
853 }
854
855 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreError, ___E>
856 for &'a CapabilityStoreError
857 where
858 ___E: ?Sized,
859 {
860 #[inline]
861 fn encode(
862 self,
863 encoder: &mut ___E,
864 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreError>,
865 _: (),
866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
867 ::fidl_next::munge!(let crate::wire::CapabilityStoreError { value } = out);
868 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
869 CapabilityStoreError::IdNotFound => 1,
870
871 CapabilityStoreError::IdAlreadyExists => 2,
872
873 CapabilityStoreError::BadCapability => 3,
874
875 CapabilityStoreError::WrongType => 4,
876
877 CapabilityStoreError::NotDuplicatable => 5,
878
879 CapabilityStoreError::ItemNotFound => 6,
880
881 CapabilityStoreError::ItemAlreadyExists => 7,
882
883 CapabilityStoreError::InvalidKey => 8,
884
885 CapabilityStoreError::InvalidArgs => 9,
886
887 CapabilityStoreError::UnknownOrdinal_(value) => value,
888 }));
889
890 Ok(())
891 }
892 }
893
894 impl ::core::convert::From<crate::wire::CapabilityStoreError> for CapabilityStoreError {
895 fn from(wire: crate::wire::CapabilityStoreError) -> Self {
896 match u32::from(wire.value) {
897 1 => Self::IdNotFound,
898
899 2 => Self::IdAlreadyExists,
900
901 3 => Self::BadCapability,
902
903 4 => Self::WrongType,
904
905 5 => Self::NotDuplicatable,
906
907 6 => Self::ItemNotFound,
908
909 7 => Self::ItemAlreadyExists,
910
911 8 => Self::InvalidKey,
912
913 9 => Self::InvalidArgs,
914
915 value => Self::UnknownOrdinal_(value),
916 }
917 }
918 }
919
920 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreError> for CapabilityStoreError {
921 #[inline]
922 fn from_wire(wire: crate::wire::CapabilityStoreError) -> Self {
923 Self::from(wire)
924 }
925 }
926
927 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreError> for CapabilityStoreError {
928 #[inline]
929 fn from_wire_ref(wire: &crate::wire::CapabilityStoreError) -> Self {
930 Self::from(*wire)
931 }
932 }
933
934 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
935 #[repr(C)]
936 pub struct CapabilityStoreDropRequest {
937 pub id: u64,
938 }
939
940 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>
941 for CapabilityStoreDropRequest
942 where
943 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
944 {
945 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
946 Self,
947 crate::wire::CapabilityStoreDropRequest,
948 > = unsafe {
949 ::fidl_next::CopyOptimization::enable_if(
950 true
951
952 && <
953 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
954 >::COPY_OPTIMIZATION.is_enabled()
955
956 )
957 };
958
959 #[inline]
960 fn encode(
961 self,
962 encoder_: &mut ___E,
963 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropRequest>,
964 _: (),
965 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
966 ::fidl_next::munge! {
967 let crate::wire::CapabilityStoreDropRequest {
968 id,
969
970 } = out_;
971 }
972
973 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
974
975 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
976
977 Ok(())
978 }
979 }
980
981 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>
982 for &'a CapabilityStoreDropRequest
983 where
984 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
985 {
986 #[inline]
987 fn encode(
988 self,
989 encoder_: &mut ___E,
990 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropRequest>,
991 _: (),
992 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
993 ::fidl_next::munge! {
994 let crate::wire::CapabilityStoreDropRequest {
995
996 id,
997
998 } = out_;
999 }
1000
1001 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1002
1003 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1004
1005 Ok(())
1006 }
1007 }
1008
1009 unsafe impl<___E>
1010 ::fidl_next::EncodeOption<
1011 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
1012 ___E,
1013 > for CapabilityStoreDropRequest
1014 where
1015 ___E: ::fidl_next::Encoder + ?Sized,
1016 CapabilityStoreDropRequest:
1017 ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>,
1018 {
1019 #[inline]
1020 fn encode_option(
1021 this: ::core::option::Option<Self>,
1022 encoder: &mut ___E,
1023 out: &mut ::core::mem::MaybeUninit<
1024 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
1025 >,
1026 _: (),
1027 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1028 if let Some(inner) = this {
1029 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1030 ::fidl_next::wire::Box::encode_present(out);
1031 } else {
1032 ::fidl_next::wire::Box::encode_absent(out);
1033 }
1034
1035 Ok(())
1036 }
1037 }
1038
1039 unsafe impl<'a, ___E>
1040 ::fidl_next::EncodeOption<
1041 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
1042 ___E,
1043 > for &'a CapabilityStoreDropRequest
1044 where
1045 ___E: ::fidl_next::Encoder + ?Sized,
1046 &'a CapabilityStoreDropRequest:
1047 ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>,
1048 {
1049 #[inline]
1050 fn encode_option(
1051 this: ::core::option::Option<Self>,
1052 encoder: &mut ___E,
1053 out: &mut ::core::mem::MaybeUninit<
1054 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
1055 >,
1056 _: (),
1057 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1058 if let Some(inner) = this {
1059 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1060 ::fidl_next::wire::Box::encode_present(out);
1061 } else {
1062 ::fidl_next::wire::Box::encode_absent(out);
1063 }
1064
1065 Ok(())
1066 }
1067 }
1068
1069 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropRequest> for CapabilityStoreDropRequest {
1070 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1071 crate::wire::CapabilityStoreDropRequest,
1072 Self,
1073 > = unsafe {
1074 ::fidl_next::CopyOptimization::enable_if(
1075 true
1076 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
1077 .is_enabled(),
1078 )
1079 };
1080
1081 #[inline]
1082 fn from_wire(wire: crate::wire::CapabilityStoreDropRequest) -> Self {
1083 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1084 }
1085 }
1086
1087 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropRequest>
1088 for CapabilityStoreDropRequest
1089 {
1090 #[inline]
1091 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropRequest) -> Self {
1092 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1093 }
1094 }
1095
1096 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1097 #[repr(C)]
1098 pub struct CapabilityStoreDropResponse {}
1099
1100 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDropResponse, ___E>
1101 for CapabilityStoreDropResponse
1102 where
1103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1104 {
1105 #[inline]
1106 fn encode(
1107 self,
1108 encoder_: &mut ___E,
1109 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropResponse>,
1110 _: (),
1111 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1112 ::fidl_next::munge! {
1113 let crate::wire::CapabilityStoreDropResponse {
1114
1115 _empty,
1116
1117 } = out_;
1118 }
1119
1120 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1121
1122 Ok(())
1123 }
1124 }
1125
1126 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDropResponse, ___E>
1127 for &'a CapabilityStoreDropResponse
1128 where
1129 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1130 {
1131 #[inline]
1132 fn encode(
1133 self,
1134 encoder_: &mut ___E,
1135 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropResponse>,
1136 _: (),
1137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1138 ::fidl_next::munge! {
1139 let crate::wire::CapabilityStoreDropResponse {
1140
1141 _empty,
1142
1143
1144 } = out_;
1145 }
1146
1147 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1148
1149 Ok(())
1150 }
1151 }
1152
1153 unsafe impl<___E>
1154 ::fidl_next::EncodeOption<
1155 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropResponse>,
1156 ___E,
1157 > for CapabilityStoreDropResponse
1158 where
1159 ___E: ::fidl_next::Encoder + ?Sized,
1160 CapabilityStoreDropResponse:
1161 ::fidl_next::Encode<crate::wire::CapabilityStoreDropResponse, ___E>,
1162 {
1163 #[inline]
1164 fn encode_option(
1165 this: ::core::option::Option<Self>,
1166 encoder: &mut ___E,
1167 out: &mut ::core::mem::MaybeUninit<
1168 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropResponse>,
1169 >,
1170 _: (),
1171 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1172 if let Some(inner) = this {
1173 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1174 ::fidl_next::wire::Box::encode_present(out);
1175 } else {
1176 ::fidl_next::wire::Box::encode_absent(out);
1177 }
1178
1179 Ok(())
1180 }
1181 }
1182
1183 unsafe impl<'a, ___E>
1184 ::fidl_next::EncodeOption<
1185 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropResponse>,
1186 ___E,
1187 > for &'a CapabilityStoreDropResponse
1188 where
1189 ___E: ::fidl_next::Encoder + ?Sized,
1190 &'a CapabilityStoreDropResponse:
1191 ::fidl_next::Encode<crate::wire::CapabilityStoreDropResponse, ___E>,
1192 {
1193 #[inline]
1194 fn encode_option(
1195 this: ::core::option::Option<Self>,
1196 encoder: &mut ___E,
1197 out: &mut ::core::mem::MaybeUninit<
1198 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropResponse>,
1199 >,
1200 _: (),
1201 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1202 if let Some(inner) = this {
1203 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1204 ::fidl_next::wire::Box::encode_present(out);
1205 } else {
1206 ::fidl_next::wire::Box::encode_absent(out);
1207 }
1208
1209 Ok(())
1210 }
1211 }
1212
1213 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropResponse>
1214 for CapabilityStoreDropResponse
1215 {
1216 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1217 crate::wire::CapabilityStoreDropResponse,
1218 Self,
1219 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1220
1221 #[inline]
1222 fn from_wire(wire: crate::wire::CapabilityStoreDropResponse) -> Self {
1223 Self {}
1224 }
1225 }
1226
1227 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropResponse>
1228 for CapabilityStoreDropResponse
1229 {
1230 #[inline]
1231 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropResponse) -> Self {
1232 Self {}
1233 }
1234 }
1235
1236 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1237 #[repr(C)]
1238 pub struct CapabilityStoreExportRequest {
1239 pub id: u64,
1240 }
1241
1242 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>
1243 for CapabilityStoreExportRequest
1244 where
1245 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1246 {
1247 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1248 Self,
1249 crate::wire::CapabilityStoreExportRequest,
1250 > = unsafe {
1251 ::fidl_next::CopyOptimization::enable_if(
1252 true
1253
1254 && <
1255 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
1256 >::COPY_OPTIMIZATION.is_enabled()
1257
1258 )
1259 };
1260
1261 #[inline]
1262 fn encode(
1263 self,
1264 encoder_: &mut ___E,
1265 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreExportRequest>,
1266 _: (),
1267 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1268 ::fidl_next::munge! {
1269 let crate::wire::CapabilityStoreExportRequest {
1270 id,
1271
1272 } = out_;
1273 }
1274
1275 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1276
1277 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1278
1279 Ok(())
1280 }
1281 }
1282
1283 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>
1284 for &'a CapabilityStoreExportRequest
1285 where
1286 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1287 {
1288 #[inline]
1289 fn encode(
1290 self,
1291 encoder_: &mut ___E,
1292 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreExportRequest>,
1293 _: (),
1294 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1295 ::fidl_next::munge! {
1296 let crate::wire::CapabilityStoreExportRequest {
1297
1298 id,
1299
1300 } = out_;
1301 }
1302
1303 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1304
1305 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1306
1307 Ok(())
1308 }
1309 }
1310
1311 unsafe impl<___E>
1312 ::fidl_next::EncodeOption<
1313 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
1314 ___E,
1315 > for CapabilityStoreExportRequest
1316 where
1317 ___E: ::fidl_next::Encoder + ?Sized,
1318 CapabilityStoreExportRequest:
1319 ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>,
1320 {
1321 #[inline]
1322 fn encode_option(
1323 this: ::core::option::Option<Self>,
1324 encoder: &mut ___E,
1325 out: &mut ::core::mem::MaybeUninit<
1326 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
1327 >,
1328 _: (),
1329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1330 if let Some(inner) = this {
1331 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1332 ::fidl_next::wire::Box::encode_present(out);
1333 } else {
1334 ::fidl_next::wire::Box::encode_absent(out);
1335 }
1336
1337 Ok(())
1338 }
1339 }
1340
1341 unsafe impl<'a, ___E>
1342 ::fidl_next::EncodeOption<
1343 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
1344 ___E,
1345 > for &'a CapabilityStoreExportRequest
1346 where
1347 ___E: ::fidl_next::Encoder + ?Sized,
1348 &'a CapabilityStoreExportRequest:
1349 ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>,
1350 {
1351 #[inline]
1352 fn encode_option(
1353 this: ::core::option::Option<Self>,
1354 encoder: &mut ___E,
1355 out: &mut ::core::mem::MaybeUninit<
1356 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
1357 >,
1358 _: (),
1359 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1360 if let Some(inner) = this {
1361 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1362 ::fidl_next::wire::Box::encode_present(out);
1363 } else {
1364 ::fidl_next::wire::Box::encode_absent(out);
1365 }
1366
1367 Ok(())
1368 }
1369 }
1370
1371 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreExportRequest>
1372 for CapabilityStoreExportRequest
1373 {
1374 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1375 crate::wire::CapabilityStoreExportRequest,
1376 Self,
1377 > = unsafe {
1378 ::fidl_next::CopyOptimization::enable_if(
1379 true
1380 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
1381 .is_enabled(),
1382 )
1383 };
1384
1385 #[inline]
1386 fn from_wire(wire: crate::wire::CapabilityStoreExportRequest) -> Self {
1387 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1388 }
1389 }
1390
1391 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreExportRequest>
1392 for CapabilityStoreExportRequest
1393 {
1394 #[inline]
1395 fn from_wire_ref(wire: &crate::wire::CapabilityStoreExportRequest) -> Self {
1396 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1397 }
1398 }
1399
1400 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1401 #[repr(C)]
1402 pub struct CapabilityStoreImportResponse {}
1403
1404 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreImportResponse, ___E>
1405 for CapabilityStoreImportResponse
1406 where
1407 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1408 {
1409 #[inline]
1410 fn encode(
1411 self,
1412 encoder_: &mut ___E,
1413 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportResponse>,
1414 _: (),
1415 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1416 ::fidl_next::munge! {
1417 let crate::wire::CapabilityStoreImportResponse {
1418
1419 _empty,
1420
1421 } = out_;
1422 }
1423
1424 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1425
1426 Ok(())
1427 }
1428 }
1429
1430 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreImportResponse, ___E>
1431 for &'a CapabilityStoreImportResponse
1432 where
1433 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1434 {
1435 #[inline]
1436 fn encode(
1437 self,
1438 encoder_: &mut ___E,
1439 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportResponse>,
1440 _: (),
1441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1442 ::fidl_next::munge! {
1443 let crate::wire::CapabilityStoreImportResponse {
1444
1445 _empty,
1446
1447
1448 } = out_;
1449 }
1450
1451 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1452
1453 Ok(())
1454 }
1455 }
1456
1457 unsafe impl<___E>
1458 ::fidl_next::EncodeOption<
1459 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreImportResponse>,
1460 ___E,
1461 > for CapabilityStoreImportResponse
1462 where
1463 ___E: ::fidl_next::Encoder + ?Sized,
1464 CapabilityStoreImportResponse:
1465 ::fidl_next::Encode<crate::wire::CapabilityStoreImportResponse, ___E>,
1466 {
1467 #[inline]
1468 fn encode_option(
1469 this: ::core::option::Option<Self>,
1470 encoder: &mut ___E,
1471 out: &mut ::core::mem::MaybeUninit<
1472 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreImportResponse>,
1473 >,
1474 _: (),
1475 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1476 if let Some(inner) = this {
1477 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1478 ::fidl_next::wire::Box::encode_present(out);
1479 } else {
1480 ::fidl_next::wire::Box::encode_absent(out);
1481 }
1482
1483 Ok(())
1484 }
1485 }
1486
1487 unsafe impl<'a, ___E>
1488 ::fidl_next::EncodeOption<
1489 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreImportResponse>,
1490 ___E,
1491 > for &'a CapabilityStoreImportResponse
1492 where
1493 ___E: ::fidl_next::Encoder + ?Sized,
1494 &'a CapabilityStoreImportResponse:
1495 ::fidl_next::Encode<crate::wire::CapabilityStoreImportResponse, ___E>,
1496 {
1497 #[inline]
1498 fn encode_option(
1499 this: ::core::option::Option<Self>,
1500 encoder: &mut ___E,
1501 out: &mut ::core::mem::MaybeUninit<
1502 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreImportResponse>,
1503 >,
1504 _: (),
1505 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1506 if let Some(inner) = this {
1507 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1508 ::fidl_next::wire::Box::encode_present(out);
1509 } else {
1510 ::fidl_next::wire::Box::encode_absent(out);
1511 }
1512
1513 Ok(())
1514 }
1515 }
1516
1517 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreImportResponse>
1518 for CapabilityStoreImportResponse
1519 {
1520 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1521 crate::wire::CapabilityStoreImportResponse,
1522 Self,
1523 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1524
1525 #[inline]
1526 fn from_wire(wire: crate::wire::CapabilityStoreImportResponse) -> Self {
1527 Self {}
1528 }
1529 }
1530
1531 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreImportResponse>
1532 for CapabilityStoreImportResponse
1533 {
1534 #[inline]
1535 fn from_wire_ref(wire: &crate::wire::CapabilityStoreImportResponse) -> Self {
1536 Self {}
1537 }
1538 }
1539
1540 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1541 #[repr(C)]
1542 pub struct CapabilityStoreConnectorCreateResponse {}
1543
1544 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateResponse, ___E>
1545 for CapabilityStoreConnectorCreateResponse
1546 where
1547 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1548 {
1549 #[inline]
1550 fn encode(
1551 self,
1552 encoder_: &mut ___E,
1553 out_: &mut ::core::mem::MaybeUninit<
1554 crate::wire::CapabilityStoreConnectorCreateResponse,
1555 >,
1556 _: (),
1557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1558 ::fidl_next::munge! {
1559 let crate::wire::CapabilityStoreConnectorCreateResponse {
1560
1561 _empty,
1562
1563 } = out_;
1564 }
1565
1566 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1567
1568 Ok(())
1569 }
1570 }
1571
1572 unsafe impl<'a, ___E>
1573 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateResponse, ___E>
1574 for &'a CapabilityStoreConnectorCreateResponse
1575 where
1576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1577 {
1578 #[inline]
1579 fn encode(
1580 self,
1581 encoder_: &mut ___E,
1582 out_: &mut ::core::mem::MaybeUninit<
1583 crate::wire::CapabilityStoreConnectorCreateResponse,
1584 >,
1585 _: (),
1586 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1587 ::fidl_next::munge! {
1588 let crate::wire::CapabilityStoreConnectorCreateResponse {
1589
1590 _empty,
1591
1592
1593 } = out_;
1594 }
1595
1596 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1597
1598 Ok(())
1599 }
1600 }
1601
1602 unsafe impl<___E>
1603 ::fidl_next::EncodeOption<
1604 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorCreateResponse>,
1605 ___E,
1606 > for CapabilityStoreConnectorCreateResponse
1607 where
1608 ___E: ::fidl_next::Encoder + ?Sized,
1609 CapabilityStoreConnectorCreateResponse:
1610 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateResponse, ___E>,
1611 {
1612 #[inline]
1613 fn encode_option(
1614 this: ::core::option::Option<Self>,
1615 encoder: &mut ___E,
1616 out: &mut ::core::mem::MaybeUninit<
1617 ::fidl_next::wire::Box<
1618 'static,
1619 crate::wire::CapabilityStoreConnectorCreateResponse,
1620 >,
1621 >,
1622 _: (),
1623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1624 if let Some(inner) = this {
1625 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1626 ::fidl_next::wire::Box::encode_present(out);
1627 } else {
1628 ::fidl_next::wire::Box::encode_absent(out);
1629 }
1630
1631 Ok(())
1632 }
1633 }
1634
1635 unsafe impl<'a, ___E>
1636 ::fidl_next::EncodeOption<
1637 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorCreateResponse>,
1638 ___E,
1639 > for &'a CapabilityStoreConnectorCreateResponse
1640 where
1641 ___E: ::fidl_next::Encoder + ?Sized,
1642 &'a CapabilityStoreConnectorCreateResponse:
1643 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateResponse, ___E>,
1644 {
1645 #[inline]
1646 fn encode_option(
1647 this: ::core::option::Option<Self>,
1648 encoder: &mut ___E,
1649 out: &mut ::core::mem::MaybeUninit<
1650 ::fidl_next::wire::Box<
1651 'static,
1652 crate::wire::CapabilityStoreConnectorCreateResponse,
1653 >,
1654 >,
1655 _: (),
1656 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1657 if let Some(inner) = this {
1658 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1659 ::fidl_next::wire::Box::encode_present(out);
1660 } else {
1661 ::fidl_next::wire::Box::encode_absent(out);
1662 }
1663
1664 Ok(())
1665 }
1666 }
1667
1668 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateResponse>
1669 for CapabilityStoreConnectorCreateResponse
1670 {
1671 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1672 crate::wire::CapabilityStoreConnectorCreateResponse,
1673 Self,
1674 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1675
1676 #[inline]
1677 fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateResponse) -> Self {
1678 Self {}
1679 }
1680 }
1681
1682 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreConnectorCreateResponse>
1683 for CapabilityStoreConnectorCreateResponse
1684 {
1685 #[inline]
1686 fn from_wire_ref(wire: &crate::wire::CapabilityStoreConnectorCreateResponse) -> Self {
1687 Self {}
1688 }
1689 }
1690
1691 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1692 #[repr(C)]
1693 pub struct CapabilityStoreConnectorOpenResponse {}
1694
1695 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenResponse, ___E>
1696 for CapabilityStoreConnectorOpenResponse
1697 where
1698 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1699 {
1700 #[inline]
1701 fn encode(
1702 self,
1703 encoder_: &mut ___E,
1704 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenResponse>,
1705 _: (),
1706 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1707 ::fidl_next::munge! {
1708 let crate::wire::CapabilityStoreConnectorOpenResponse {
1709
1710 _empty,
1711
1712 } = out_;
1713 }
1714
1715 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1716
1717 Ok(())
1718 }
1719 }
1720
1721 unsafe impl<'a, ___E>
1722 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenResponse, ___E>
1723 for &'a CapabilityStoreConnectorOpenResponse
1724 where
1725 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1726 {
1727 #[inline]
1728 fn encode(
1729 self,
1730 encoder_: &mut ___E,
1731 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenResponse>,
1732 _: (),
1733 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1734 ::fidl_next::munge! {
1735 let crate::wire::CapabilityStoreConnectorOpenResponse {
1736
1737 _empty,
1738
1739
1740 } = out_;
1741 }
1742
1743 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1744
1745 Ok(())
1746 }
1747 }
1748
1749 unsafe impl<___E>
1750 ::fidl_next::EncodeOption<
1751 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorOpenResponse>,
1752 ___E,
1753 > for CapabilityStoreConnectorOpenResponse
1754 where
1755 ___E: ::fidl_next::Encoder + ?Sized,
1756 CapabilityStoreConnectorOpenResponse:
1757 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenResponse, ___E>,
1758 {
1759 #[inline]
1760 fn encode_option(
1761 this: ::core::option::Option<Self>,
1762 encoder: &mut ___E,
1763 out: &mut ::core::mem::MaybeUninit<
1764 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorOpenResponse>,
1765 >,
1766 _: (),
1767 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1768 if let Some(inner) = this {
1769 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1770 ::fidl_next::wire::Box::encode_present(out);
1771 } else {
1772 ::fidl_next::wire::Box::encode_absent(out);
1773 }
1774
1775 Ok(())
1776 }
1777 }
1778
1779 unsafe impl<'a, ___E>
1780 ::fidl_next::EncodeOption<
1781 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorOpenResponse>,
1782 ___E,
1783 > for &'a CapabilityStoreConnectorOpenResponse
1784 where
1785 ___E: ::fidl_next::Encoder + ?Sized,
1786 &'a CapabilityStoreConnectorOpenResponse:
1787 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenResponse, ___E>,
1788 {
1789 #[inline]
1790 fn encode_option(
1791 this: ::core::option::Option<Self>,
1792 encoder: &mut ___E,
1793 out: &mut ::core::mem::MaybeUninit<
1794 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorOpenResponse>,
1795 >,
1796 _: (),
1797 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1798 if let Some(inner) = this {
1799 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1800 ::fidl_next::wire::Box::encode_present(out);
1801 } else {
1802 ::fidl_next::wire::Box::encode_absent(out);
1803 }
1804
1805 Ok(())
1806 }
1807 }
1808
1809 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenResponse>
1810 for CapabilityStoreConnectorOpenResponse
1811 {
1812 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1813 crate::wire::CapabilityStoreConnectorOpenResponse,
1814 Self,
1815 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1816
1817 #[inline]
1818 fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenResponse) -> Self {
1819 Self {}
1820 }
1821 }
1822
1823 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreConnectorOpenResponse>
1824 for CapabilityStoreConnectorOpenResponse
1825 {
1826 #[inline]
1827 fn from_wire_ref(wire: &crate::wire::CapabilityStoreConnectorOpenResponse) -> Self {
1828 Self {}
1829 }
1830 }
1831
1832 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1833 #[repr(C)]
1834 pub struct CapabilityStoreDirConnectorCreateResponse {}
1835
1836 unsafe impl<___E>
1837 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateResponse, ___E>
1838 for CapabilityStoreDirConnectorCreateResponse
1839 where
1840 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1841 {
1842 #[inline]
1843 fn encode(
1844 self,
1845 encoder_: &mut ___E,
1846 out_: &mut ::core::mem::MaybeUninit<
1847 crate::wire::CapabilityStoreDirConnectorCreateResponse,
1848 >,
1849 _: (),
1850 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1851 ::fidl_next::munge! {
1852 let crate::wire::CapabilityStoreDirConnectorCreateResponse {
1853
1854 _empty,
1855
1856 } = out_;
1857 }
1858
1859 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1860
1861 Ok(())
1862 }
1863 }
1864
1865 unsafe impl<'a, ___E>
1866 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateResponse, ___E>
1867 for &'a CapabilityStoreDirConnectorCreateResponse
1868 where
1869 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1870 {
1871 #[inline]
1872 fn encode(
1873 self,
1874 encoder_: &mut ___E,
1875 out_: &mut ::core::mem::MaybeUninit<
1876 crate::wire::CapabilityStoreDirConnectorCreateResponse,
1877 >,
1878 _: (),
1879 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1880 ::fidl_next::munge! {
1881 let crate::wire::CapabilityStoreDirConnectorCreateResponse {
1882
1883 _empty,
1884
1885
1886 } = out_;
1887 }
1888
1889 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
1890
1891 Ok(())
1892 }
1893 }
1894
1895 unsafe impl<___E>
1896 ::fidl_next::EncodeOption<
1897 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDirConnectorCreateResponse>,
1898 ___E,
1899 > for CapabilityStoreDirConnectorCreateResponse
1900 where
1901 ___E: ::fidl_next::Encoder + ?Sized,
1902 CapabilityStoreDirConnectorCreateResponse:
1903 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateResponse, ___E>,
1904 {
1905 #[inline]
1906 fn encode_option(
1907 this: ::core::option::Option<Self>,
1908 encoder: &mut ___E,
1909 out: &mut ::core::mem::MaybeUninit<
1910 ::fidl_next::wire::Box<
1911 'static,
1912 crate::wire::CapabilityStoreDirConnectorCreateResponse,
1913 >,
1914 >,
1915 _: (),
1916 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1917 if let Some(inner) = this {
1918 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1919 ::fidl_next::wire::Box::encode_present(out);
1920 } else {
1921 ::fidl_next::wire::Box::encode_absent(out);
1922 }
1923
1924 Ok(())
1925 }
1926 }
1927
1928 unsafe impl<'a, ___E>
1929 ::fidl_next::EncodeOption<
1930 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDirConnectorCreateResponse>,
1931 ___E,
1932 > for &'a CapabilityStoreDirConnectorCreateResponse
1933 where
1934 ___E: ::fidl_next::Encoder + ?Sized,
1935 &'a CapabilityStoreDirConnectorCreateResponse:
1936 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateResponse, ___E>,
1937 {
1938 #[inline]
1939 fn encode_option(
1940 this: ::core::option::Option<Self>,
1941 encoder: &mut ___E,
1942 out: &mut ::core::mem::MaybeUninit<
1943 ::fidl_next::wire::Box<
1944 'static,
1945 crate::wire::CapabilityStoreDirConnectorCreateResponse,
1946 >,
1947 >,
1948 _: (),
1949 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1950 if let Some(inner) = this {
1951 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1952 ::fidl_next::wire::Box::encode_present(out);
1953 } else {
1954 ::fidl_next::wire::Box::encode_absent(out);
1955 }
1956
1957 Ok(())
1958 }
1959 }
1960
1961 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateResponse>
1962 for CapabilityStoreDirConnectorCreateResponse
1963 {
1964 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1965 crate::wire::CapabilityStoreDirConnectorCreateResponse,
1966 Self,
1967 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1968
1969 #[inline]
1970 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateResponse) -> Self {
1971 Self {}
1972 }
1973 }
1974
1975 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDirConnectorCreateResponse>
1976 for CapabilityStoreDirConnectorCreateResponse
1977 {
1978 #[inline]
1979 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDirConnectorCreateResponse) -> Self {
1980 Self {}
1981 }
1982 }
1983
1984 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1985 #[repr(C)]
1986 pub struct CapabilityStoreDirConnectorOpenResponse {}
1987
1988 unsafe impl<___E>
1989 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenResponse, ___E>
1990 for CapabilityStoreDirConnectorOpenResponse
1991 where
1992 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1993 {
1994 #[inline]
1995 fn encode(
1996 self,
1997 encoder_: &mut ___E,
1998 out_: &mut ::core::mem::MaybeUninit<
1999 crate::wire::CapabilityStoreDirConnectorOpenResponse,
2000 >,
2001 _: (),
2002 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2003 ::fidl_next::munge! {
2004 let crate::wire::CapabilityStoreDirConnectorOpenResponse {
2005
2006 _empty,
2007
2008 } = out_;
2009 }
2010
2011 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2012
2013 Ok(())
2014 }
2015 }
2016
2017 unsafe impl<'a, ___E>
2018 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenResponse, ___E>
2019 for &'a CapabilityStoreDirConnectorOpenResponse
2020 where
2021 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2022 {
2023 #[inline]
2024 fn encode(
2025 self,
2026 encoder_: &mut ___E,
2027 out_: &mut ::core::mem::MaybeUninit<
2028 crate::wire::CapabilityStoreDirConnectorOpenResponse,
2029 >,
2030 _: (),
2031 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2032 ::fidl_next::munge! {
2033 let crate::wire::CapabilityStoreDirConnectorOpenResponse {
2034
2035 _empty,
2036
2037
2038 } = out_;
2039 }
2040
2041 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2042
2043 Ok(())
2044 }
2045 }
2046
2047 unsafe impl<___E>
2048 ::fidl_next::EncodeOption<
2049 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDirConnectorOpenResponse>,
2050 ___E,
2051 > for CapabilityStoreDirConnectorOpenResponse
2052 where
2053 ___E: ::fidl_next::Encoder + ?Sized,
2054 CapabilityStoreDirConnectorOpenResponse:
2055 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenResponse, ___E>,
2056 {
2057 #[inline]
2058 fn encode_option(
2059 this: ::core::option::Option<Self>,
2060 encoder: &mut ___E,
2061 out: &mut ::core::mem::MaybeUninit<
2062 ::fidl_next::wire::Box<
2063 'static,
2064 crate::wire::CapabilityStoreDirConnectorOpenResponse,
2065 >,
2066 >,
2067 _: (),
2068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2069 if let Some(inner) = this {
2070 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2071 ::fidl_next::wire::Box::encode_present(out);
2072 } else {
2073 ::fidl_next::wire::Box::encode_absent(out);
2074 }
2075
2076 Ok(())
2077 }
2078 }
2079
2080 unsafe impl<'a, ___E>
2081 ::fidl_next::EncodeOption<
2082 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDirConnectorOpenResponse>,
2083 ___E,
2084 > for &'a CapabilityStoreDirConnectorOpenResponse
2085 where
2086 ___E: ::fidl_next::Encoder + ?Sized,
2087 &'a CapabilityStoreDirConnectorOpenResponse:
2088 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenResponse, ___E>,
2089 {
2090 #[inline]
2091 fn encode_option(
2092 this: ::core::option::Option<Self>,
2093 encoder: &mut ___E,
2094 out: &mut ::core::mem::MaybeUninit<
2095 ::fidl_next::wire::Box<
2096 'static,
2097 crate::wire::CapabilityStoreDirConnectorOpenResponse,
2098 >,
2099 >,
2100 _: (),
2101 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2102 if let Some(inner) = this {
2103 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2104 ::fidl_next::wire::Box::encode_present(out);
2105 } else {
2106 ::fidl_next::wire::Box::encode_absent(out);
2107 }
2108
2109 Ok(())
2110 }
2111 }
2112
2113 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenResponse>
2114 for CapabilityStoreDirConnectorOpenResponse
2115 {
2116 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2117 crate::wire::CapabilityStoreDirConnectorOpenResponse,
2118 Self,
2119 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2120
2121 #[inline]
2122 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorOpenResponse) -> Self {
2123 Self {}
2124 }
2125 }
2126
2127 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDirConnectorOpenResponse>
2128 for CapabilityStoreDirConnectorOpenResponse
2129 {
2130 #[inline]
2131 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDirConnectorOpenResponse) -> Self {
2132 Self {}
2133 }
2134 }
2135
2136 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2137 #[repr(C)]
2138 pub struct CapabilityStoreDictionaryCreateRequest {
2139 pub id: u64,
2140 }
2141
2142 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>
2143 for CapabilityStoreDictionaryCreateRequest
2144 where
2145 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2146 {
2147 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2148 Self,
2149 crate::wire::CapabilityStoreDictionaryCreateRequest,
2150 > = unsafe {
2151 ::fidl_next::CopyOptimization::enable_if(
2152 true
2153
2154 && <
2155 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
2156 >::COPY_OPTIMIZATION.is_enabled()
2157
2158 )
2159 };
2160
2161 #[inline]
2162 fn encode(
2163 self,
2164 encoder_: &mut ___E,
2165 out_: &mut ::core::mem::MaybeUninit<
2166 crate::wire::CapabilityStoreDictionaryCreateRequest,
2167 >,
2168 _: (),
2169 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2170 ::fidl_next::munge! {
2171 let crate::wire::CapabilityStoreDictionaryCreateRequest {
2172 id,
2173
2174 } = out_;
2175 }
2176
2177 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2178
2179 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2180
2181 Ok(())
2182 }
2183 }
2184
2185 unsafe impl<'a, ___E>
2186 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>
2187 for &'a CapabilityStoreDictionaryCreateRequest
2188 where
2189 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2190 {
2191 #[inline]
2192 fn encode(
2193 self,
2194 encoder_: &mut ___E,
2195 out_: &mut ::core::mem::MaybeUninit<
2196 crate::wire::CapabilityStoreDictionaryCreateRequest,
2197 >,
2198 _: (),
2199 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2200 ::fidl_next::munge! {
2201 let crate::wire::CapabilityStoreDictionaryCreateRequest {
2202
2203 id,
2204
2205 } = out_;
2206 }
2207
2208 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
2209
2210 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2211
2212 Ok(())
2213 }
2214 }
2215
2216 unsafe impl<___E>
2217 ::fidl_next::EncodeOption<
2218 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCreateRequest>,
2219 ___E,
2220 > for CapabilityStoreDictionaryCreateRequest
2221 where
2222 ___E: ::fidl_next::Encoder + ?Sized,
2223 CapabilityStoreDictionaryCreateRequest:
2224 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>,
2225 {
2226 #[inline]
2227 fn encode_option(
2228 this: ::core::option::Option<Self>,
2229 encoder: &mut ___E,
2230 out: &mut ::core::mem::MaybeUninit<
2231 ::fidl_next::wire::Box<
2232 'static,
2233 crate::wire::CapabilityStoreDictionaryCreateRequest,
2234 >,
2235 >,
2236 _: (),
2237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2238 if let Some(inner) = this {
2239 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2240 ::fidl_next::wire::Box::encode_present(out);
2241 } else {
2242 ::fidl_next::wire::Box::encode_absent(out);
2243 }
2244
2245 Ok(())
2246 }
2247 }
2248
2249 unsafe impl<'a, ___E>
2250 ::fidl_next::EncodeOption<
2251 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCreateRequest>,
2252 ___E,
2253 > for &'a CapabilityStoreDictionaryCreateRequest
2254 where
2255 ___E: ::fidl_next::Encoder + ?Sized,
2256 &'a CapabilityStoreDictionaryCreateRequest:
2257 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>,
2258 {
2259 #[inline]
2260 fn encode_option(
2261 this: ::core::option::Option<Self>,
2262 encoder: &mut ___E,
2263 out: &mut ::core::mem::MaybeUninit<
2264 ::fidl_next::wire::Box<
2265 'static,
2266 crate::wire::CapabilityStoreDictionaryCreateRequest,
2267 >,
2268 >,
2269 _: (),
2270 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2271 if let Some(inner) = this {
2272 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2273 ::fidl_next::wire::Box::encode_present(out);
2274 } else {
2275 ::fidl_next::wire::Box::encode_absent(out);
2276 }
2277
2278 Ok(())
2279 }
2280 }
2281
2282 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateRequest>
2283 for CapabilityStoreDictionaryCreateRequest
2284 {
2285 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2286 crate::wire::CapabilityStoreDictionaryCreateRequest,
2287 Self,
2288 > = unsafe {
2289 ::fidl_next::CopyOptimization::enable_if(
2290 true
2291 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
2292 .is_enabled(),
2293 )
2294 };
2295
2296 #[inline]
2297 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
2298 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2299 }
2300 }
2301
2302 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateRequest>
2303 for CapabilityStoreDictionaryCreateRequest
2304 {
2305 #[inline]
2306 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
2307 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2308 }
2309 }
2310
2311 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2312 #[repr(C)]
2313 pub struct CapabilityStoreDictionaryCreateResponse {}
2314
2315 unsafe impl<___E>
2316 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateResponse, ___E>
2317 for CapabilityStoreDictionaryCreateResponse
2318 where
2319 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2320 {
2321 #[inline]
2322 fn encode(
2323 self,
2324 encoder_: &mut ___E,
2325 out_: &mut ::core::mem::MaybeUninit<
2326 crate::wire::CapabilityStoreDictionaryCreateResponse,
2327 >,
2328 _: (),
2329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2330 ::fidl_next::munge! {
2331 let crate::wire::CapabilityStoreDictionaryCreateResponse {
2332
2333 _empty,
2334
2335 } = out_;
2336 }
2337
2338 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2339
2340 Ok(())
2341 }
2342 }
2343
2344 unsafe impl<'a, ___E>
2345 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateResponse, ___E>
2346 for &'a CapabilityStoreDictionaryCreateResponse
2347 where
2348 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2349 {
2350 #[inline]
2351 fn encode(
2352 self,
2353 encoder_: &mut ___E,
2354 out_: &mut ::core::mem::MaybeUninit<
2355 crate::wire::CapabilityStoreDictionaryCreateResponse,
2356 >,
2357 _: (),
2358 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2359 ::fidl_next::munge! {
2360 let crate::wire::CapabilityStoreDictionaryCreateResponse {
2361
2362 _empty,
2363
2364
2365 } = out_;
2366 }
2367
2368 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2369
2370 Ok(())
2371 }
2372 }
2373
2374 unsafe impl<___E>
2375 ::fidl_next::EncodeOption<
2376 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCreateResponse>,
2377 ___E,
2378 > for CapabilityStoreDictionaryCreateResponse
2379 where
2380 ___E: ::fidl_next::Encoder + ?Sized,
2381 CapabilityStoreDictionaryCreateResponse:
2382 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateResponse, ___E>,
2383 {
2384 #[inline]
2385 fn encode_option(
2386 this: ::core::option::Option<Self>,
2387 encoder: &mut ___E,
2388 out: &mut ::core::mem::MaybeUninit<
2389 ::fidl_next::wire::Box<
2390 'static,
2391 crate::wire::CapabilityStoreDictionaryCreateResponse,
2392 >,
2393 >,
2394 _: (),
2395 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2396 if let Some(inner) = this {
2397 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2398 ::fidl_next::wire::Box::encode_present(out);
2399 } else {
2400 ::fidl_next::wire::Box::encode_absent(out);
2401 }
2402
2403 Ok(())
2404 }
2405 }
2406
2407 unsafe impl<'a, ___E>
2408 ::fidl_next::EncodeOption<
2409 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCreateResponse>,
2410 ___E,
2411 > for &'a CapabilityStoreDictionaryCreateResponse
2412 where
2413 ___E: ::fidl_next::Encoder + ?Sized,
2414 &'a CapabilityStoreDictionaryCreateResponse:
2415 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateResponse, ___E>,
2416 {
2417 #[inline]
2418 fn encode_option(
2419 this: ::core::option::Option<Self>,
2420 encoder: &mut ___E,
2421 out: &mut ::core::mem::MaybeUninit<
2422 ::fidl_next::wire::Box<
2423 'static,
2424 crate::wire::CapabilityStoreDictionaryCreateResponse,
2425 >,
2426 >,
2427 _: (),
2428 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2429 if let Some(inner) = this {
2430 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2431 ::fidl_next::wire::Box::encode_present(out);
2432 } else {
2433 ::fidl_next::wire::Box::encode_absent(out);
2434 }
2435
2436 Ok(())
2437 }
2438 }
2439
2440 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateResponse>
2441 for CapabilityStoreDictionaryCreateResponse
2442 {
2443 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2444 crate::wire::CapabilityStoreDictionaryCreateResponse,
2445 Self,
2446 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2447
2448 #[inline]
2449 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateResponse) -> Self {
2450 Self {}
2451 }
2452 }
2453
2454 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateResponse>
2455 for CapabilityStoreDictionaryCreateResponse
2456 {
2457 #[inline]
2458 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateResponse) -> Self {
2459 Self {}
2460 }
2461 }
2462
2463 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2464 #[repr(C)]
2465 pub struct CapabilityStoreDictionaryLegacyImportResponse {}
2466
2467 unsafe impl<___E>
2468 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportResponse, ___E>
2469 for CapabilityStoreDictionaryLegacyImportResponse
2470 where
2471 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2472 {
2473 #[inline]
2474 fn encode(
2475 self,
2476 encoder_: &mut ___E,
2477 out_: &mut ::core::mem::MaybeUninit<
2478 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2479 >,
2480 _: (),
2481 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2482 ::fidl_next::munge! {
2483 let crate::wire::CapabilityStoreDictionaryLegacyImportResponse {
2484
2485 _empty,
2486
2487 } = out_;
2488 }
2489
2490 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2491
2492 Ok(())
2493 }
2494 }
2495
2496 unsafe impl<'a, ___E>
2497 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportResponse, ___E>
2498 for &'a CapabilityStoreDictionaryLegacyImportResponse
2499 where
2500 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2501 {
2502 #[inline]
2503 fn encode(
2504 self,
2505 encoder_: &mut ___E,
2506 out_: &mut ::core::mem::MaybeUninit<
2507 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2508 >,
2509 _: (),
2510 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2511 ::fidl_next::munge! {
2512 let crate::wire::CapabilityStoreDictionaryLegacyImportResponse {
2513
2514 _empty,
2515
2516
2517 } = out_;
2518 }
2519
2520 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2521
2522 Ok(())
2523 }
2524 }
2525
2526 unsafe impl<___E>
2527 ::fidl_next::EncodeOption<
2528 ::fidl_next::wire::Box<
2529 'static,
2530 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2531 >,
2532 ___E,
2533 > for CapabilityStoreDictionaryLegacyImportResponse
2534 where
2535 ___E: ::fidl_next::Encoder + ?Sized,
2536 CapabilityStoreDictionaryLegacyImportResponse:
2537 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportResponse, ___E>,
2538 {
2539 #[inline]
2540 fn encode_option(
2541 this: ::core::option::Option<Self>,
2542 encoder: &mut ___E,
2543 out: &mut ::core::mem::MaybeUninit<
2544 ::fidl_next::wire::Box<
2545 'static,
2546 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2547 >,
2548 >,
2549 _: (),
2550 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2551 if let Some(inner) = this {
2552 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2553 ::fidl_next::wire::Box::encode_present(out);
2554 } else {
2555 ::fidl_next::wire::Box::encode_absent(out);
2556 }
2557
2558 Ok(())
2559 }
2560 }
2561
2562 unsafe impl<'a, ___E>
2563 ::fidl_next::EncodeOption<
2564 ::fidl_next::wire::Box<
2565 'static,
2566 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2567 >,
2568 ___E,
2569 > for &'a CapabilityStoreDictionaryLegacyImportResponse
2570 where
2571 ___E: ::fidl_next::Encoder + ?Sized,
2572 &'a CapabilityStoreDictionaryLegacyImportResponse:
2573 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportResponse, ___E>,
2574 {
2575 #[inline]
2576 fn encode_option(
2577 this: ::core::option::Option<Self>,
2578 encoder: &mut ___E,
2579 out: &mut ::core::mem::MaybeUninit<
2580 ::fidl_next::wire::Box<
2581 'static,
2582 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2583 >,
2584 >,
2585 _: (),
2586 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2587 if let Some(inner) = this {
2588 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2589 ::fidl_next::wire::Box::encode_present(out);
2590 } else {
2591 ::fidl_next::wire::Box::encode_absent(out);
2592 }
2593
2594 Ok(())
2595 }
2596 }
2597
2598 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportResponse>
2599 for CapabilityStoreDictionaryLegacyImportResponse
2600 {
2601 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2602 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2603 Self,
2604 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2605
2606 #[inline]
2607 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportResponse) -> Self {
2608 Self {}
2609 }
2610 }
2611
2612 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryLegacyImportResponse>
2613 for CapabilityStoreDictionaryLegacyImportResponse
2614 {
2615 #[inline]
2616 fn from_wire_ref(
2617 wire: &crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
2618 ) -> Self {
2619 Self {}
2620 }
2621 }
2622
2623 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2624 #[repr(C)]
2625 pub struct CapabilityStoreDictionaryLegacyExportResponse {}
2626
2627 unsafe impl<___E>
2628 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportResponse, ___E>
2629 for CapabilityStoreDictionaryLegacyExportResponse
2630 where
2631 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2632 {
2633 #[inline]
2634 fn encode(
2635 self,
2636 encoder_: &mut ___E,
2637 out_: &mut ::core::mem::MaybeUninit<
2638 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2639 >,
2640 _: (),
2641 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2642 ::fidl_next::munge! {
2643 let crate::wire::CapabilityStoreDictionaryLegacyExportResponse {
2644
2645 _empty,
2646
2647 } = out_;
2648 }
2649
2650 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2651
2652 Ok(())
2653 }
2654 }
2655
2656 unsafe impl<'a, ___E>
2657 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportResponse, ___E>
2658 for &'a CapabilityStoreDictionaryLegacyExportResponse
2659 where
2660 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2661 {
2662 #[inline]
2663 fn encode(
2664 self,
2665 encoder_: &mut ___E,
2666 out_: &mut ::core::mem::MaybeUninit<
2667 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2668 >,
2669 _: (),
2670 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2671 ::fidl_next::munge! {
2672 let crate::wire::CapabilityStoreDictionaryLegacyExportResponse {
2673
2674 _empty,
2675
2676
2677 } = out_;
2678 }
2679
2680 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
2681
2682 Ok(())
2683 }
2684 }
2685
2686 unsafe impl<___E>
2687 ::fidl_next::EncodeOption<
2688 ::fidl_next::wire::Box<
2689 'static,
2690 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2691 >,
2692 ___E,
2693 > for CapabilityStoreDictionaryLegacyExportResponse
2694 where
2695 ___E: ::fidl_next::Encoder + ?Sized,
2696 CapabilityStoreDictionaryLegacyExportResponse:
2697 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportResponse, ___E>,
2698 {
2699 #[inline]
2700 fn encode_option(
2701 this: ::core::option::Option<Self>,
2702 encoder: &mut ___E,
2703 out: &mut ::core::mem::MaybeUninit<
2704 ::fidl_next::wire::Box<
2705 'static,
2706 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2707 >,
2708 >,
2709 _: (),
2710 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2711 if let Some(inner) = this {
2712 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2713 ::fidl_next::wire::Box::encode_present(out);
2714 } else {
2715 ::fidl_next::wire::Box::encode_absent(out);
2716 }
2717
2718 Ok(())
2719 }
2720 }
2721
2722 unsafe impl<'a, ___E>
2723 ::fidl_next::EncodeOption<
2724 ::fidl_next::wire::Box<
2725 'static,
2726 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2727 >,
2728 ___E,
2729 > for &'a CapabilityStoreDictionaryLegacyExportResponse
2730 where
2731 ___E: ::fidl_next::Encoder + ?Sized,
2732 &'a CapabilityStoreDictionaryLegacyExportResponse:
2733 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportResponse, ___E>,
2734 {
2735 #[inline]
2736 fn encode_option(
2737 this: ::core::option::Option<Self>,
2738 encoder: &mut ___E,
2739 out: &mut ::core::mem::MaybeUninit<
2740 ::fidl_next::wire::Box<
2741 'static,
2742 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2743 >,
2744 >,
2745 _: (),
2746 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2747 if let Some(inner) = this {
2748 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2749 ::fidl_next::wire::Box::encode_present(out);
2750 } else {
2751 ::fidl_next::wire::Box::encode_absent(out);
2752 }
2753
2754 Ok(())
2755 }
2756 }
2757
2758 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportResponse>
2759 for CapabilityStoreDictionaryLegacyExportResponse
2760 {
2761 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2762 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2763 Self,
2764 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2765
2766 #[inline]
2767 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportResponse) -> Self {
2768 Self {}
2769 }
2770 }
2771
2772 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryLegacyExportResponse>
2773 for CapabilityStoreDictionaryLegacyExportResponse
2774 {
2775 #[inline]
2776 fn from_wire_ref(
2777 wire: &crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
2778 ) -> Self {
2779 Self {}
2780 }
2781 }
2782
2783 #[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
2784 pub type DictionaryKey = ::std::string::String;
2785
2786 #[doc = " A key-value pair in a [`DictionaryRef`].\n"]
2787 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2788 pub struct DictionaryItem {
2789 pub key: ::std::string::String,
2790
2791 pub value: u64,
2792 }
2793
2794 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E> for DictionaryItem
2795 where
2796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2797 ___E: ::fidl_next::Encoder,
2798 {
2799 #[inline]
2800 fn encode(
2801 self,
2802 encoder_: &mut ___E,
2803 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryItem<'static>>,
2804 _: (),
2805 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2806 ::fidl_next::munge! {
2807 let crate::wire::DictionaryItem {
2808 key,
2809 value,
2810
2811 } = out_;
2812 }
2813
2814 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
2815
2816 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2817 ::fidl_next::Constrained::validate(_field, 255)?;
2818
2819 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
2820
2821 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2822
2823 Ok(())
2824 }
2825 }
2826
2827 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>
2828 for &'a DictionaryItem
2829 where
2830 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2831 ___E: ::fidl_next::Encoder,
2832 {
2833 #[inline]
2834 fn encode(
2835 self,
2836 encoder_: &mut ___E,
2837 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryItem<'static>>,
2838 _: (),
2839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2840 ::fidl_next::munge! {
2841 let crate::wire::DictionaryItem {
2842
2843 key,
2844 value,
2845
2846 } = out_;
2847 }
2848
2849 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
2850
2851 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2852 ::fidl_next::Constrained::validate(_field, 255)?;
2853
2854 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
2855
2856 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2857
2858 Ok(())
2859 }
2860 }
2861
2862 unsafe impl<___E>
2863 ::fidl_next::EncodeOption<
2864 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
2865 ___E,
2866 > for DictionaryItem
2867 where
2868 ___E: ::fidl_next::Encoder + ?Sized,
2869 DictionaryItem: ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>,
2870 {
2871 #[inline]
2872 fn encode_option(
2873 this: ::core::option::Option<Self>,
2874 encoder: &mut ___E,
2875 out: &mut ::core::mem::MaybeUninit<
2876 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
2877 >,
2878 _: (),
2879 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2880 if let Some(inner) = this {
2881 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2882 ::fidl_next::wire::Box::encode_present(out);
2883 } else {
2884 ::fidl_next::wire::Box::encode_absent(out);
2885 }
2886
2887 Ok(())
2888 }
2889 }
2890
2891 unsafe impl<'a, ___E>
2892 ::fidl_next::EncodeOption<
2893 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
2894 ___E,
2895 > for &'a DictionaryItem
2896 where
2897 ___E: ::fidl_next::Encoder + ?Sized,
2898 &'a DictionaryItem: ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>,
2899 {
2900 #[inline]
2901 fn encode_option(
2902 this: ::core::option::Option<Self>,
2903 encoder: &mut ___E,
2904 out: &mut ::core::mem::MaybeUninit<
2905 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
2906 >,
2907 _: (),
2908 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2909 if let Some(inner) = this {
2910 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2911 ::fidl_next::wire::Box::encode_present(out);
2912 } else {
2913 ::fidl_next::wire::Box::encode_absent(out);
2914 }
2915
2916 Ok(())
2917 }
2918 }
2919
2920 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryItem<'de>> for DictionaryItem {
2921 #[inline]
2922 fn from_wire(wire: crate::wire::DictionaryItem<'de>) -> Self {
2923 Self {
2924 key: ::fidl_next::FromWire::from_wire(wire.key),
2925
2926 value: ::fidl_next::FromWire::from_wire(wire.value),
2927 }
2928 }
2929 }
2930
2931 impl<'de> ::fidl_next::FromWireRef<crate::wire::DictionaryItem<'de>> for DictionaryItem {
2932 #[inline]
2933 fn from_wire_ref(wire: &crate::wire::DictionaryItem<'de>) -> Self {
2934 Self {
2935 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
2936
2937 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
2938 }
2939 }
2940 }
2941
2942 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2943 pub struct CapabilityStoreDictionaryInsertRequest {
2944 pub id: u64,
2945
2946 pub item: crate::natural::DictionaryItem,
2947 }
2948
2949 unsafe impl<___E>
2950 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>
2951 for CapabilityStoreDictionaryInsertRequest
2952 where
2953 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2954 ___E: ::fidl_next::Encoder,
2955 {
2956 #[inline]
2957 fn encode(
2958 self,
2959 encoder_: &mut ___E,
2960 out_: &mut ::core::mem::MaybeUninit<
2961 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
2962 >,
2963 _: (),
2964 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2965 ::fidl_next::munge! {
2966 let crate::wire::CapabilityStoreDictionaryInsertRequest {
2967 id,
2968 item,
2969
2970 } = out_;
2971 }
2972
2973 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2974
2975 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2976
2977 ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
2978
2979 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
2980
2981 Ok(())
2982 }
2983 }
2984
2985 unsafe impl<'a, ___E>
2986 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>
2987 for &'a CapabilityStoreDictionaryInsertRequest
2988 where
2989 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2990 ___E: ::fidl_next::Encoder,
2991 {
2992 #[inline]
2993 fn encode(
2994 self,
2995 encoder_: &mut ___E,
2996 out_: &mut ::core::mem::MaybeUninit<
2997 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
2998 >,
2999 _: (),
3000 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3001 ::fidl_next::munge! {
3002 let crate::wire::CapabilityStoreDictionaryInsertRequest {
3003
3004 id,
3005 item,
3006
3007 } = out_;
3008 }
3009
3010 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
3011
3012 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3013
3014 ::fidl_next::Encode::encode(&self.item, encoder_, item, ())?;
3015
3016 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
3017
3018 Ok(())
3019 }
3020 }
3021
3022 unsafe impl<___E>
3023 ::fidl_next::EncodeOption<
3024 ::fidl_next::wire::Box<
3025 'static,
3026 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
3027 >,
3028 ___E,
3029 > for CapabilityStoreDictionaryInsertRequest
3030 where
3031 ___E: ::fidl_next::Encoder + ?Sized,
3032 CapabilityStoreDictionaryInsertRequest:
3033 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>,
3034 {
3035 #[inline]
3036 fn encode_option(
3037 this: ::core::option::Option<Self>,
3038 encoder: &mut ___E,
3039 out: &mut ::core::mem::MaybeUninit<
3040 ::fidl_next::wire::Box<
3041 'static,
3042 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
3043 >,
3044 >,
3045 _: (),
3046 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3047 if let Some(inner) = this {
3048 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3049 ::fidl_next::wire::Box::encode_present(out);
3050 } else {
3051 ::fidl_next::wire::Box::encode_absent(out);
3052 }
3053
3054 Ok(())
3055 }
3056 }
3057
3058 unsafe impl<'a, ___E>
3059 ::fidl_next::EncodeOption<
3060 ::fidl_next::wire::Box<
3061 'static,
3062 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
3063 >,
3064 ___E,
3065 > for &'a CapabilityStoreDictionaryInsertRequest
3066 where
3067 ___E: ::fidl_next::Encoder + ?Sized,
3068 &'a CapabilityStoreDictionaryInsertRequest:
3069 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>,
3070 {
3071 #[inline]
3072 fn encode_option(
3073 this: ::core::option::Option<Self>,
3074 encoder: &mut ___E,
3075 out: &mut ::core::mem::MaybeUninit<
3076 ::fidl_next::wire::Box<
3077 'static,
3078 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
3079 >,
3080 >,
3081 _: (),
3082 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3083 if let Some(inner) = this {
3084 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3085 ::fidl_next::wire::Box::encode_present(out);
3086 } else {
3087 ::fidl_next::wire::Box::encode_absent(out);
3088 }
3089
3090 Ok(())
3091 }
3092 }
3093
3094 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
3095 for CapabilityStoreDictionaryInsertRequest
3096 {
3097 #[inline]
3098 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
3099 Self {
3100 id: ::fidl_next::FromWire::from_wire(wire.id),
3101
3102 item: ::fidl_next::FromWire::from_wire(wire.item),
3103 }
3104 }
3105 }
3106
3107 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
3108 for CapabilityStoreDictionaryInsertRequest
3109 {
3110 #[inline]
3111 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
3112 Self {
3113 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
3114
3115 item: ::fidl_next::FromWireRef::from_wire_ref(&wire.item),
3116 }
3117 }
3118 }
3119
3120 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3121 #[repr(C)]
3122 pub struct CapabilityStoreDictionaryInsertResponse {}
3123
3124 unsafe impl<___E>
3125 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertResponse, ___E>
3126 for CapabilityStoreDictionaryInsertResponse
3127 where
3128 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3129 {
3130 #[inline]
3131 fn encode(
3132 self,
3133 encoder_: &mut ___E,
3134 out_: &mut ::core::mem::MaybeUninit<
3135 crate::wire::CapabilityStoreDictionaryInsertResponse,
3136 >,
3137 _: (),
3138 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3139 ::fidl_next::munge! {
3140 let crate::wire::CapabilityStoreDictionaryInsertResponse {
3141
3142 _empty,
3143
3144 } = out_;
3145 }
3146
3147 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3148
3149 Ok(())
3150 }
3151 }
3152
3153 unsafe impl<'a, ___E>
3154 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertResponse, ___E>
3155 for &'a CapabilityStoreDictionaryInsertResponse
3156 where
3157 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3158 {
3159 #[inline]
3160 fn encode(
3161 self,
3162 encoder_: &mut ___E,
3163 out_: &mut ::core::mem::MaybeUninit<
3164 crate::wire::CapabilityStoreDictionaryInsertResponse,
3165 >,
3166 _: (),
3167 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3168 ::fidl_next::munge! {
3169 let crate::wire::CapabilityStoreDictionaryInsertResponse {
3170
3171 _empty,
3172
3173
3174 } = out_;
3175 }
3176
3177 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3178
3179 Ok(())
3180 }
3181 }
3182
3183 unsafe impl<___E>
3184 ::fidl_next::EncodeOption<
3185 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryInsertResponse>,
3186 ___E,
3187 > for CapabilityStoreDictionaryInsertResponse
3188 where
3189 ___E: ::fidl_next::Encoder + ?Sized,
3190 CapabilityStoreDictionaryInsertResponse:
3191 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertResponse, ___E>,
3192 {
3193 #[inline]
3194 fn encode_option(
3195 this: ::core::option::Option<Self>,
3196 encoder: &mut ___E,
3197 out: &mut ::core::mem::MaybeUninit<
3198 ::fidl_next::wire::Box<
3199 'static,
3200 crate::wire::CapabilityStoreDictionaryInsertResponse,
3201 >,
3202 >,
3203 _: (),
3204 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3205 if let Some(inner) = this {
3206 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3207 ::fidl_next::wire::Box::encode_present(out);
3208 } else {
3209 ::fidl_next::wire::Box::encode_absent(out);
3210 }
3211
3212 Ok(())
3213 }
3214 }
3215
3216 unsafe impl<'a, ___E>
3217 ::fidl_next::EncodeOption<
3218 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryInsertResponse>,
3219 ___E,
3220 > for &'a CapabilityStoreDictionaryInsertResponse
3221 where
3222 ___E: ::fidl_next::Encoder + ?Sized,
3223 &'a CapabilityStoreDictionaryInsertResponse:
3224 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertResponse, ___E>,
3225 {
3226 #[inline]
3227 fn encode_option(
3228 this: ::core::option::Option<Self>,
3229 encoder: &mut ___E,
3230 out: &mut ::core::mem::MaybeUninit<
3231 ::fidl_next::wire::Box<
3232 'static,
3233 crate::wire::CapabilityStoreDictionaryInsertResponse,
3234 >,
3235 >,
3236 _: (),
3237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3238 if let Some(inner) = this {
3239 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3240 ::fidl_next::wire::Box::encode_present(out);
3241 } else {
3242 ::fidl_next::wire::Box::encode_absent(out);
3243 }
3244
3245 Ok(())
3246 }
3247 }
3248
3249 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertResponse>
3250 for CapabilityStoreDictionaryInsertResponse
3251 {
3252 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3253 crate::wire::CapabilityStoreDictionaryInsertResponse,
3254 Self,
3255 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3256
3257 #[inline]
3258 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertResponse) -> Self {
3259 Self {}
3260 }
3261 }
3262
3263 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertResponse>
3264 for CapabilityStoreDictionaryInsertResponse
3265 {
3266 #[inline]
3267 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertResponse) -> Self {
3268 Self {}
3269 }
3270 }
3271
3272 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3273 pub struct CapabilityStoreDictionaryGetRequest {
3274 pub id: u64,
3275
3276 pub key: ::std::string::String,
3277
3278 pub dest_id: u64,
3279 }
3280
3281 unsafe impl<___E>
3282 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>
3283 for CapabilityStoreDictionaryGetRequest
3284 where
3285 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3286 ___E: ::fidl_next::Encoder,
3287 {
3288 #[inline]
3289 fn encode(
3290 self,
3291 encoder_: &mut ___E,
3292 out_: &mut ::core::mem::MaybeUninit<
3293 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3294 >,
3295 _: (),
3296 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3297 ::fidl_next::munge! {
3298 let crate::wire::CapabilityStoreDictionaryGetRequest {
3299 id,
3300 key,
3301 dest_id,
3302
3303 } = out_;
3304 }
3305
3306 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3307
3308 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3309
3310 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
3311
3312 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3313 ::fidl_next::Constrained::validate(_field, 255)?;
3314
3315 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
3316
3317 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3318
3319 Ok(())
3320 }
3321 }
3322
3323 unsafe impl<'a, ___E>
3324 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>
3325 for &'a CapabilityStoreDictionaryGetRequest
3326 where
3327 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3328 ___E: ::fidl_next::Encoder,
3329 {
3330 #[inline]
3331 fn encode(
3332 self,
3333 encoder_: &mut ___E,
3334 out_: &mut ::core::mem::MaybeUninit<
3335 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3336 >,
3337 _: (),
3338 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3339 ::fidl_next::munge! {
3340 let crate::wire::CapabilityStoreDictionaryGetRequest {
3341
3342 id,
3343 key,
3344 dest_id,
3345
3346 } = out_;
3347 }
3348
3349 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
3350
3351 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3352
3353 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
3354
3355 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3356 ::fidl_next::Constrained::validate(_field, 255)?;
3357
3358 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
3359
3360 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3361
3362 Ok(())
3363 }
3364 }
3365
3366 unsafe impl<___E>
3367 ::fidl_next::EncodeOption<
3368 ::fidl_next::wire::Box<
3369 'static,
3370 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3371 >,
3372 ___E,
3373 > for CapabilityStoreDictionaryGetRequest
3374 where
3375 ___E: ::fidl_next::Encoder + ?Sized,
3376 CapabilityStoreDictionaryGetRequest:
3377 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>,
3378 {
3379 #[inline]
3380 fn encode_option(
3381 this: ::core::option::Option<Self>,
3382 encoder: &mut ___E,
3383 out: &mut ::core::mem::MaybeUninit<
3384 ::fidl_next::wire::Box<
3385 'static,
3386 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3387 >,
3388 >,
3389 _: (),
3390 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3391 if let Some(inner) = this {
3392 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3393 ::fidl_next::wire::Box::encode_present(out);
3394 } else {
3395 ::fidl_next::wire::Box::encode_absent(out);
3396 }
3397
3398 Ok(())
3399 }
3400 }
3401
3402 unsafe impl<'a, ___E>
3403 ::fidl_next::EncodeOption<
3404 ::fidl_next::wire::Box<
3405 'static,
3406 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3407 >,
3408 ___E,
3409 > for &'a CapabilityStoreDictionaryGetRequest
3410 where
3411 ___E: ::fidl_next::Encoder + ?Sized,
3412 &'a CapabilityStoreDictionaryGetRequest:
3413 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>,
3414 {
3415 #[inline]
3416 fn encode_option(
3417 this: ::core::option::Option<Self>,
3418 encoder: &mut ___E,
3419 out: &mut ::core::mem::MaybeUninit<
3420 ::fidl_next::wire::Box<
3421 'static,
3422 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3423 >,
3424 >,
3425 _: (),
3426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3427 if let Some(inner) = this {
3428 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3429 ::fidl_next::wire::Box::encode_present(out);
3430 } else {
3431 ::fidl_next::wire::Box::encode_absent(out);
3432 }
3433
3434 Ok(())
3435 }
3436 }
3437
3438 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
3439 for CapabilityStoreDictionaryGetRequest
3440 {
3441 #[inline]
3442 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
3443 Self {
3444 id: ::fidl_next::FromWire::from_wire(wire.id),
3445
3446 key: ::fidl_next::FromWire::from_wire(wire.key),
3447
3448 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
3449 }
3450 }
3451 }
3452
3453 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
3454 for CapabilityStoreDictionaryGetRequest
3455 {
3456 #[inline]
3457 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
3458 Self {
3459 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
3460
3461 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
3462
3463 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
3464 }
3465 }
3466 }
3467
3468 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3469 #[repr(C)]
3470 pub struct CapabilityStoreDictionaryGetResponse {}
3471
3472 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetResponse, ___E>
3473 for CapabilityStoreDictionaryGetResponse
3474 where
3475 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3476 {
3477 #[inline]
3478 fn encode(
3479 self,
3480 encoder_: &mut ___E,
3481 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryGetResponse>,
3482 _: (),
3483 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3484 ::fidl_next::munge! {
3485 let crate::wire::CapabilityStoreDictionaryGetResponse {
3486
3487 _empty,
3488
3489 } = out_;
3490 }
3491
3492 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3493
3494 Ok(())
3495 }
3496 }
3497
3498 unsafe impl<'a, ___E>
3499 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetResponse, ___E>
3500 for &'a CapabilityStoreDictionaryGetResponse
3501 where
3502 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3503 {
3504 #[inline]
3505 fn encode(
3506 self,
3507 encoder_: &mut ___E,
3508 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryGetResponse>,
3509 _: (),
3510 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3511 ::fidl_next::munge! {
3512 let crate::wire::CapabilityStoreDictionaryGetResponse {
3513
3514 _empty,
3515
3516
3517 } = out_;
3518 }
3519
3520 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3521
3522 Ok(())
3523 }
3524 }
3525
3526 unsafe impl<___E>
3527 ::fidl_next::EncodeOption<
3528 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryGetResponse>,
3529 ___E,
3530 > for CapabilityStoreDictionaryGetResponse
3531 where
3532 ___E: ::fidl_next::Encoder + ?Sized,
3533 CapabilityStoreDictionaryGetResponse:
3534 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetResponse, ___E>,
3535 {
3536 #[inline]
3537 fn encode_option(
3538 this: ::core::option::Option<Self>,
3539 encoder: &mut ___E,
3540 out: &mut ::core::mem::MaybeUninit<
3541 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryGetResponse>,
3542 >,
3543 _: (),
3544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3545 if let Some(inner) = this {
3546 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3547 ::fidl_next::wire::Box::encode_present(out);
3548 } else {
3549 ::fidl_next::wire::Box::encode_absent(out);
3550 }
3551
3552 Ok(())
3553 }
3554 }
3555
3556 unsafe impl<'a, ___E>
3557 ::fidl_next::EncodeOption<
3558 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryGetResponse>,
3559 ___E,
3560 > for &'a CapabilityStoreDictionaryGetResponse
3561 where
3562 ___E: ::fidl_next::Encoder + ?Sized,
3563 &'a CapabilityStoreDictionaryGetResponse:
3564 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetResponse, ___E>,
3565 {
3566 #[inline]
3567 fn encode_option(
3568 this: ::core::option::Option<Self>,
3569 encoder: &mut ___E,
3570 out: &mut ::core::mem::MaybeUninit<
3571 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryGetResponse>,
3572 >,
3573 _: (),
3574 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3575 if let Some(inner) = this {
3576 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3577 ::fidl_next::wire::Box::encode_present(out);
3578 } else {
3579 ::fidl_next::wire::Box::encode_absent(out);
3580 }
3581
3582 Ok(())
3583 }
3584 }
3585
3586 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetResponse>
3587 for CapabilityStoreDictionaryGetResponse
3588 {
3589 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3590 crate::wire::CapabilityStoreDictionaryGetResponse,
3591 Self,
3592 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3593
3594 #[inline]
3595 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetResponse) -> Self {
3596 Self {}
3597 }
3598 }
3599
3600 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetResponse>
3601 for CapabilityStoreDictionaryGetResponse
3602 {
3603 #[inline]
3604 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetResponse) -> Self {
3605 Self {}
3606 }
3607 }
3608
3609 #[doc = " A [CapabilityId] wrapped in a struct. This is useful for putting a [CapabilityId] in a `box<>`,\n which FIDL does not allow for pure integral types.\n"]
3610 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3611 #[repr(C)]
3612 pub struct WrappedCapabilityId {
3613 pub id: u64,
3614 }
3615
3616 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>
3617 for WrappedCapabilityId
3618 where
3619 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3620 {
3621 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3622 Self,
3623 crate::wire::WrappedCapabilityId,
3624 > = unsafe {
3625 ::fidl_next::CopyOptimization::enable_if(
3626 true
3627
3628 && <
3629 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
3630 >::COPY_OPTIMIZATION.is_enabled()
3631
3632 )
3633 };
3634
3635 #[inline]
3636 fn encode(
3637 self,
3638 encoder_: &mut ___E,
3639 out_: &mut ::core::mem::MaybeUninit<crate::wire::WrappedCapabilityId>,
3640 _: (),
3641 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3642 ::fidl_next::munge! {
3643 let crate::wire::WrappedCapabilityId {
3644 id,
3645
3646 } = out_;
3647 }
3648
3649 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3650
3651 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3652
3653 Ok(())
3654 }
3655 }
3656
3657 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>
3658 for &'a WrappedCapabilityId
3659 where
3660 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3661 {
3662 #[inline]
3663 fn encode(
3664 self,
3665 encoder_: &mut ___E,
3666 out_: &mut ::core::mem::MaybeUninit<crate::wire::WrappedCapabilityId>,
3667 _: (),
3668 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3669 ::fidl_next::munge! {
3670 let crate::wire::WrappedCapabilityId {
3671
3672 id,
3673
3674 } = out_;
3675 }
3676
3677 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
3678
3679 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3680
3681 Ok(())
3682 }
3683 }
3684
3685 unsafe impl<___E>
3686 ::fidl_next::EncodeOption<
3687 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
3688 ___E,
3689 > for WrappedCapabilityId
3690 where
3691 ___E: ::fidl_next::Encoder + ?Sized,
3692 WrappedCapabilityId: ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>,
3693 {
3694 #[inline]
3695 fn encode_option(
3696 this: ::core::option::Option<Self>,
3697 encoder: &mut ___E,
3698 out: &mut ::core::mem::MaybeUninit<
3699 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
3700 >,
3701 _: (),
3702 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3703 if let Some(inner) = this {
3704 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3705 ::fidl_next::wire::Box::encode_present(out);
3706 } else {
3707 ::fidl_next::wire::Box::encode_absent(out);
3708 }
3709
3710 Ok(())
3711 }
3712 }
3713
3714 unsafe impl<'a, ___E>
3715 ::fidl_next::EncodeOption<
3716 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
3717 ___E,
3718 > for &'a WrappedCapabilityId
3719 where
3720 ___E: ::fidl_next::Encoder + ?Sized,
3721 &'a WrappedCapabilityId: ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>,
3722 {
3723 #[inline]
3724 fn encode_option(
3725 this: ::core::option::Option<Self>,
3726 encoder: &mut ___E,
3727 out: &mut ::core::mem::MaybeUninit<
3728 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
3729 >,
3730 _: (),
3731 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3732 if let Some(inner) = this {
3733 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3734 ::fidl_next::wire::Box::encode_present(out);
3735 } else {
3736 ::fidl_next::wire::Box::encode_absent(out);
3737 }
3738
3739 Ok(())
3740 }
3741 }
3742
3743 impl ::fidl_next::FromWire<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
3744 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3745 crate::wire::WrappedCapabilityId,
3746 Self,
3747 > = unsafe {
3748 ::fidl_next::CopyOptimization::enable_if(
3749 true
3750 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
3751 .is_enabled(),
3752 )
3753 };
3754
3755 #[inline]
3756 fn from_wire(wire: crate::wire::WrappedCapabilityId) -> Self {
3757 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
3758 }
3759 }
3760
3761 impl ::fidl_next::FromWireRef<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
3762 #[inline]
3763 fn from_wire_ref(wire: &crate::wire::WrappedCapabilityId) -> Self {
3764 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
3765 }
3766 }
3767
3768 pub type WrappedNewCapabilityId = crate::natural::WrappedCapabilityId;
3769
3770 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3771 pub struct CapabilityStoreDictionaryRemoveRequest {
3772 pub id: u64,
3773
3774 pub key: ::std::string::String,
3775
3776 pub dest_id: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
3777 }
3778
3779 unsafe impl<___E>
3780 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>
3781 for CapabilityStoreDictionaryRemoveRequest
3782 where
3783 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3784 ___E: ::fidl_next::Encoder,
3785 {
3786 #[inline]
3787 fn encode(
3788 self,
3789 encoder_: &mut ___E,
3790 out_: &mut ::core::mem::MaybeUninit<
3791 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
3792 >,
3793 _: (),
3794 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3795 ::fidl_next::munge! {
3796 let crate::wire::CapabilityStoreDictionaryRemoveRequest {
3797 id,
3798 key,
3799 dest_id,
3800
3801 } = out_;
3802 }
3803
3804 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3805
3806 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3807
3808 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
3809
3810 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3811 ::fidl_next::Constrained::validate(_field, 255)?;
3812
3813 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
3814
3815 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3816
3817 Ok(())
3818 }
3819 }
3820
3821 unsafe impl<'a, ___E>
3822 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>
3823 for &'a CapabilityStoreDictionaryRemoveRequest
3824 where
3825 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3826 ___E: ::fidl_next::Encoder,
3827 {
3828 #[inline]
3829 fn encode(
3830 self,
3831 encoder_: &mut ___E,
3832 out_: &mut ::core::mem::MaybeUninit<
3833 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
3834 >,
3835 _: (),
3836 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3837 ::fidl_next::munge! {
3838 let crate::wire::CapabilityStoreDictionaryRemoveRequest {
3839
3840 id,
3841 key,
3842 dest_id,
3843
3844 } = out_;
3845 }
3846
3847 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
3848
3849 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3850
3851 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
3852
3853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3854 ::fidl_next::Constrained::validate(_field, 255)?;
3855
3856 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
3857
3858 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3859
3860 Ok(())
3861 }
3862 }
3863
3864 unsafe impl<___E>
3865 ::fidl_next::EncodeOption<
3866 ::fidl_next::wire::Box<
3867 'static,
3868 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
3869 >,
3870 ___E,
3871 > for CapabilityStoreDictionaryRemoveRequest
3872 where
3873 ___E: ::fidl_next::Encoder + ?Sized,
3874 CapabilityStoreDictionaryRemoveRequest:
3875 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>,
3876 {
3877 #[inline]
3878 fn encode_option(
3879 this: ::core::option::Option<Self>,
3880 encoder: &mut ___E,
3881 out: &mut ::core::mem::MaybeUninit<
3882 ::fidl_next::wire::Box<
3883 'static,
3884 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
3885 >,
3886 >,
3887 _: (),
3888 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3889 if let Some(inner) = this {
3890 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3891 ::fidl_next::wire::Box::encode_present(out);
3892 } else {
3893 ::fidl_next::wire::Box::encode_absent(out);
3894 }
3895
3896 Ok(())
3897 }
3898 }
3899
3900 unsafe impl<'a, ___E>
3901 ::fidl_next::EncodeOption<
3902 ::fidl_next::wire::Box<
3903 'static,
3904 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
3905 >,
3906 ___E,
3907 > for &'a CapabilityStoreDictionaryRemoveRequest
3908 where
3909 ___E: ::fidl_next::Encoder + ?Sized,
3910 &'a CapabilityStoreDictionaryRemoveRequest:
3911 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>,
3912 {
3913 #[inline]
3914 fn encode_option(
3915 this: ::core::option::Option<Self>,
3916 encoder: &mut ___E,
3917 out: &mut ::core::mem::MaybeUninit<
3918 ::fidl_next::wire::Box<
3919 'static,
3920 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
3921 >,
3922 >,
3923 _: (),
3924 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3925 if let Some(inner) = this {
3926 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3927 ::fidl_next::wire::Box::encode_present(out);
3928 } else {
3929 ::fidl_next::wire::Box::encode_absent(out);
3930 }
3931
3932 Ok(())
3933 }
3934 }
3935
3936 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
3937 for CapabilityStoreDictionaryRemoveRequest
3938 {
3939 #[inline]
3940 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
3941 Self {
3942 id: ::fidl_next::FromWire::from_wire(wire.id),
3943
3944 key: ::fidl_next::FromWire::from_wire(wire.key),
3945
3946 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
3947 }
3948 }
3949 }
3950
3951 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
3952 for CapabilityStoreDictionaryRemoveRequest
3953 {
3954 #[inline]
3955 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
3956 Self {
3957 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
3958
3959 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
3960
3961 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
3962 }
3963 }
3964 }
3965
3966 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3967 #[repr(C)]
3968 pub struct CapabilityStoreDictionaryRemoveResponse {}
3969
3970 unsafe impl<___E>
3971 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveResponse, ___E>
3972 for CapabilityStoreDictionaryRemoveResponse
3973 where
3974 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3975 {
3976 #[inline]
3977 fn encode(
3978 self,
3979 encoder_: &mut ___E,
3980 out_: &mut ::core::mem::MaybeUninit<
3981 crate::wire::CapabilityStoreDictionaryRemoveResponse,
3982 >,
3983 _: (),
3984 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3985 ::fidl_next::munge! {
3986 let crate::wire::CapabilityStoreDictionaryRemoveResponse {
3987
3988 _empty,
3989
3990 } = out_;
3991 }
3992
3993 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
3994
3995 Ok(())
3996 }
3997 }
3998
3999 unsafe impl<'a, ___E>
4000 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveResponse, ___E>
4001 for &'a CapabilityStoreDictionaryRemoveResponse
4002 where
4003 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4004 {
4005 #[inline]
4006 fn encode(
4007 self,
4008 encoder_: &mut ___E,
4009 out_: &mut ::core::mem::MaybeUninit<
4010 crate::wire::CapabilityStoreDictionaryRemoveResponse,
4011 >,
4012 _: (),
4013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4014 ::fidl_next::munge! {
4015 let crate::wire::CapabilityStoreDictionaryRemoveResponse {
4016
4017 _empty,
4018
4019
4020 } = out_;
4021 }
4022
4023 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4024
4025 Ok(())
4026 }
4027 }
4028
4029 unsafe impl<___E>
4030 ::fidl_next::EncodeOption<
4031 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryRemoveResponse>,
4032 ___E,
4033 > for CapabilityStoreDictionaryRemoveResponse
4034 where
4035 ___E: ::fidl_next::Encoder + ?Sized,
4036 CapabilityStoreDictionaryRemoveResponse:
4037 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveResponse, ___E>,
4038 {
4039 #[inline]
4040 fn encode_option(
4041 this: ::core::option::Option<Self>,
4042 encoder: &mut ___E,
4043 out: &mut ::core::mem::MaybeUninit<
4044 ::fidl_next::wire::Box<
4045 'static,
4046 crate::wire::CapabilityStoreDictionaryRemoveResponse,
4047 >,
4048 >,
4049 _: (),
4050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4051 if let Some(inner) = this {
4052 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4053 ::fidl_next::wire::Box::encode_present(out);
4054 } else {
4055 ::fidl_next::wire::Box::encode_absent(out);
4056 }
4057
4058 Ok(())
4059 }
4060 }
4061
4062 unsafe impl<'a, ___E>
4063 ::fidl_next::EncodeOption<
4064 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryRemoveResponse>,
4065 ___E,
4066 > for &'a CapabilityStoreDictionaryRemoveResponse
4067 where
4068 ___E: ::fidl_next::Encoder + ?Sized,
4069 &'a CapabilityStoreDictionaryRemoveResponse:
4070 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveResponse, ___E>,
4071 {
4072 #[inline]
4073 fn encode_option(
4074 this: ::core::option::Option<Self>,
4075 encoder: &mut ___E,
4076 out: &mut ::core::mem::MaybeUninit<
4077 ::fidl_next::wire::Box<
4078 'static,
4079 crate::wire::CapabilityStoreDictionaryRemoveResponse,
4080 >,
4081 >,
4082 _: (),
4083 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4084 if let Some(inner) = this {
4085 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4086 ::fidl_next::wire::Box::encode_present(out);
4087 } else {
4088 ::fidl_next::wire::Box::encode_absent(out);
4089 }
4090
4091 Ok(())
4092 }
4093 }
4094
4095 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveResponse>
4096 for CapabilityStoreDictionaryRemoveResponse
4097 {
4098 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4099 crate::wire::CapabilityStoreDictionaryRemoveResponse,
4100 Self,
4101 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4102
4103 #[inline]
4104 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveResponse) -> Self {
4105 Self {}
4106 }
4107 }
4108
4109 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveResponse>
4110 for CapabilityStoreDictionaryRemoveResponse
4111 {
4112 #[inline]
4113 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveResponse) -> Self {
4114 Self {}
4115 }
4116 }
4117
4118 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4119 #[repr(C)]
4120 pub struct CapabilityStoreDictionaryCopyRequest {
4121 pub id: u64,
4122
4123 pub dest_id: u64,
4124 }
4125
4126 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>
4127 for CapabilityStoreDictionaryCopyRequest
4128 where
4129 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4130 {
4131 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4132 Self,
4133 crate::wire::CapabilityStoreDictionaryCopyRequest,
4134 > = unsafe {
4135 ::fidl_next::CopyOptimization::enable_if(
4136 true
4137
4138 && <
4139 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
4140 >::COPY_OPTIMIZATION.is_enabled()
4141
4142 && <
4143 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
4144 >::COPY_OPTIMIZATION.is_enabled()
4145
4146 )
4147 };
4148
4149 #[inline]
4150 fn encode(
4151 self,
4152 encoder_: &mut ___E,
4153 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyRequest>,
4154 _: (),
4155 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4156 ::fidl_next::munge! {
4157 let crate::wire::CapabilityStoreDictionaryCopyRequest {
4158 id,
4159 dest_id,
4160
4161 } = out_;
4162 }
4163
4164 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4165
4166 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4167
4168 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4169
4170 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4171
4172 Ok(())
4173 }
4174 }
4175
4176 unsafe impl<'a, ___E>
4177 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>
4178 for &'a CapabilityStoreDictionaryCopyRequest
4179 where
4180 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4181 {
4182 #[inline]
4183 fn encode(
4184 self,
4185 encoder_: &mut ___E,
4186 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyRequest>,
4187 _: (),
4188 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4189 ::fidl_next::munge! {
4190 let crate::wire::CapabilityStoreDictionaryCopyRequest {
4191
4192 id,
4193 dest_id,
4194
4195 } = out_;
4196 }
4197
4198 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
4199
4200 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4201
4202 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
4203
4204 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4205
4206 Ok(())
4207 }
4208 }
4209
4210 unsafe impl<___E>
4211 ::fidl_next::EncodeOption<
4212 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
4213 ___E,
4214 > for CapabilityStoreDictionaryCopyRequest
4215 where
4216 ___E: ::fidl_next::Encoder + ?Sized,
4217 CapabilityStoreDictionaryCopyRequest:
4218 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>,
4219 {
4220 #[inline]
4221 fn encode_option(
4222 this: ::core::option::Option<Self>,
4223 encoder: &mut ___E,
4224 out: &mut ::core::mem::MaybeUninit<
4225 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
4226 >,
4227 _: (),
4228 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4229 if let Some(inner) = this {
4230 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4231 ::fidl_next::wire::Box::encode_present(out);
4232 } else {
4233 ::fidl_next::wire::Box::encode_absent(out);
4234 }
4235
4236 Ok(())
4237 }
4238 }
4239
4240 unsafe impl<'a, ___E>
4241 ::fidl_next::EncodeOption<
4242 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
4243 ___E,
4244 > for &'a CapabilityStoreDictionaryCopyRequest
4245 where
4246 ___E: ::fidl_next::Encoder + ?Sized,
4247 &'a CapabilityStoreDictionaryCopyRequest:
4248 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>,
4249 {
4250 #[inline]
4251 fn encode_option(
4252 this: ::core::option::Option<Self>,
4253 encoder: &mut ___E,
4254 out: &mut ::core::mem::MaybeUninit<
4255 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
4256 >,
4257 _: (),
4258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4259 if let Some(inner) = this {
4260 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4261 ::fidl_next::wire::Box::encode_present(out);
4262 } else {
4263 ::fidl_next::wire::Box::encode_absent(out);
4264 }
4265
4266 Ok(())
4267 }
4268 }
4269
4270 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyRequest>
4271 for CapabilityStoreDictionaryCopyRequest
4272 {
4273 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4274 crate::wire::CapabilityStoreDictionaryCopyRequest,
4275 Self,
4276 > = unsafe {
4277 ::fidl_next::CopyOptimization::enable_if(
4278 true
4279 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
4280 .is_enabled()
4281 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
4282 .is_enabled(),
4283 )
4284 };
4285
4286 #[inline]
4287 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
4288 Self {
4289 id: ::fidl_next::FromWire::from_wire(wire.id),
4290
4291 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4292 }
4293 }
4294 }
4295
4296 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyRequest>
4297 for CapabilityStoreDictionaryCopyRequest
4298 {
4299 #[inline]
4300 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
4301 Self {
4302 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4303
4304 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4305 }
4306 }
4307 }
4308
4309 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4310 #[repr(C)]
4311 pub struct CapabilityStoreDictionaryCopyResponse {}
4312
4313 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyResponse, ___E>
4314 for CapabilityStoreDictionaryCopyResponse
4315 where
4316 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4317 {
4318 #[inline]
4319 fn encode(
4320 self,
4321 encoder_: &mut ___E,
4322 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyResponse>,
4323 _: (),
4324 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4325 ::fidl_next::munge! {
4326 let crate::wire::CapabilityStoreDictionaryCopyResponse {
4327
4328 _empty,
4329
4330 } = out_;
4331 }
4332
4333 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4334
4335 Ok(())
4336 }
4337 }
4338
4339 unsafe impl<'a, ___E>
4340 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyResponse, ___E>
4341 for &'a CapabilityStoreDictionaryCopyResponse
4342 where
4343 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4344 {
4345 #[inline]
4346 fn encode(
4347 self,
4348 encoder_: &mut ___E,
4349 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyResponse>,
4350 _: (),
4351 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4352 ::fidl_next::munge! {
4353 let crate::wire::CapabilityStoreDictionaryCopyResponse {
4354
4355 _empty,
4356
4357
4358 } = out_;
4359 }
4360
4361 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4362
4363 Ok(())
4364 }
4365 }
4366
4367 unsafe impl<___E>
4368 ::fidl_next::EncodeOption<
4369 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyResponse>,
4370 ___E,
4371 > for CapabilityStoreDictionaryCopyResponse
4372 where
4373 ___E: ::fidl_next::Encoder + ?Sized,
4374 CapabilityStoreDictionaryCopyResponse:
4375 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyResponse, ___E>,
4376 {
4377 #[inline]
4378 fn encode_option(
4379 this: ::core::option::Option<Self>,
4380 encoder: &mut ___E,
4381 out: &mut ::core::mem::MaybeUninit<
4382 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyResponse>,
4383 >,
4384 _: (),
4385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4386 if let Some(inner) = this {
4387 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4388 ::fidl_next::wire::Box::encode_present(out);
4389 } else {
4390 ::fidl_next::wire::Box::encode_absent(out);
4391 }
4392
4393 Ok(())
4394 }
4395 }
4396
4397 unsafe impl<'a, ___E>
4398 ::fidl_next::EncodeOption<
4399 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyResponse>,
4400 ___E,
4401 > for &'a CapabilityStoreDictionaryCopyResponse
4402 where
4403 ___E: ::fidl_next::Encoder + ?Sized,
4404 &'a CapabilityStoreDictionaryCopyResponse:
4405 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyResponse, ___E>,
4406 {
4407 #[inline]
4408 fn encode_option(
4409 this: ::core::option::Option<Self>,
4410 encoder: &mut ___E,
4411 out: &mut ::core::mem::MaybeUninit<
4412 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyResponse>,
4413 >,
4414 _: (),
4415 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4416 if let Some(inner) = this {
4417 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4418 ::fidl_next::wire::Box::encode_present(out);
4419 } else {
4420 ::fidl_next::wire::Box::encode_absent(out);
4421 }
4422
4423 Ok(())
4424 }
4425 }
4426
4427 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyResponse>
4428 for CapabilityStoreDictionaryCopyResponse
4429 {
4430 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4431 crate::wire::CapabilityStoreDictionaryCopyResponse,
4432 Self,
4433 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4434
4435 #[inline]
4436 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyResponse) -> Self {
4437 Self {}
4438 }
4439 }
4440
4441 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyResponse>
4442 for CapabilityStoreDictionaryCopyResponse
4443 {
4444 #[inline]
4445 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyResponse) -> Self {
4446 Self {}
4447 }
4448 }
4449
4450 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4451 #[repr(C)]
4452 pub struct CapabilityStoreDictionaryKeysResponse {}
4453
4454 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysResponse, ___E>
4455 for CapabilityStoreDictionaryKeysResponse
4456 where
4457 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4458 {
4459 #[inline]
4460 fn encode(
4461 self,
4462 encoder_: &mut ___E,
4463 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysResponse>,
4464 _: (),
4465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4466 ::fidl_next::munge! {
4467 let crate::wire::CapabilityStoreDictionaryKeysResponse {
4468
4469 _empty,
4470
4471 } = out_;
4472 }
4473
4474 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4475
4476 Ok(())
4477 }
4478 }
4479
4480 unsafe impl<'a, ___E>
4481 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysResponse, ___E>
4482 for &'a CapabilityStoreDictionaryKeysResponse
4483 where
4484 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4485 {
4486 #[inline]
4487 fn encode(
4488 self,
4489 encoder_: &mut ___E,
4490 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysResponse>,
4491 _: (),
4492 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4493 ::fidl_next::munge! {
4494 let crate::wire::CapabilityStoreDictionaryKeysResponse {
4495
4496 _empty,
4497
4498
4499 } = out_;
4500 }
4501
4502 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4503
4504 Ok(())
4505 }
4506 }
4507
4508 unsafe impl<___E>
4509 ::fidl_next::EncodeOption<
4510 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryKeysResponse>,
4511 ___E,
4512 > for CapabilityStoreDictionaryKeysResponse
4513 where
4514 ___E: ::fidl_next::Encoder + ?Sized,
4515 CapabilityStoreDictionaryKeysResponse:
4516 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysResponse, ___E>,
4517 {
4518 #[inline]
4519 fn encode_option(
4520 this: ::core::option::Option<Self>,
4521 encoder: &mut ___E,
4522 out: &mut ::core::mem::MaybeUninit<
4523 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryKeysResponse>,
4524 >,
4525 _: (),
4526 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4527 if let Some(inner) = this {
4528 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4529 ::fidl_next::wire::Box::encode_present(out);
4530 } else {
4531 ::fidl_next::wire::Box::encode_absent(out);
4532 }
4533
4534 Ok(())
4535 }
4536 }
4537
4538 unsafe impl<'a, ___E>
4539 ::fidl_next::EncodeOption<
4540 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryKeysResponse>,
4541 ___E,
4542 > for &'a CapabilityStoreDictionaryKeysResponse
4543 where
4544 ___E: ::fidl_next::Encoder + ?Sized,
4545 &'a CapabilityStoreDictionaryKeysResponse:
4546 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysResponse, ___E>,
4547 {
4548 #[inline]
4549 fn encode_option(
4550 this: ::core::option::Option<Self>,
4551 encoder: &mut ___E,
4552 out: &mut ::core::mem::MaybeUninit<
4553 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryKeysResponse>,
4554 >,
4555 _: (),
4556 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4557 if let Some(inner) = this {
4558 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4559 ::fidl_next::wire::Box::encode_present(out);
4560 } else {
4561 ::fidl_next::wire::Box::encode_absent(out);
4562 }
4563
4564 Ok(())
4565 }
4566 }
4567
4568 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysResponse>
4569 for CapabilityStoreDictionaryKeysResponse
4570 {
4571 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4572 crate::wire::CapabilityStoreDictionaryKeysResponse,
4573 Self,
4574 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4575
4576 #[inline]
4577 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysResponse) -> Self {
4578 Self {}
4579 }
4580 }
4581
4582 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryKeysResponse>
4583 for CapabilityStoreDictionaryKeysResponse
4584 {
4585 #[inline]
4586 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryKeysResponse) -> Self {
4587 Self {}
4588 }
4589 }
4590
4591 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4592 #[repr(C)]
4593 pub struct CapabilityStoreDictionaryEnumerateResponse {}
4594
4595 unsafe impl<___E>
4596 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateResponse, ___E>
4597 for CapabilityStoreDictionaryEnumerateResponse
4598 where
4599 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4600 {
4601 #[inline]
4602 fn encode(
4603 self,
4604 encoder_: &mut ___E,
4605 out_: &mut ::core::mem::MaybeUninit<
4606 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4607 >,
4608 _: (),
4609 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4610 ::fidl_next::munge! {
4611 let crate::wire::CapabilityStoreDictionaryEnumerateResponse {
4612
4613 _empty,
4614
4615 } = out_;
4616 }
4617
4618 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4619
4620 Ok(())
4621 }
4622 }
4623
4624 unsafe impl<'a, ___E>
4625 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateResponse, ___E>
4626 for &'a CapabilityStoreDictionaryEnumerateResponse
4627 where
4628 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4629 {
4630 #[inline]
4631 fn encode(
4632 self,
4633 encoder_: &mut ___E,
4634 out_: &mut ::core::mem::MaybeUninit<
4635 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4636 >,
4637 _: (),
4638 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4639 ::fidl_next::munge! {
4640 let crate::wire::CapabilityStoreDictionaryEnumerateResponse {
4641
4642 _empty,
4643
4644
4645 } = out_;
4646 }
4647
4648 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4649
4650 Ok(())
4651 }
4652 }
4653
4654 unsafe impl<___E>
4655 ::fidl_next::EncodeOption<
4656 ::fidl_next::wire::Box<
4657 'static,
4658 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4659 >,
4660 ___E,
4661 > for CapabilityStoreDictionaryEnumerateResponse
4662 where
4663 ___E: ::fidl_next::Encoder + ?Sized,
4664 CapabilityStoreDictionaryEnumerateResponse:
4665 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateResponse, ___E>,
4666 {
4667 #[inline]
4668 fn encode_option(
4669 this: ::core::option::Option<Self>,
4670 encoder: &mut ___E,
4671 out: &mut ::core::mem::MaybeUninit<
4672 ::fidl_next::wire::Box<
4673 'static,
4674 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4675 >,
4676 >,
4677 _: (),
4678 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4679 if let Some(inner) = this {
4680 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4681 ::fidl_next::wire::Box::encode_present(out);
4682 } else {
4683 ::fidl_next::wire::Box::encode_absent(out);
4684 }
4685
4686 Ok(())
4687 }
4688 }
4689
4690 unsafe impl<'a, ___E>
4691 ::fidl_next::EncodeOption<
4692 ::fidl_next::wire::Box<
4693 'static,
4694 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4695 >,
4696 ___E,
4697 > for &'a CapabilityStoreDictionaryEnumerateResponse
4698 where
4699 ___E: ::fidl_next::Encoder + ?Sized,
4700 &'a CapabilityStoreDictionaryEnumerateResponse:
4701 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateResponse, ___E>,
4702 {
4703 #[inline]
4704 fn encode_option(
4705 this: ::core::option::Option<Self>,
4706 encoder: &mut ___E,
4707 out: &mut ::core::mem::MaybeUninit<
4708 ::fidl_next::wire::Box<
4709 'static,
4710 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4711 >,
4712 >,
4713 _: (),
4714 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4715 if let Some(inner) = this {
4716 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4717 ::fidl_next::wire::Box::encode_present(out);
4718 } else {
4719 ::fidl_next::wire::Box::encode_absent(out);
4720 }
4721
4722 Ok(())
4723 }
4724 }
4725
4726 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateResponse>
4727 for CapabilityStoreDictionaryEnumerateResponse
4728 {
4729 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4730 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
4731 Self,
4732 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4733
4734 #[inline]
4735 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateResponse) -> Self {
4736 Self {}
4737 }
4738 }
4739
4740 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryEnumerateResponse>
4741 for CapabilityStoreDictionaryEnumerateResponse
4742 {
4743 #[inline]
4744 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryEnumerateResponse) -> Self {
4745 Self {}
4746 }
4747 }
4748
4749 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4750 #[repr(C)]
4751 pub struct CapabilityStoreDictionaryDrainResponse {}
4752
4753 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainResponse, ___E>
4754 for CapabilityStoreDictionaryDrainResponse
4755 where
4756 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4757 {
4758 #[inline]
4759 fn encode(
4760 self,
4761 encoder_: &mut ___E,
4762 out_: &mut ::core::mem::MaybeUninit<
4763 crate::wire::CapabilityStoreDictionaryDrainResponse,
4764 >,
4765 _: (),
4766 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4767 ::fidl_next::munge! {
4768 let crate::wire::CapabilityStoreDictionaryDrainResponse {
4769
4770 _empty,
4771
4772 } = out_;
4773 }
4774
4775 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4776
4777 Ok(())
4778 }
4779 }
4780
4781 unsafe impl<'a, ___E>
4782 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainResponse, ___E>
4783 for &'a CapabilityStoreDictionaryDrainResponse
4784 where
4785 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4786 {
4787 #[inline]
4788 fn encode(
4789 self,
4790 encoder_: &mut ___E,
4791 out_: &mut ::core::mem::MaybeUninit<
4792 crate::wire::CapabilityStoreDictionaryDrainResponse,
4793 >,
4794 _: (),
4795 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4796 ::fidl_next::munge! {
4797 let crate::wire::CapabilityStoreDictionaryDrainResponse {
4798
4799 _empty,
4800
4801
4802 } = out_;
4803 }
4804
4805 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
4806
4807 Ok(())
4808 }
4809 }
4810
4811 unsafe impl<___E>
4812 ::fidl_next::EncodeOption<
4813 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryDrainResponse>,
4814 ___E,
4815 > for CapabilityStoreDictionaryDrainResponse
4816 where
4817 ___E: ::fidl_next::Encoder + ?Sized,
4818 CapabilityStoreDictionaryDrainResponse:
4819 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainResponse, ___E>,
4820 {
4821 #[inline]
4822 fn encode_option(
4823 this: ::core::option::Option<Self>,
4824 encoder: &mut ___E,
4825 out: &mut ::core::mem::MaybeUninit<
4826 ::fidl_next::wire::Box<
4827 'static,
4828 crate::wire::CapabilityStoreDictionaryDrainResponse,
4829 >,
4830 >,
4831 _: (),
4832 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4833 if let Some(inner) = this {
4834 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4835 ::fidl_next::wire::Box::encode_present(out);
4836 } else {
4837 ::fidl_next::wire::Box::encode_absent(out);
4838 }
4839
4840 Ok(())
4841 }
4842 }
4843
4844 unsafe impl<'a, ___E>
4845 ::fidl_next::EncodeOption<
4846 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryDrainResponse>,
4847 ___E,
4848 > for &'a CapabilityStoreDictionaryDrainResponse
4849 where
4850 ___E: ::fidl_next::Encoder + ?Sized,
4851 &'a CapabilityStoreDictionaryDrainResponse:
4852 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainResponse, ___E>,
4853 {
4854 #[inline]
4855 fn encode_option(
4856 this: ::core::option::Option<Self>,
4857 encoder: &mut ___E,
4858 out: &mut ::core::mem::MaybeUninit<
4859 ::fidl_next::wire::Box<
4860 'static,
4861 crate::wire::CapabilityStoreDictionaryDrainResponse,
4862 >,
4863 >,
4864 _: (),
4865 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4866 if let Some(inner) = this {
4867 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4868 ::fidl_next::wire::Box::encode_present(out);
4869 } else {
4870 ::fidl_next::wire::Box::encode_absent(out);
4871 }
4872
4873 Ok(())
4874 }
4875 }
4876
4877 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainResponse>
4878 for CapabilityStoreDictionaryDrainResponse
4879 {
4880 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4881 crate::wire::CapabilityStoreDictionaryDrainResponse,
4882 Self,
4883 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4884
4885 #[inline]
4886 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainResponse) -> Self {
4887 Self {}
4888 }
4889 }
4890
4891 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryDrainResponse>
4892 for CapabilityStoreDictionaryDrainResponse
4893 {
4894 #[inline]
4895 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryDrainResponse) -> Self {
4896 Self {}
4897 }
4898 }
4899
4900 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4901 #[repr(u32)]
4902 pub enum RouterError {
4903 NotFound = 1,
4904 InvalidArgs = 2,
4905 NotSupported = 3,
4906 Internal = 4,
4907 UnknownOrdinal_(u32) = 5,
4908 }
4909 impl ::std::convert::From<u32> for RouterError {
4910 fn from(value: u32) -> Self {
4911 match value {
4912 1 => Self::NotFound,
4913 2 => Self::InvalidArgs,
4914 3 => Self::NotSupported,
4915 4 => Self::Internal,
4916
4917 _ => Self::UnknownOrdinal_(value),
4918 }
4919 }
4920 }
4921
4922 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouterError, ___E> for RouterError
4923 where
4924 ___E: ?Sized,
4925 {
4926 #[inline]
4927 fn encode(
4928 self,
4929 encoder: &mut ___E,
4930 out: &mut ::core::mem::MaybeUninit<crate::wire::RouterError>,
4931 _: (),
4932 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4933 ::fidl_next::Encode::encode(&self, encoder, out, ())
4934 }
4935 }
4936
4937 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RouterError, ___E> for &'a RouterError
4938 where
4939 ___E: ?Sized,
4940 {
4941 #[inline]
4942 fn encode(
4943 self,
4944 encoder: &mut ___E,
4945 out: &mut ::core::mem::MaybeUninit<crate::wire::RouterError>,
4946 _: (),
4947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4948 ::fidl_next::munge!(let crate::wire::RouterError { value } = out);
4949 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
4950 RouterError::NotFound => 1,
4951
4952 RouterError::InvalidArgs => 2,
4953
4954 RouterError::NotSupported => 3,
4955
4956 RouterError::Internal => 4,
4957
4958 RouterError::UnknownOrdinal_(value) => value,
4959 }));
4960
4961 Ok(())
4962 }
4963 }
4964
4965 impl ::core::convert::From<crate::wire::RouterError> for RouterError {
4966 fn from(wire: crate::wire::RouterError) -> Self {
4967 match u32::from(wire.value) {
4968 1 => Self::NotFound,
4969
4970 2 => Self::InvalidArgs,
4971
4972 3 => Self::NotSupported,
4973
4974 4 => Self::Internal,
4975
4976 value => Self::UnknownOrdinal_(value),
4977 }
4978 }
4979 }
4980
4981 impl ::fidl_next::FromWire<crate::wire::RouterError> for RouterError {
4982 #[inline]
4983 fn from_wire(wire: crate::wire::RouterError) -> Self {
4984 Self::from(wire)
4985 }
4986 }
4987
4988 impl ::fidl_next::FromWireRef<crate::wire::RouterError> for RouterError {
4989 #[inline]
4990 fn from_wire_ref(wire: &crate::wire::RouterError) -> Self {
4991 Self::from(*wire)
4992 }
4993 }
4994
4995 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4996 pub struct DictionaryDrainIteratorGetNextRequest {
4997 pub start_id: u64,
4998
4999 pub limit: u32,
5000 }
5001
5002 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>
5003 for DictionaryDrainIteratorGetNextRequest
5004 where
5005 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5006 {
5007 #[inline]
5008 fn encode(
5009 self,
5010 encoder_: &mut ___E,
5011 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryDrainIteratorGetNextRequest>,
5012 _: (),
5013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5014 ::fidl_next::munge! {
5015 let crate::wire::DictionaryDrainIteratorGetNextRequest {
5016 start_id,
5017 limit,
5018
5019 } = out_;
5020 }
5021
5022 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
5023
5024 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
5025
5026 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
5027
5028 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
5029
5030 Ok(())
5031 }
5032 }
5033
5034 unsafe impl<'a, ___E>
5035 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>
5036 for &'a DictionaryDrainIteratorGetNextRequest
5037 where
5038 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5039 {
5040 #[inline]
5041 fn encode(
5042 self,
5043 encoder_: &mut ___E,
5044 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryDrainIteratorGetNextRequest>,
5045 _: (),
5046 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5047 ::fidl_next::munge! {
5048 let crate::wire::DictionaryDrainIteratorGetNextRequest {
5049
5050 start_id,
5051 limit,
5052
5053 } = out_;
5054 }
5055
5056 ::fidl_next::Encode::encode(&self.start_id, encoder_, start_id, ())?;
5057
5058 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
5059
5060 ::fidl_next::Encode::encode(&self.limit, encoder_, limit, ())?;
5061
5062 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
5063
5064 Ok(())
5065 }
5066 }
5067
5068 unsafe impl<___E>
5069 ::fidl_next::EncodeOption<
5070 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
5071 ___E,
5072 > for DictionaryDrainIteratorGetNextRequest
5073 where
5074 ___E: ::fidl_next::Encoder + ?Sized,
5075 DictionaryDrainIteratorGetNextRequest:
5076 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>,
5077 {
5078 #[inline]
5079 fn encode_option(
5080 this: ::core::option::Option<Self>,
5081 encoder: &mut ___E,
5082 out: &mut ::core::mem::MaybeUninit<
5083 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
5084 >,
5085 _: (),
5086 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5087 if let Some(inner) = this {
5088 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5089 ::fidl_next::wire::Box::encode_present(out);
5090 } else {
5091 ::fidl_next::wire::Box::encode_absent(out);
5092 }
5093
5094 Ok(())
5095 }
5096 }
5097
5098 unsafe impl<'a, ___E>
5099 ::fidl_next::EncodeOption<
5100 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
5101 ___E,
5102 > for &'a DictionaryDrainIteratorGetNextRequest
5103 where
5104 ___E: ::fidl_next::Encoder + ?Sized,
5105 &'a DictionaryDrainIteratorGetNextRequest:
5106 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>,
5107 {
5108 #[inline]
5109 fn encode_option(
5110 this: ::core::option::Option<Self>,
5111 encoder: &mut ___E,
5112 out: &mut ::core::mem::MaybeUninit<
5113 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
5114 >,
5115 _: (),
5116 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5117 if let Some(inner) = this {
5118 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5119 ::fidl_next::wire::Box::encode_present(out);
5120 } else {
5121 ::fidl_next::wire::Box::encode_absent(out);
5122 }
5123
5124 Ok(())
5125 }
5126 }
5127
5128 impl ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextRequest>
5129 for DictionaryDrainIteratorGetNextRequest
5130 {
5131 #[inline]
5132 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
5133 Self {
5134 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
5135
5136 limit: ::fidl_next::FromWire::from_wire(wire.limit),
5137 }
5138 }
5139 }
5140
5141 impl ::fidl_next::FromWireRef<crate::wire::DictionaryDrainIteratorGetNextRequest>
5142 for DictionaryDrainIteratorGetNextRequest
5143 {
5144 #[inline]
5145 fn from_wire_ref(wire: &crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
5146 Self {
5147 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
5148
5149 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
5150 }
5151 }
5152 }
5153
5154 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5155 pub struct DictionaryEnumerateIteratorGetNextRequest {
5156 pub start_id: u64,
5157
5158 pub limit: u32,
5159 }
5160
5161 unsafe impl<___E>
5162 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>
5163 for DictionaryEnumerateIteratorGetNextRequest
5164 where
5165 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5166 {
5167 #[inline]
5168 fn encode(
5169 self,
5170 encoder_: &mut ___E,
5171 out_: &mut ::core::mem::MaybeUninit<
5172 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
5173 >,
5174 _: (),
5175 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5176 ::fidl_next::munge! {
5177 let crate::wire::DictionaryEnumerateIteratorGetNextRequest {
5178 start_id,
5179 limit,
5180
5181 } = out_;
5182 }
5183
5184 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
5185
5186 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
5187
5188 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
5189
5190 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
5191
5192 Ok(())
5193 }
5194 }
5195
5196 unsafe impl<'a, ___E>
5197 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>
5198 for &'a DictionaryEnumerateIteratorGetNextRequest
5199 where
5200 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5201 {
5202 #[inline]
5203 fn encode(
5204 self,
5205 encoder_: &mut ___E,
5206 out_: &mut ::core::mem::MaybeUninit<
5207 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
5208 >,
5209 _: (),
5210 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5211 ::fidl_next::munge! {
5212 let crate::wire::DictionaryEnumerateIteratorGetNextRequest {
5213
5214 start_id,
5215 limit,
5216
5217 } = out_;
5218 }
5219
5220 ::fidl_next::Encode::encode(&self.start_id, encoder_, start_id, ())?;
5221
5222 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
5223
5224 ::fidl_next::Encode::encode(&self.limit, encoder_, limit, ())?;
5225
5226 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
5227
5228 Ok(())
5229 }
5230 }
5231
5232 unsafe impl<___E>
5233 ::fidl_next::EncodeOption<
5234 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEnumerateIteratorGetNextRequest>,
5235 ___E,
5236 > for DictionaryEnumerateIteratorGetNextRequest
5237 where
5238 ___E: ::fidl_next::Encoder + ?Sized,
5239 DictionaryEnumerateIteratorGetNextRequest:
5240 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>,
5241 {
5242 #[inline]
5243 fn encode_option(
5244 this: ::core::option::Option<Self>,
5245 encoder: &mut ___E,
5246 out: &mut ::core::mem::MaybeUninit<
5247 ::fidl_next::wire::Box<
5248 'static,
5249 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
5250 >,
5251 >,
5252 _: (),
5253 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5254 if let Some(inner) = this {
5255 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5256 ::fidl_next::wire::Box::encode_present(out);
5257 } else {
5258 ::fidl_next::wire::Box::encode_absent(out);
5259 }
5260
5261 Ok(())
5262 }
5263 }
5264
5265 unsafe impl<'a, ___E>
5266 ::fidl_next::EncodeOption<
5267 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEnumerateIteratorGetNextRequest>,
5268 ___E,
5269 > for &'a DictionaryEnumerateIteratorGetNextRequest
5270 where
5271 ___E: ::fidl_next::Encoder + ?Sized,
5272 &'a DictionaryEnumerateIteratorGetNextRequest:
5273 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>,
5274 {
5275 #[inline]
5276 fn encode_option(
5277 this: ::core::option::Option<Self>,
5278 encoder: &mut ___E,
5279 out: &mut ::core::mem::MaybeUninit<
5280 ::fidl_next::wire::Box<
5281 'static,
5282 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
5283 >,
5284 >,
5285 _: (),
5286 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5287 if let Some(inner) = this {
5288 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5289 ::fidl_next::wire::Box::encode_present(out);
5290 } else {
5291 ::fidl_next::wire::Box::encode_absent(out);
5292 }
5293
5294 Ok(())
5295 }
5296 }
5297
5298 impl ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
5299 for DictionaryEnumerateIteratorGetNextRequest
5300 {
5301 #[inline]
5302 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
5303 Self {
5304 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
5305
5306 limit: ::fidl_next::FromWire::from_wire(wire.limit),
5307 }
5308 }
5309 }
5310
5311 impl ::fidl_next::FromWireRef<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
5312 for DictionaryEnumerateIteratorGetNextRequest
5313 {
5314 #[inline]
5315 fn from_wire_ref(wire: &crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
5316 Self {
5317 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
5318
5319 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
5320 }
5321 }
5322 }
5323
5324 #[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
5325 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5326 #[repr(u32)]
5327 pub enum DictionaryError {
5328 NotFound = 1,
5329 AlreadyExists = 2,
5330 BadCapability = 3,
5331 InvalidKey = 4,
5332 NotCloneable = 5,
5333 UnknownOrdinal_(u32) = 6,
5334 }
5335 impl ::std::convert::From<u32> for DictionaryError {
5336 fn from(value: u32) -> Self {
5337 match value {
5338 1 => Self::NotFound,
5339 2 => Self::AlreadyExists,
5340 3 => Self::BadCapability,
5341 4 => Self::InvalidKey,
5342 5 => Self::NotCloneable,
5343
5344 _ => Self::UnknownOrdinal_(value),
5345 }
5346 }
5347 }
5348
5349 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryError, ___E> for DictionaryError
5350 where
5351 ___E: ?Sized,
5352 {
5353 #[inline]
5354 fn encode(
5355 self,
5356 encoder: &mut ___E,
5357 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryError>,
5358 _: (),
5359 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5360 ::fidl_next::Encode::encode(&self, encoder, out, ())
5361 }
5362 }
5363
5364 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DictionaryError, ___E>
5365 for &'a DictionaryError
5366 where
5367 ___E: ?Sized,
5368 {
5369 #[inline]
5370 fn encode(
5371 self,
5372 encoder: &mut ___E,
5373 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryError>,
5374 _: (),
5375 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5376 ::fidl_next::munge!(let crate::wire::DictionaryError { value } = out);
5377 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
5378 DictionaryError::NotFound => 1,
5379
5380 DictionaryError::AlreadyExists => 2,
5381
5382 DictionaryError::BadCapability => 3,
5383
5384 DictionaryError::InvalidKey => 4,
5385
5386 DictionaryError::NotCloneable => 5,
5387
5388 DictionaryError::UnknownOrdinal_(value) => value,
5389 }));
5390
5391 Ok(())
5392 }
5393 }
5394
5395 impl ::core::convert::From<crate::wire::DictionaryError> for DictionaryError {
5396 fn from(wire: crate::wire::DictionaryError) -> Self {
5397 match u32::from(wire.value) {
5398 1 => Self::NotFound,
5399
5400 2 => Self::AlreadyExists,
5401
5402 3 => Self::BadCapability,
5403
5404 4 => Self::InvalidKey,
5405
5406 5 => Self::NotCloneable,
5407
5408 value => Self::UnknownOrdinal_(value),
5409 }
5410 }
5411 }
5412
5413 impl ::fidl_next::FromWire<crate::wire::DictionaryError> for DictionaryError {
5414 #[inline]
5415 fn from_wire(wire: crate::wire::DictionaryError) -> Self {
5416 Self::from(wire)
5417 }
5418 }
5419
5420 impl ::fidl_next::FromWireRef<crate::wire::DictionaryError> for DictionaryError {
5421 #[inline]
5422 fn from_wire_ref(wire: &crate::wire::DictionaryError) -> Self {
5423 Self::from(*wire)
5424 }
5425 }
5426
5427 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5428 #[repr(C)]
5429 pub struct Unavailable {}
5430
5431 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Unavailable, ___E> for Unavailable
5432 where
5433 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5434 {
5435 #[inline]
5436 fn encode(
5437 self,
5438 encoder_: &mut ___E,
5439 out_: &mut ::core::mem::MaybeUninit<crate::wire::Unavailable>,
5440 _: (),
5441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5442 ::fidl_next::munge! {
5443 let crate::wire::Unavailable {
5444
5445 _empty,
5446
5447 } = out_;
5448 }
5449
5450 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
5451
5452 Ok(())
5453 }
5454 }
5455
5456 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Unavailable, ___E> for &'a Unavailable
5457 where
5458 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5459 {
5460 #[inline]
5461 fn encode(
5462 self,
5463 encoder_: &mut ___E,
5464 out_: &mut ::core::mem::MaybeUninit<crate::wire::Unavailable>,
5465 _: (),
5466 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5467 ::fidl_next::munge! {
5468 let crate::wire::Unavailable {
5469
5470 _empty,
5471
5472
5473 } = out_;
5474 }
5475
5476 let _ = _empty.write(::fidl_next::wire::EmptyStruct::Zero);
5477
5478 Ok(())
5479 }
5480 }
5481
5482 unsafe impl<___E>
5483 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Unavailable>, ___E>
5484 for Unavailable
5485 where
5486 ___E: ::fidl_next::Encoder + ?Sized,
5487 Unavailable: ::fidl_next::Encode<crate::wire::Unavailable, ___E>,
5488 {
5489 #[inline]
5490 fn encode_option(
5491 this: ::core::option::Option<Self>,
5492 encoder: &mut ___E,
5493 out: &mut ::core::mem::MaybeUninit<
5494 ::fidl_next::wire::Box<'static, crate::wire::Unavailable>,
5495 >,
5496 _: (),
5497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5498 if let Some(inner) = this {
5499 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5500 ::fidl_next::wire::Box::encode_present(out);
5501 } else {
5502 ::fidl_next::wire::Box::encode_absent(out);
5503 }
5504
5505 Ok(())
5506 }
5507 }
5508
5509 unsafe impl<'a, ___E>
5510 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Unavailable>, ___E>
5511 for &'a Unavailable
5512 where
5513 ___E: ::fidl_next::Encoder + ?Sized,
5514 &'a Unavailable: ::fidl_next::Encode<crate::wire::Unavailable, ___E>,
5515 {
5516 #[inline]
5517 fn encode_option(
5518 this: ::core::option::Option<Self>,
5519 encoder: &mut ___E,
5520 out: &mut ::core::mem::MaybeUninit<
5521 ::fidl_next::wire::Box<'static, crate::wire::Unavailable>,
5522 >,
5523 _: (),
5524 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5525 if let Some(inner) = this {
5526 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5527 ::fidl_next::wire::Box::encode_present(out);
5528 } else {
5529 ::fidl_next::wire::Box::encode_absent(out);
5530 }
5531
5532 Ok(())
5533 }
5534 }
5535
5536 impl ::fidl_next::FromWire<crate::wire::Unavailable> for Unavailable {
5537 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Unavailable, Self> =
5538 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5539
5540 #[inline]
5541 fn from_wire(wire: crate::wire::Unavailable) -> Self {
5542 Self {}
5543 }
5544 }
5545
5546 impl ::fidl_next::FromWireRef<crate::wire::Unavailable> for Unavailable {
5547 #[inline]
5548 fn from_wire_ref(wire: &crate::wire::Unavailable) -> Self {
5549 Self {}
5550 }
5551 }
5552}
5553
5554pub mod wire {
5555
5556 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
5558 #[repr(transparent)]
5559 pub struct Availability {
5560 pub(crate) value: ::fidl_next::wire::Uint32,
5561 }
5562
5563 impl ::fidl_next::Constrained for Availability {
5564 type Constraint = ();
5565
5566 fn validate(
5567 _: ::fidl_next::Slot<'_, Self>,
5568 _: Self::Constraint,
5569 ) -> Result<(), ::fidl_next::ValidationError> {
5570 Ok(())
5571 }
5572 }
5573
5574 unsafe impl ::fidl_next::Wire for Availability {
5575 type Narrowed<'de> = Self;
5576
5577 #[inline]
5578 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
5579 }
5581 }
5582
5583 impl Availability {
5584 pub const REQUIRED: Availability = Availability { value: ::fidl_next::wire::Uint32(1) };
5585
5586 pub const OPTIONAL: Availability = Availability { value: ::fidl_next::wire::Uint32(2) };
5587
5588 pub const SAME_AS_TARGET: Availability =
5589 Availability { value: ::fidl_next::wire::Uint32(3) };
5590
5591 pub const TRANSITIONAL: Availability = Availability { value: ::fidl_next::wire::Uint32(4) };
5592 }
5593
5594 unsafe impl<___D> ::fidl_next::Decode<___D> for Availability
5595 where
5596 ___D: ?Sized,
5597 {
5598 fn decode(
5599 slot: ::fidl_next::Slot<'_, Self>,
5600 _: &mut ___D,
5601 _: (),
5602 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5603 ::fidl_next::munge!(let Self { value } = slot);
5604
5605 match u32::from(*value) {
5606 1 | 2 | 3 | 4 => (),
5607 unknown => {
5608 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
5609 }
5610 }
5611
5612 Ok(())
5613 }
5614 }
5615
5616 impl ::core::convert::From<crate::natural::Availability> for Availability {
5617 fn from(natural: crate::natural::Availability) -> Self {
5618 match natural {
5619 crate::natural::Availability::Required => Availability::REQUIRED,
5620
5621 crate::natural::Availability::Optional => Availability::OPTIONAL,
5622
5623 crate::natural::Availability::SameAsTarget => Availability::SAME_AS_TARGET,
5624
5625 crate::natural::Availability::Transitional => Availability::TRANSITIONAL,
5626 }
5627 }
5628 }
5629
5630 impl ::fidl_next::IntoNatural for Availability {
5631 type Natural = crate::natural::Availability;
5632 }
5633
5634 #[derive(Clone, Debug)]
5636 #[repr(C)]
5637 pub struct Unit {
5638 pub(crate) _empty: fidl_next::wire::EmptyStruct,
5639 }
5640
5641 static_assertions::const_assert_eq!(std::mem::size_of::<Unit>(), 1);
5642 static_assertions::const_assert_eq!(std::mem::align_of::<Unit>(), 1);
5643
5644 impl ::fidl_next::Constrained for Unit {
5645 type Constraint = ();
5646
5647 fn validate(
5648 _: ::fidl_next::Slot<'_, Self>,
5649 _: Self::Constraint,
5650 ) -> Result<(), ::fidl_next::ValidationError> {
5651 Ok(())
5652 }
5653 }
5654
5655 unsafe impl ::fidl_next::Wire for Unit {
5656 type Narrowed<'de> = Unit;
5657
5658 #[inline]
5659 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5660 ::fidl_next::munge! {
5661 let Self {
5662
5663 _empty,
5664
5665
5666 } = &mut *out_;
5667 }
5668 }
5669 }
5670
5671 unsafe impl<___D> ::fidl_next::Decode<___D> for Unit
5672 where
5673 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5674 {
5675 fn decode(
5676 slot_: ::fidl_next::Slot<'_, Self>,
5677 decoder_: &mut ___D,
5678 _: (),
5679 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5680 ::fidl_next::munge! {
5681 let Self {
5682
5683 mut _empty,
5684
5685
5686 } = slot_;
5687 }
5688
5689 if _empty.as_bytes() != &[0u8] {
5690 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
5691 }
5692
5693 Ok(())
5694 }
5695 }
5696
5697 impl ::fidl_next::IntoNatural for Unit {
5698 type Natural = crate::natural::Unit;
5699 }
5700
5701 #[repr(transparent)]
5703 pub struct Data<'de> {
5704 pub(crate) raw: ::fidl_next::wire::Union,
5705 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
5706 }
5707
5708 impl<'de> Drop for Data<'de> {
5709 fn drop(&mut self) {
5710 match self.raw.ordinal() {
5711 1 => {
5712 let _ = unsafe {
5713 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
5714 };
5715 }
5716
5717 2 => {
5718 let _ = unsafe {
5719 self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
5720 };
5721 }
5722
5723 3 => {
5724 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Int64>() };
5725 }
5726
5727 4 => {
5728 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint64>() };
5729 }
5730
5731 _ => (),
5732 }
5733 }
5734 }
5735
5736 impl ::fidl_next::Constrained for Data<'_> {
5737 type Constraint = ();
5738
5739 fn validate(
5740 _: ::fidl_next::Slot<'_, Self>,
5741 _: Self::Constraint,
5742 ) -> Result<(), ::fidl_next::ValidationError> {
5743 Ok(())
5744 }
5745 }
5746
5747 unsafe impl ::fidl_next::Wire for Data<'static> {
5748 type Narrowed<'de> = Data<'de>;
5749
5750 #[inline]
5751 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5752 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5753 ::fidl_next::wire::Union::zero_padding(raw);
5754 }
5755 }
5756
5757 pub mod data {
5758 pub enum Ref<'de> {
5759 Bytes(&'de ::fidl_next::wire::Vector<'de, u8>),
5760
5761 String(&'de ::fidl_next::wire::String<'de>),
5762
5763 Int64(&'de ::fidl_next::wire::Int64),
5764
5765 Uint64(&'de ::fidl_next::wire::Uint64),
5766
5767 UnknownOrdinal_(u64),
5768 }
5769 }
5770
5771 impl<'de> Data<'de> {
5772 pub fn as_ref(&self) -> crate::wire::data::Ref<'_> {
5773 match self.raw.ordinal() {
5774 1 => crate::wire::data::Ref::Bytes(unsafe {
5775 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
5776 }),
5777
5778 2 => crate::wire::data::Ref::String(unsafe {
5779 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
5780 }),
5781
5782 3 => crate::wire::data::Ref::Int64(unsafe {
5783 self.raw.get().deref_unchecked::<::fidl_next::wire::Int64>()
5784 }),
5785
5786 4 => crate::wire::data::Ref::Uint64(unsafe {
5787 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>()
5788 }),
5789
5790 unknown => crate::wire::data::Ref::UnknownOrdinal_(unknown),
5791 }
5792 }
5793 }
5794
5795 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Data<'de>
5796 where
5797 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5798 ___D: ::fidl_next::Decoder<'de>,
5799 {
5800 fn decode(
5801 mut slot: ::fidl_next::Slot<'_, Self>,
5802 decoder: &mut ___D,
5803 _: (),
5804 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5805 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5806 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
5807 1 => {
5808 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
5809 raw,
5810 decoder,
5811 (8192, ()),
5812 )?
5813 }
5814
5815 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
5816 raw, decoder, 8192,
5817 )?,
5818
5819 3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int64>(
5820 raw,
5821 decoder,
5822 (),
5823 )?,
5824
5825 4 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
5826 raw,
5827 decoder,
5828 (),
5829 )?,
5830
5831 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
5832 }
5833
5834 Ok(())
5835 }
5836 }
5837
5838 impl<'de> ::core::fmt::Debug for Data<'de> {
5839 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5840 match self.raw.ordinal() {
5841 1 => unsafe {
5842 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
5843 },
5844 2 => unsafe {
5845 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
5846 },
5847 3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::wire::Int64>().fmt(f) },
5848 4 => unsafe {
5849 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>().fmt(f)
5850 },
5851 _ => unsafe { ::core::hint::unreachable_unchecked() },
5852 }
5853 }
5854 }
5855
5856 impl<'de> ::fidl_next::IntoNatural for Data<'de> {
5857 type Natural = crate::natural::Data;
5858 }
5859
5860 pub type CapabilityId = ::fidl_next::wire::Uint64;
5862
5863 pub type NewCapabilityId = ::fidl_next::wire::Uint64;
5865
5866 #[derive(Clone, Debug)]
5868 #[repr(C)]
5869 pub struct CapabilityStoreDuplicateRequest {
5870 pub id: ::fidl_next::wire::Uint64,
5871
5872 pub dest_id: ::fidl_next::wire::Uint64,
5873 }
5874
5875 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateRequest>(), 16);
5876 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDuplicateRequest>(), 8);
5877
5878 static_assertions::const_assert_eq!(
5879 std::mem::offset_of!(CapabilityStoreDuplicateRequest, id),
5880 0
5881 );
5882
5883 static_assertions::const_assert_eq!(
5884 std::mem::offset_of!(CapabilityStoreDuplicateRequest, dest_id),
5885 8
5886 );
5887
5888 impl ::fidl_next::Constrained for CapabilityStoreDuplicateRequest {
5889 type Constraint = ();
5890
5891 fn validate(
5892 _: ::fidl_next::Slot<'_, Self>,
5893 _: Self::Constraint,
5894 ) -> Result<(), ::fidl_next::ValidationError> {
5895 Ok(())
5896 }
5897 }
5898
5899 unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateRequest {
5900 type Narrowed<'de> = CapabilityStoreDuplicateRequest;
5901
5902 #[inline]
5903 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5904 ::fidl_next::munge! {
5905 let Self {
5906
5907 id,
5908 dest_id,
5909
5910 } = &mut *out_;
5911 }
5912
5913 ::fidl_next::Wire::zero_padding(id);
5914
5915 ::fidl_next::Wire::zero_padding(dest_id);
5916 }
5917 }
5918
5919 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateRequest
5920 where
5921 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5922 {
5923 fn decode(
5924 slot_: ::fidl_next::Slot<'_, Self>,
5925 decoder_: &mut ___D,
5926 _: (),
5927 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5928 ::fidl_next::munge! {
5929 let Self {
5930
5931 mut id,
5932 mut dest_id,
5933
5934 } = slot_;
5935 }
5936
5937 let _field = id.as_mut();
5938
5939 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5940
5941 let _field = dest_id.as_mut();
5942
5943 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
5944
5945 Ok(())
5946 }
5947 }
5948
5949 impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateRequest {
5950 type Natural = crate::natural::CapabilityStoreDuplicateRequest;
5951 }
5952
5953 #[derive(Clone, Debug)]
5955 #[repr(C)]
5956 pub struct CapabilityStoreDuplicateResponse {
5957 pub(crate) _empty: fidl_next::wire::EmptyStruct,
5958 }
5959
5960 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateResponse>(), 1);
5961 static_assertions::const_assert_eq!(
5962 std::mem::align_of::<CapabilityStoreDuplicateResponse>(),
5963 1
5964 );
5965
5966 impl ::fidl_next::Constrained for CapabilityStoreDuplicateResponse {
5967 type Constraint = ();
5968
5969 fn validate(
5970 _: ::fidl_next::Slot<'_, Self>,
5971 _: Self::Constraint,
5972 ) -> Result<(), ::fidl_next::ValidationError> {
5973 Ok(())
5974 }
5975 }
5976
5977 unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateResponse {
5978 type Narrowed<'de> = CapabilityStoreDuplicateResponse;
5979
5980 #[inline]
5981 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5982 ::fidl_next::munge! {
5983 let Self {
5984
5985 _empty,
5986
5987
5988 } = &mut *out_;
5989 }
5990 }
5991 }
5992
5993 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateResponse
5994 where
5995 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5996 {
5997 fn decode(
5998 slot_: ::fidl_next::Slot<'_, Self>,
5999 decoder_: &mut ___D,
6000 _: (),
6001 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6002 ::fidl_next::munge! {
6003 let Self {
6004
6005 mut _empty,
6006
6007
6008 } = slot_;
6009 }
6010
6011 if _empty.as_bytes() != &[0u8] {
6012 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6013 }
6014
6015 Ok(())
6016 }
6017 }
6018
6019 impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateResponse {
6020 type Natural = crate::natural::CapabilityStoreDuplicateResponse;
6021 }
6022
6023 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6025 #[repr(transparent)]
6026 pub struct CapabilityStoreError {
6027 pub(crate) value: ::fidl_next::wire::Uint32,
6028 }
6029
6030 impl ::fidl_next::Constrained for CapabilityStoreError {
6031 type Constraint = ();
6032
6033 fn validate(
6034 _: ::fidl_next::Slot<'_, Self>,
6035 _: Self::Constraint,
6036 ) -> Result<(), ::fidl_next::ValidationError> {
6037 Ok(())
6038 }
6039 }
6040
6041 unsafe impl ::fidl_next::Wire for CapabilityStoreError {
6042 type Narrowed<'de> = Self;
6043
6044 #[inline]
6045 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6046 }
6048 }
6049
6050 impl CapabilityStoreError {
6051 pub const ID_NOT_FOUND: CapabilityStoreError =
6052 CapabilityStoreError { value: ::fidl_next::wire::Uint32(1) };
6053
6054 pub const ID_ALREADY_EXISTS: CapabilityStoreError =
6055 CapabilityStoreError { value: ::fidl_next::wire::Uint32(2) };
6056
6057 pub const BAD_CAPABILITY: CapabilityStoreError =
6058 CapabilityStoreError { value: ::fidl_next::wire::Uint32(3) };
6059
6060 pub const WRONG_TYPE: CapabilityStoreError =
6061 CapabilityStoreError { value: ::fidl_next::wire::Uint32(4) };
6062
6063 pub const NOT_DUPLICATABLE: CapabilityStoreError =
6064 CapabilityStoreError { value: ::fidl_next::wire::Uint32(5) };
6065
6066 pub const ITEM_NOT_FOUND: CapabilityStoreError =
6067 CapabilityStoreError { value: ::fidl_next::wire::Uint32(6) };
6068
6069 pub const ITEM_ALREADY_EXISTS: CapabilityStoreError =
6070 CapabilityStoreError { value: ::fidl_next::wire::Uint32(7) };
6071
6072 pub const INVALID_KEY: CapabilityStoreError =
6073 CapabilityStoreError { value: ::fidl_next::wire::Uint32(8) };
6074
6075 pub const INVALID_ARGS: CapabilityStoreError =
6076 CapabilityStoreError { value: ::fidl_next::wire::Uint32(9) };
6077 }
6078
6079 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreError
6080 where
6081 ___D: ?Sized,
6082 {
6083 fn decode(
6084 slot: ::fidl_next::Slot<'_, Self>,
6085 _: &mut ___D,
6086 _: (),
6087 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6088 Ok(())
6089 }
6090 }
6091
6092 impl ::core::convert::From<crate::natural::CapabilityStoreError> for CapabilityStoreError {
6093 fn from(natural: crate::natural::CapabilityStoreError) -> Self {
6094 match natural {
6095 crate::natural::CapabilityStoreError::IdNotFound => {
6096 CapabilityStoreError::ID_NOT_FOUND
6097 }
6098
6099 crate::natural::CapabilityStoreError::IdAlreadyExists => {
6100 CapabilityStoreError::ID_ALREADY_EXISTS
6101 }
6102
6103 crate::natural::CapabilityStoreError::BadCapability => {
6104 CapabilityStoreError::BAD_CAPABILITY
6105 }
6106
6107 crate::natural::CapabilityStoreError::WrongType => CapabilityStoreError::WRONG_TYPE,
6108
6109 crate::natural::CapabilityStoreError::NotDuplicatable => {
6110 CapabilityStoreError::NOT_DUPLICATABLE
6111 }
6112
6113 crate::natural::CapabilityStoreError::ItemNotFound => {
6114 CapabilityStoreError::ITEM_NOT_FOUND
6115 }
6116
6117 crate::natural::CapabilityStoreError::ItemAlreadyExists => {
6118 CapabilityStoreError::ITEM_ALREADY_EXISTS
6119 }
6120
6121 crate::natural::CapabilityStoreError::InvalidKey => {
6122 CapabilityStoreError::INVALID_KEY
6123 }
6124
6125 crate::natural::CapabilityStoreError::InvalidArgs => {
6126 CapabilityStoreError::INVALID_ARGS
6127 }
6128
6129 crate::natural::CapabilityStoreError::UnknownOrdinal_(value) => {
6130 CapabilityStoreError { value: ::fidl_next::wire::Uint32::from(value) }
6131 }
6132 }
6133 }
6134 }
6135
6136 impl ::fidl_next::IntoNatural for CapabilityStoreError {
6137 type Natural = crate::natural::CapabilityStoreError;
6138 }
6139
6140 #[derive(Clone, Debug)]
6142 #[repr(C)]
6143 pub struct CapabilityStoreDropRequest {
6144 pub id: ::fidl_next::wire::Uint64,
6145 }
6146
6147 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropRequest>(), 8);
6148 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropRequest>(), 8);
6149
6150 static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreDropRequest, id), 0);
6151
6152 impl ::fidl_next::Constrained for CapabilityStoreDropRequest {
6153 type Constraint = ();
6154
6155 fn validate(
6156 _: ::fidl_next::Slot<'_, Self>,
6157 _: Self::Constraint,
6158 ) -> Result<(), ::fidl_next::ValidationError> {
6159 Ok(())
6160 }
6161 }
6162
6163 unsafe impl ::fidl_next::Wire for CapabilityStoreDropRequest {
6164 type Narrowed<'de> = CapabilityStoreDropRequest;
6165
6166 #[inline]
6167 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6168 ::fidl_next::munge! {
6169 let Self {
6170
6171 id,
6172
6173 } = &mut *out_;
6174 }
6175
6176 ::fidl_next::Wire::zero_padding(id);
6177 }
6178 }
6179
6180 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropRequest
6181 where
6182 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6183 {
6184 fn decode(
6185 slot_: ::fidl_next::Slot<'_, Self>,
6186 decoder_: &mut ___D,
6187 _: (),
6188 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6189 ::fidl_next::munge! {
6190 let Self {
6191
6192 mut id,
6193
6194 } = slot_;
6195 }
6196
6197 let _field = id.as_mut();
6198
6199 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
6200
6201 Ok(())
6202 }
6203 }
6204
6205 impl ::fidl_next::IntoNatural for CapabilityStoreDropRequest {
6206 type Natural = crate::natural::CapabilityStoreDropRequest;
6207 }
6208
6209 #[derive(Clone, Debug)]
6211 #[repr(C)]
6212 pub struct CapabilityStoreDropResponse {
6213 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6214 }
6215
6216 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropResponse>(), 1);
6217 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropResponse>(), 1);
6218
6219 impl ::fidl_next::Constrained for CapabilityStoreDropResponse {
6220 type Constraint = ();
6221
6222 fn validate(
6223 _: ::fidl_next::Slot<'_, Self>,
6224 _: Self::Constraint,
6225 ) -> Result<(), ::fidl_next::ValidationError> {
6226 Ok(())
6227 }
6228 }
6229
6230 unsafe impl ::fidl_next::Wire for CapabilityStoreDropResponse {
6231 type Narrowed<'de> = CapabilityStoreDropResponse;
6232
6233 #[inline]
6234 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6235 ::fidl_next::munge! {
6236 let Self {
6237
6238 _empty,
6239
6240
6241 } = &mut *out_;
6242 }
6243 }
6244 }
6245
6246 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropResponse
6247 where
6248 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6249 {
6250 fn decode(
6251 slot_: ::fidl_next::Slot<'_, Self>,
6252 decoder_: &mut ___D,
6253 _: (),
6254 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6255 ::fidl_next::munge! {
6256 let Self {
6257
6258 mut _empty,
6259
6260
6261 } = slot_;
6262 }
6263
6264 if _empty.as_bytes() != &[0u8] {
6265 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6266 }
6267
6268 Ok(())
6269 }
6270 }
6271
6272 impl ::fidl_next::IntoNatural for CapabilityStoreDropResponse {
6273 type Natural = crate::natural::CapabilityStoreDropResponse;
6274 }
6275
6276 #[derive(Clone, Debug)]
6278 #[repr(C)]
6279 pub struct CapabilityStoreExportRequest {
6280 pub id: ::fidl_next::wire::Uint64,
6281 }
6282
6283 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreExportRequest>(), 8);
6284 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreExportRequest>(), 8);
6285
6286 static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreExportRequest, id), 0);
6287
6288 impl ::fidl_next::Constrained for CapabilityStoreExportRequest {
6289 type Constraint = ();
6290
6291 fn validate(
6292 _: ::fidl_next::Slot<'_, Self>,
6293 _: Self::Constraint,
6294 ) -> Result<(), ::fidl_next::ValidationError> {
6295 Ok(())
6296 }
6297 }
6298
6299 unsafe impl ::fidl_next::Wire for CapabilityStoreExportRequest {
6300 type Narrowed<'de> = CapabilityStoreExportRequest;
6301
6302 #[inline]
6303 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6304 ::fidl_next::munge! {
6305 let Self {
6306
6307 id,
6308
6309 } = &mut *out_;
6310 }
6311
6312 ::fidl_next::Wire::zero_padding(id);
6313 }
6314 }
6315
6316 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportRequest
6317 where
6318 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6319 {
6320 fn decode(
6321 slot_: ::fidl_next::Slot<'_, Self>,
6322 decoder_: &mut ___D,
6323 _: (),
6324 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6325 ::fidl_next::munge! {
6326 let Self {
6327
6328 mut id,
6329
6330 } = slot_;
6331 }
6332
6333 let _field = id.as_mut();
6334
6335 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
6336
6337 Ok(())
6338 }
6339 }
6340
6341 impl ::fidl_next::IntoNatural for CapabilityStoreExportRequest {
6342 type Natural = crate::natural::CapabilityStoreExportRequest;
6343 }
6344
6345 #[derive(Clone, Debug)]
6347 #[repr(C)]
6348 pub struct CapabilityStoreImportResponse {
6349 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6350 }
6351
6352 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreImportResponse>(), 1);
6353 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreImportResponse>(), 1);
6354
6355 impl ::fidl_next::Constrained for CapabilityStoreImportResponse {
6356 type Constraint = ();
6357
6358 fn validate(
6359 _: ::fidl_next::Slot<'_, Self>,
6360 _: Self::Constraint,
6361 ) -> Result<(), ::fidl_next::ValidationError> {
6362 Ok(())
6363 }
6364 }
6365
6366 unsafe impl ::fidl_next::Wire for CapabilityStoreImportResponse {
6367 type Narrowed<'de> = CapabilityStoreImportResponse;
6368
6369 #[inline]
6370 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6371 ::fidl_next::munge! {
6372 let Self {
6373
6374 _empty,
6375
6376
6377 } = &mut *out_;
6378 }
6379 }
6380 }
6381
6382 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportResponse
6383 where
6384 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6385 {
6386 fn decode(
6387 slot_: ::fidl_next::Slot<'_, Self>,
6388 decoder_: &mut ___D,
6389 _: (),
6390 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6391 ::fidl_next::munge! {
6392 let Self {
6393
6394 mut _empty,
6395
6396
6397 } = slot_;
6398 }
6399
6400 if _empty.as_bytes() != &[0u8] {
6401 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6402 }
6403
6404 Ok(())
6405 }
6406 }
6407
6408 impl ::fidl_next::IntoNatural for CapabilityStoreImportResponse {
6409 type Natural = crate::natural::CapabilityStoreImportResponse;
6410 }
6411
6412 #[derive(Clone, Debug)]
6414 #[repr(C)]
6415 pub struct CapabilityStoreConnectorCreateResponse {
6416 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6417 }
6418
6419 static_assertions::const_assert_eq!(
6420 std::mem::size_of::<CapabilityStoreConnectorCreateResponse>(),
6421 1
6422 );
6423 static_assertions::const_assert_eq!(
6424 std::mem::align_of::<CapabilityStoreConnectorCreateResponse>(),
6425 1
6426 );
6427
6428 impl ::fidl_next::Constrained for CapabilityStoreConnectorCreateResponse {
6429 type Constraint = ();
6430
6431 fn validate(
6432 _: ::fidl_next::Slot<'_, Self>,
6433 _: Self::Constraint,
6434 ) -> Result<(), ::fidl_next::ValidationError> {
6435 Ok(())
6436 }
6437 }
6438
6439 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateResponse {
6440 type Narrowed<'de> = CapabilityStoreConnectorCreateResponse;
6441
6442 #[inline]
6443 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6444 ::fidl_next::munge! {
6445 let Self {
6446
6447 _empty,
6448
6449
6450 } = &mut *out_;
6451 }
6452 }
6453 }
6454
6455 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateResponse
6456 where
6457 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6458 {
6459 fn decode(
6460 slot_: ::fidl_next::Slot<'_, Self>,
6461 decoder_: &mut ___D,
6462 _: (),
6463 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6464 ::fidl_next::munge! {
6465 let Self {
6466
6467 mut _empty,
6468
6469
6470 } = slot_;
6471 }
6472
6473 if _empty.as_bytes() != &[0u8] {
6474 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6475 }
6476
6477 Ok(())
6478 }
6479 }
6480
6481 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateResponse {
6482 type Natural = crate::natural::CapabilityStoreConnectorCreateResponse;
6483 }
6484
6485 #[derive(Clone, Debug)]
6487 #[repr(C)]
6488 pub struct CapabilityStoreConnectorOpenResponse {
6489 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6490 }
6491
6492 static_assertions::const_assert_eq!(
6493 std::mem::size_of::<CapabilityStoreConnectorOpenResponse>(),
6494 1
6495 );
6496 static_assertions::const_assert_eq!(
6497 std::mem::align_of::<CapabilityStoreConnectorOpenResponse>(),
6498 1
6499 );
6500
6501 impl ::fidl_next::Constrained for CapabilityStoreConnectorOpenResponse {
6502 type Constraint = ();
6503
6504 fn validate(
6505 _: ::fidl_next::Slot<'_, Self>,
6506 _: Self::Constraint,
6507 ) -> Result<(), ::fidl_next::ValidationError> {
6508 Ok(())
6509 }
6510 }
6511
6512 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenResponse {
6513 type Narrowed<'de> = CapabilityStoreConnectorOpenResponse;
6514
6515 #[inline]
6516 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6517 ::fidl_next::munge! {
6518 let Self {
6519
6520 _empty,
6521
6522
6523 } = &mut *out_;
6524 }
6525 }
6526 }
6527
6528 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenResponse
6529 where
6530 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6531 {
6532 fn decode(
6533 slot_: ::fidl_next::Slot<'_, Self>,
6534 decoder_: &mut ___D,
6535 _: (),
6536 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6537 ::fidl_next::munge! {
6538 let Self {
6539
6540 mut _empty,
6541
6542
6543 } = slot_;
6544 }
6545
6546 if _empty.as_bytes() != &[0u8] {
6547 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6548 }
6549
6550 Ok(())
6551 }
6552 }
6553
6554 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenResponse {
6555 type Natural = crate::natural::CapabilityStoreConnectorOpenResponse;
6556 }
6557
6558 #[derive(Clone, Debug)]
6560 #[repr(C)]
6561 pub struct CapabilityStoreDirConnectorCreateResponse {
6562 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6563 }
6564
6565 static_assertions::const_assert_eq!(
6566 std::mem::size_of::<CapabilityStoreDirConnectorCreateResponse>(),
6567 1
6568 );
6569 static_assertions::const_assert_eq!(
6570 std::mem::align_of::<CapabilityStoreDirConnectorCreateResponse>(),
6571 1
6572 );
6573
6574 impl ::fidl_next::Constrained for CapabilityStoreDirConnectorCreateResponse {
6575 type Constraint = ();
6576
6577 fn validate(
6578 _: ::fidl_next::Slot<'_, Self>,
6579 _: Self::Constraint,
6580 ) -> Result<(), ::fidl_next::ValidationError> {
6581 Ok(())
6582 }
6583 }
6584
6585 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateResponse {
6586 type Narrowed<'de> = CapabilityStoreDirConnectorCreateResponse;
6587
6588 #[inline]
6589 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6590 ::fidl_next::munge! {
6591 let Self {
6592
6593 _empty,
6594
6595
6596 } = &mut *out_;
6597 }
6598 }
6599 }
6600
6601 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateResponse
6602 where
6603 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6604 {
6605 fn decode(
6606 slot_: ::fidl_next::Slot<'_, Self>,
6607 decoder_: &mut ___D,
6608 _: (),
6609 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6610 ::fidl_next::munge! {
6611 let Self {
6612
6613 mut _empty,
6614
6615
6616 } = slot_;
6617 }
6618
6619 if _empty.as_bytes() != &[0u8] {
6620 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6621 }
6622
6623 Ok(())
6624 }
6625 }
6626
6627 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateResponse {
6628 type Natural = crate::natural::CapabilityStoreDirConnectorCreateResponse;
6629 }
6630
6631 #[derive(Clone, Debug)]
6633 #[repr(C)]
6634 pub struct CapabilityStoreDirConnectorOpenResponse {
6635 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6636 }
6637
6638 static_assertions::const_assert_eq!(
6639 std::mem::size_of::<CapabilityStoreDirConnectorOpenResponse>(),
6640 1
6641 );
6642 static_assertions::const_assert_eq!(
6643 std::mem::align_of::<CapabilityStoreDirConnectorOpenResponse>(),
6644 1
6645 );
6646
6647 impl ::fidl_next::Constrained for CapabilityStoreDirConnectorOpenResponse {
6648 type Constraint = ();
6649
6650 fn validate(
6651 _: ::fidl_next::Slot<'_, Self>,
6652 _: Self::Constraint,
6653 ) -> Result<(), ::fidl_next::ValidationError> {
6654 Ok(())
6655 }
6656 }
6657
6658 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenResponse {
6659 type Narrowed<'de> = CapabilityStoreDirConnectorOpenResponse;
6660
6661 #[inline]
6662 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6663 ::fidl_next::munge! {
6664 let Self {
6665
6666 _empty,
6667
6668
6669 } = &mut *out_;
6670 }
6671 }
6672 }
6673
6674 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenResponse
6675 where
6676 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6677 {
6678 fn decode(
6679 slot_: ::fidl_next::Slot<'_, Self>,
6680 decoder_: &mut ___D,
6681 _: (),
6682 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6683 ::fidl_next::munge! {
6684 let Self {
6685
6686 mut _empty,
6687
6688
6689 } = slot_;
6690 }
6691
6692 if _empty.as_bytes() != &[0u8] {
6693 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6694 }
6695
6696 Ok(())
6697 }
6698 }
6699
6700 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenResponse {
6701 type Natural = crate::natural::CapabilityStoreDirConnectorOpenResponse;
6702 }
6703
6704 #[derive(Clone, Debug)]
6706 #[repr(C)]
6707 pub struct CapabilityStoreDictionaryCreateRequest {
6708 pub id: ::fidl_next::wire::Uint64,
6709 }
6710
6711 static_assertions::const_assert_eq!(
6712 std::mem::size_of::<CapabilityStoreDictionaryCreateRequest>(),
6713 8
6714 );
6715 static_assertions::const_assert_eq!(
6716 std::mem::align_of::<CapabilityStoreDictionaryCreateRequest>(),
6717 8
6718 );
6719
6720 static_assertions::const_assert_eq!(
6721 std::mem::offset_of!(CapabilityStoreDictionaryCreateRequest, id),
6722 0
6723 );
6724
6725 impl ::fidl_next::Constrained for CapabilityStoreDictionaryCreateRequest {
6726 type Constraint = ();
6727
6728 fn validate(
6729 _: ::fidl_next::Slot<'_, Self>,
6730 _: Self::Constraint,
6731 ) -> Result<(), ::fidl_next::ValidationError> {
6732 Ok(())
6733 }
6734 }
6735
6736 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateRequest {
6737 type Narrowed<'de> = CapabilityStoreDictionaryCreateRequest;
6738
6739 #[inline]
6740 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6741 ::fidl_next::munge! {
6742 let Self {
6743
6744 id,
6745
6746 } = &mut *out_;
6747 }
6748
6749 ::fidl_next::Wire::zero_padding(id);
6750 }
6751 }
6752
6753 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateRequest
6754 where
6755 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6756 {
6757 fn decode(
6758 slot_: ::fidl_next::Slot<'_, Self>,
6759 decoder_: &mut ___D,
6760 _: (),
6761 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6762 ::fidl_next::munge! {
6763 let Self {
6764
6765 mut id,
6766
6767 } = slot_;
6768 }
6769
6770 let _field = id.as_mut();
6771
6772 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
6773
6774 Ok(())
6775 }
6776 }
6777
6778 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateRequest {
6779 type Natural = crate::natural::CapabilityStoreDictionaryCreateRequest;
6780 }
6781
6782 #[derive(Clone, Debug)]
6784 #[repr(C)]
6785 pub struct CapabilityStoreDictionaryCreateResponse {
6786 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6787 }
6788
6789 static_assertions::const_assert_eq!(
6790 std::mem::size_of::<CapabilityStoreDictionaryCreateResponse>(),
6791 1
6792 );
6793 static_assertions::const_assert_eq!(
6794 std::mem::align_of::<CapabilityStoreDictionaryCreateResponse>(),
6795 1
6796 );
6797
6798 impl ::fidl_next::Constrained for CapabilityStoreDictionaryCreateResponse {
6799 type Constraint = ();
6800
6801 fn validate(
6802 _: ::fidl_next::Slot<'_, Self>,
6803 _: Self::Constraint,
6804 ) -> Result<(), ::fidl_next::ValidationError> {
6805 Ok(())
6806 }
6807 }
6808
6809 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateResponse {
6810 type Narrowed<'de> = CapabilityStoreDictionaryCreateResponse;
6811
6812 #[inline]
6813 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6814 ::fidl_next::munge! {
6815 let Self {
6816
6817 _empty,
6818
6819
6820 } = &mut *out_;
6821 }
6822 }
6823 }
6824
6825 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateResponse
6826 where
6827 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6828 {
6829 fn decode(
6830 slot_: ::fidl_next::Slot<'_, Self>,
6831 decoder_: &mut ___D,
6832 _: (),
6833 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6834 ::fidl_next::munge! {
6835 let Self {
6836
6837 mut _empty,
6838
6839
6840 } = slot_;
6841 }
6842
6843 if _empty.as_bytes() != &[0u8] {
6844 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6845 }
6846
6847 Ok(())
6848 }
6849 }
6850
6851 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateResponse {
6852 type Natural = crate::natural::CapabilityStoreDictionaryCreateResponse;
6853 }
6854
6855 #[derive(Clone, Debug)]
6857 #[repr(C)]
6858 pub struct CapabilityStoreDictionaryLegacyImportResponse {
6859 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6860 }
6861
6862 static_assertions::const_assert_eq!(
6863 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportResponse>(),
6864 1
6865 );
6866 static_assertions::const_assert_eq!(
6867 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportResponse>(),
6868 1
6869 );
6870
6871 impl ::fidl_next::Constrained for CapabilityStoreDictionaryLegacyImportResponse {
6872 type Constraint = ();
6873
6874 fn validate(
6875 _: ::fidl_next::Slot<'_, Self>,
6876 _: Self::Constraint,
6877 ) -> Result<(), ::fidl_next::ValidationError> {
6878 Ok(())
6879 }
6880 }
6881
6882 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportResponse {
6883 type Narrowed<'de> = CapabilityStoreDictionaryLegacyImportResponse;
6884
6885 #[inline]
6886 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6887 ::fidl_next::munge! {
6888 let Self {
6889
6890 _empty,
6891
6892
6893 } = &mut *out_;
6894 }
6895 }
6896 }
6897
6898 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportResponse
6899 where
6900 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6901 {
6902 fn decode(
6903 slot_: ::fidl_next::Slot<'_, Self>,
6904 decoder_: &mut ___D,
6905 _: (),
6906 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6907 ::fidl_next::munge! {
6908 let Self {
6909
6910 mut _empty,
6911
6912
6913 } = slot_;
6914 }
6915
6916 if _empty.as_bytes() != &[0u8] {
6917 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6918 }
6919
6920 Ok(())
6921 }
6922 }
6923
6924 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportResponse {
6925 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
6926 }
6927
6928 #[derive(Clone, Debug)]
6930 #[repr(C)]
6931 pub struct CapabilityStoreDictionaryLegacyExportResponse {
6932 pub(crate) _empty: fidl_next::wire::EmptyStruct,
6933 }
6934
6935 static_assertions::const_assert_eq!(
6936 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportResponse>(),
6937 1
6938 );
6939 static_assertions::const_assert_eq!(
6940 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportResponse>(),
6941 1
6942 );
6943
6944 impl ::fidl_next::Constrained for CapabilityStoreDictionaryLegacyExportResponse {
6945 type Constraint = ();
6946
6947 fn validate(
6948 _: ::fidl_next::Slot<'_, Self>,
6949 _: Self::Constraint,
6950 ) -> Result<(), ::fidl_next::ValidationError> {
6951 Ok(())
6952 }
6953 }
6954
6955 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportResponse {
6956 type Narrowed<'de> = CapabilityStoreDictionaryLegacyExportResponse;
6957
6958 #[inline]
6959 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6960 ::fidl_next::munge! {
6961 let Self {
6962
6963 _empty,
6964
6965
6966 } = &mut *out_;
6967 }
6968 }
6969 }
6970
6971 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportResponse
6972 where
6973 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6974 {
6975 fn decode(
6976 slot_: ::fidl_next::Slot<'_, Self>,
6977 decoder_: &mut ___D,
6978 _: (),
6979 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6980 ::fidl_next::munge! {
6981 let Self {
6982
6983 mut _empty,
6984
6985
6986 } = slot_;
6987 }
6988
6989 if _empty.as_bytes() != &[0u8] {
6990 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
6991 }
6992
6993 Ok(())
6994 }
6995 }
6996
6997 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportResponse {
6998 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
6999 }
7000
7001 pub type DictionaryKey<'de> = ::fidl_next::wire::String<'de>;
7003
7004 #[derive(Debug)]
7006 #[repr(C)]
7007 pub struct DictionaryItem<'de> {
7008 pub key: ::fidl_next::wire::String<'de>,
7009
7010 pub value: ::fidl_next::wire::Uint64,
7011 }
7012
7013 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryItem<'_>>(), 24);
7014 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryItem<'_>>(), 8);
7015
7016 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, key), 0);
7017
7018 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, value), 16);
7019
7020 impl ::fidl_next::Constrained for DictionaryItem<'_> {
7021 type Constraint = ();
7022
7023 fn validate(
7024 _: ::fidl_next::Slot<'_, Self>,
7025 _: Self::Constraint,
7026 ) -> Result<(), ::fidl_next::ValidationError> {
7027 Ok(())
7028 }
7029 }
7030
7031 unsafe impl ::fidl_next::Wire for DictionaryItem<'static> {
7032 type Narrowed<'de> = DictionaryItem<'de>;
7033
7034 #[inline]
7035 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7036 ::fidl_next::munge! {
7037 let Self {
7038
7039 key,
7040 value,
7041
7042 } = &mut *out_;
7043 }
7044
7045 ::fidl_next::Wire::zero_padding(key);
7046
7047 ::fidl_next::Wire::zero_padding(value);
7048 }
7049 }
7050
7051 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryItem<'de>
7052 where
7053 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7054 ___D: ::fidl_next::Decoder<'de>,
7055 {
7056 fn decode(
7057 slot_: ::fidl_next::Slot<'_, Self>,
7058 decoder_: &mut ___D,
7059 _: (),
7060 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7061 ::fidl_next::munge! {
7062 let Self {
7063
7064 mut key,
7065 mut value,
7066
7067 } = slot_;
7068 }
7069
7070 let _field = key.as_mut();
7071 ::fidl_next::Constrained::validate(_field, 255)?;
7072 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
7073
7074 let key = unsafe { key.deref_unchecked() };
7075
7076 if key.len() > 255 {
7077 return Err(::fidl_next::DecodeError::VectorTooLong {
7078 size: key.len() as u64,
7079 limit: 255,
7080 });
7081 }
7082
7083 let _field = value.as_mut();
7084
7085 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
7086
7087 Ok(())
7088 }
7089 }
7090
7091 impl<'de> ::fidl_next::IntoNatural for DictionaryItem<'de> {
7092 type Natural = crate::natural::DictionaryItem;
7093 }
7094
7095 #[derive(Debug)]
7097 #[repr(C)]
7098 pub struct CapabilityStoreDictionaryInsertRequest<'de> {
7099 pub id: ::fidl_next::wire::Uint64,
7100
7101 pub item: crate::wire::DictionaryItem<'de>,
7102 }
7103
7104 static_assertions::const_assert_eq!(
7105 std::mem::size_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
7106 32
7107 );
7108 static_assertions::const_assert_eq!(
7109 std::mem::align_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
7110 8
7111 );
7112
7113 static_assertions::const_assert_eq!(
7114 std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, id),
7115 0
7116 );
7117
7118 static_assertions::const_assert_eq!(
7119 std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, item),
7120 8
7121 );
7122
7123 impl ::fidl_next::Constrained for CapabilityStoreDictionaryInsertRequest<'_> {
7124 type Constraint = ();
7125
7126 fn validate(
7127 _: ::fidl_next::Slot<'_, Self>,
7128 _: Self::Constraint,
7129 ) -> Result<(), ::fidl_next::ValidationError> {
7130 Ok(())
7131 }
7132 }
7133
7134 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertRequest<'static> {
7135 type Narrowed<'de> = CapabilityStoreDictionaryInsertRequest<'de>;
7136
7137 #[inline]
7138 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7139 ::fidl_next::munge! {
7140 let Self {
7141
7142 id,
7143 item,
7144
7145 } = &mut *out_;
7146 }
7147
7148 ::fidl_next::Wire::zero_padding(id);
7149
7150 ::fidl_next::Wire::zero_padding(item);
7151 }
7152 }
7153
7154 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertRequest<'de>
7155 where
7156 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7157 ___D: ::fidl_next::Decoder<'de>,
7158 {
7159 fn decode(
7160 slot_: ::fidl_next::Slot<'_, Self>,
7161 decoder_: &mut ___D,
7162 _: (),
7163 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7164 ::fidl_next::munge! {
7165 let Self {
7166
7167 mut id,
7168 mut item,
7169
7170 } = slot_;
7171 }
7172
7173 let _field = id.as_mut();
7174
7175 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7176
7177 let _field = item.as_mut();
7178
7179 ::fidl_next::Decode::decode(item.as_mut(), decoder_, ())?;
7180
7181 Ok(())
7182 }
7183 }
7184
7185 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertRequest<'de> {
7186 type Natural = crate::natural::CapabilityStoreDictionaryInsertRequest;
7187 }
7188
7189 #[derive(Clone, Debug)]
7191 #[repr(C)]
7192 pub struct CapabilityStoreDictionaryInsertResponse {
7193 pub(crate) _empty: fidl_next::wire::EmptyStruct,
7194 }
7195
7196 static_assertions::const_assert_eq!(
7197 std::mem::size_of::<CapabilityStoreDictionaryInsertResponse>(),
7198 1
7199 );
7200 static_assertions::const_assert_eq!(
7201 std::mem::align_of::<CapabilityStoreDictionaryInsertResponse>(),
7202 1
7203 );
7204
7205 impl ::fidl_next::Constrained for CapabilityStoreDictionaryInsertResponse {
7206 type Constraint = ();
7207
7208 fn validate(
7209 _: ::fidl_next::Slot<'_, Self>,
7210 _: Self::Constraint,
7211 ) -> Result<(), ::fidl_next::ValidationError> {
7212 Ok(())
7213 }
7214 }
7215
7216 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertResponse {
7217 type Narrowed<'de> = CapabilityStoreDictionaryInsertResponse;
7218
7219 #[inline]
7220 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7221 ::fidl_next::munge! {
7222 let Self {
7223
7224 _empty,
7225
7226
7227 } = &mut *out_;
7228 }
7229 }
7230 }
7231
7232 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertResponse
7233 where
7234 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7235 {
7236 fn decode(
7237 slot_: ::fidl_next::Slot<'_, Self>,
7238 decoder_: &mut ___D,
7239 _: (),
7240 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7241 ::fidl_next::munge! {
7242 let Self {
7243
7244 mut _empty,
7245
7246
7247 } = slot_;
7248 }
7249
7250 if _empty.as_bytes() != &[0u8] {
7251 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
7252 }
7253
7254 Ok(())
7255 }
7256 }
7257
7258 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertResponse {
7259 type Natural = crate::natural::CapabilityStoreDictionaryInsertResponse;
7260 }
7261
7262 #[derive(Debug)]
7264 #[repr(C)]
7265 pub struct CapabilityStoreDictionaryGetRequest<'de> {
7266 pub id: ::fidl_next::wire::Uint64,
7267
7268 pub key: ::fidl_next::wire::String<'de>,
7269
7270 pub dest_id: ::fidl_next::wire::Uint64,
7271 }
7272
7273 static_assertions::const_assert_eq!(
7274 std::mem::size_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
7275 32
7276 );
7277 static_assertions::const_assert_eq!(
7278 std::mem::align_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
7279 8
7280 );
7281
7282 static_assertions::const_assert_eq!(
7283 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, id),
7284 0
7285 );
7286
7287 static_assertions::const_assert_eq!(
7288 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, key),
7289 8
7290 );
7291
7292 static_assertions::const_assert_eq!(
7293 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, dest_id),
7294 24
7295 );
7296
7297 impl ::fidl_next::Constrained for CapabilityStoreDictionaryGetRequest<'_> {
7298 type Constraint = ();
7299
7300 fn validate(
7301 _: ::fidl_next::Slot<'_, Self>,
7302 _: Self::Constraint,
7303 ) -> Result<(), ::fidl_next::ValidationError> {
7304 Ok(())
7305 }
7306 }
7307
7308 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetRequest<'static> {
7309 type Narrowed<'de> = CapabilityStoreDictionaryGetRequest<'de>;
7310
7311 #[inline]
7312 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7313 ::fidl_next::munge! {
7314 let Self {
7315
7316 id,
7317 key,
7318 dest_id,
7319
7320 } = &mut *out_;
7321 }
7322
7323 ::fidl_next::Wire::zero_padding(id);
7324
7325 ::fidl_next::Wire::zero_padding(key);
7326
7327 ::fidl_next::Wire::zero_padding(dest_id);
7328 }
7329 }
7330
7331 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetRequest<'de>
7332 where
7333 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7334 ___D: ::fidl_next::Decoder<'de>,
7335 {
7336 fn decode(
7337 slot_: ::fidl_next::Slot<'_, Self>,
7338 decoder_: &mut ___D,
7339 _: (),
7340 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7341 ::fidl_next::munge! {
7342 let Self {
7343
7344 mut id,
7345 mut key,
7346 mut dest_id,
7347
7348 } = slot_;
7349 }
7350
7351 let _field = id.as_mut();
7352
7353 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7354
7355 let _field = key.as_mut();
7356 ::fidl_next::Constrained::validate(_field, 255)?;
7357 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
7358
7359 let key = unsafe { key.deref_unchecked() };
7360
7361 if key.len() > 255 {
7362 return Err(::fidl_next::DecodeError::VectorTooLong {
7363 size: key.len() as u64,
7364 limit: 255,
7365 });
7366 }
7367
7368 let _field = dest_id.as_mut();
7369
7370 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
7371
7372 Ok(())
7373 }
7374 }
7375
7376 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetRequest<'de> {
7377 type Natural = crate::natural::CapabilityStoreDictionaryGetRequest;
7378 }
7379
7380 #[derive(Clone, Debug)]
7382 #[repr(C)]
7383 pub struct CapabilityStoreDictionaryGetResponse {
7384 pub(crate) _empty: fidl_next::wire::EmptyStruct,
7385 }
7386
7387 static_assertions::const_assert_eq!(
7388 std::mem::size_of::<CapabilityStoreDictionaryGetResponse>(),
7389 1
7390 );
7391 static_assertions::const_assert_eq!(
7392 std::mem::align_of::<CapabilityStoreDictionaryGetResponse>(),
7393 1
7394 );
7395
7396 impl ::fidl_next::Constrained for CapabilityStoreDictionaryGetResponse {
7397 type Constraint = ();
7398
7399 fn validate(
7400 _: ::fidl_next::Slot<'_, Self>,
7401 _: Self::Constraint,
7402 ) -> Result<(), ::fidl_next::ValidationError> {
7403 Ok(())
7404 }
7405 }
7406
7407 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetResponse {
7408 type Narrowed<'de> = CapabilityStoreDictionaryGetResponse;
7409
7410 #[inline]
7411 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7412 ::fidl_next::munge! {
7413 let Self {
7414
7415 _empty,
7416
7417
7418 } = &mut *out_;
7419 }
7420 }
7421 }
7422
7423 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetResponse
7424 where
7425 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7426 {
7427 fn decode(
7428 slot_: ::fidl_next::Slot<'_, Self>,
7429 decoder_: &mut ___D,
7430 _: (),
7431 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7432 ::fidl_next::munge! {
7433 let Self {
7434
7435 mut _empty,
7436
7437
7438 } = slot_;
7439 }
7440
7441 if _empty.as_bytes() != &[0u8] {
7442 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
7443 }
7444
7445 Ok(())
7446 }
7447 }
7448
7449 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetResponse {
7450 type Natural = crate::natural::CapabilityStoreDictionaryGetResponse;
7451 }
7452
7453 #[derive(Clone, Debug)]
7455 #[repr(C)]
7456 pub struct WrappedCapabilityId {
7457 pub id: ::fidl_next::wire::Uint64,
7458 }
7459
7460 static_assertions::const_assert_eq!(std::mem::size_of::<WrappedCapabilityId>(), 8);
7461 static_assertions::const_assert_eq!(std::mem::align_of::<WrappedCapabilityId>(), 8);
7462
7463 static_assertions::const_assert_eq!(std::mem::offset_of!(WrappedCapabilityId, id), 0);
7464
7465 impl ::fidl_next::Constrained for WrappedCapabilityId {
7466 type Constraint = ();
7467
7468 fn validate(
7469 _: ::fidl_next::Slot<'_, Self>,
7470 _: Self::Constraint,
7471 ) -> Result<(), ::fidl_next::ValidationError> {
7472 Ok(())
7473 }
7474 }
7475
7476 unsafe impl ::fidl_next::Wire for WrappedCapabilityId {
7477 type Narrowed<'de> = WrappedCapabilityId;
7478
7479 #[inline]
7480 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7481 ::fidl_next::munge! {
7482 let Self {
7483
7484 id,
7485
7486 } = &mut *out_;
7487 }
7488
7489 ::fidl_next::Wire::zero_padding(id);
7490 }
7491 }
7492
7493 unsafe impl<___D> ::fidl_next::Decode<___D> for WrappedCapabilityId
7494 where
7495 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7496 {
7497 fn decode(
7498 slot_: ::fidl_next::Slot<'_, Self>,
7499 decoder_: &mut ___D,
7500 _: (),
7501 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7502 ::fidl_next::munge! {
7503 let Self {
7504
7505 mut id,
7506
7507 } = slot_;
7508 }
7509
7510 let _field = id.as_mut();
7511
7512 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7513
7514 Ok(())
7515 }
7516 }
7517
7518 impl ::fidl_next::IntoNatural for WrappedCapabilityId {
7519 type Natural = crate::natural::WrappedCapabilityId;
7520 }
7521
7522 pub type WrappedNewCapabilityId = crate::wire::WrappedCapabilityId;
7524
7525 #[derive(Debug)]
7527 #[repr(C)]
7528 pub struct CapabilityStoreDictionaryRemoveRequest<'de> {
7529 pub id: ::fidl_next::wire::Uint64,
7530
7531 pub key: ::fidl_next::wire::String<'de>,
7532
7533 pub dest_id: ::fidl_next::wire::Box<'de, crate::wire::WrappedCapabilityId>,
7534 }
7535
7536 static_assertions::const_assert_eq!(
7537 std::mem::size_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
7538 32
7539 );
7540 static_assertions::const_assert_eq!(
7541 std::mem::align_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
7542 8
7543 );
7544
7545 static_assertions::const_assert_eq!(
7546 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, id),
7547 0
7548 );
7549
7550 static_assertions::const_assert_eq!(
7551 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, key),
7552 8
7553 );
7554
7555 static_assertions::const_assert_eq!(
7556 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, dest_id),
7557 24
7558 );
7559
7560 impl ::fidl_next::Constrained for CapabilityStoreDictionaryRemoveRequest<'_> {
7561 type Constraint = ();
7562
7563 fn validate(
7564 _: ::fidl_next::Slot<'_, Self>,
7565 _: Self::Constraint,
7566 ) -> Result<(), ::fidl_next::ValidationError> {
7567 Ok(())
7568 }
7569 }
7570
7571 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveRequest<'static> {
7572 type Narrowed<'de> = CapabilityStoreDictionaryRemoveRequest<'de>;
7573
7574 #[inline]
7575 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7576 ::fidl_next::munge! {
7577 let Self {
7578
7579 id,
7580 key,
7581 dest_id,
7582
7583 } = &mut *out_;
7584 }
7585
7586 ::fidl_next::Wire::zero_padding(id);
7587
7588 ::fidl_next::Wire::zero_padding(key);
7589
7590 ::fidl_next::Wire::zero_padding(dest_id);
7591 }
7592 }
7593
7594 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveRequest<'de>
7595 where
7596 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7597 ___D: ::fidl_next::Decoder<'de>,
7598 {
7599 fn decode(
7600 slot_: ::fidl_next::Slot<'_, Self>,
7601 decoder_: &mut ___D,
7602 _: (),
7603 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7604 ::fidl_next::munge! {
7605 let Self {
7606
7607 mut id,
7608 mut key,
7609 mut dest_id,
7610
7611 } = slot_;
7612 }
7613
7614 let _field = id.as_mut();
7615
7616 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7617
7618 let _field = key.as_mut();
7619 ::fidl_next::Constrained::validate(_field, 255)?;
7620 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
7621
7622 let key = unsafe { key.deref_unchecked() };
7623
7624 if key.len() > 255 {
7625 return Err(::fidl_next::DecodeError::VectorTooLong {
7626 size: key.len() as u64,
7627 limit: 255,
7628 });
7629 }
7630
7631 let _field = dest_id.as_mut();
7632
7633 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
7634
7635 Ok(())
7636 }
7637 }
7638
7639 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveRequest<'de> {
7640 type Natural = crate::natural::CapabilityStoreDictionaryRemoveRequest;
7641 }
7642
7643 #[derive(Clone, Debug)]
7645 #[repr(C)]
7646 pub struct CapabilityStoreDictionaryRemoveResponse {
7647 pub(crate) _empty: fidl_next::wire::EmptyStruct,
7648 }
7649
7650 static_assertions::const_assert_eq!(
7651 std::mem::size_of::<CapabilityStoreDictionaryRemoveResponse>(),
7652 1
7653 );
7654 static_assertions::const_assert_eq!(
7655 std::mem::align_of::<CapabilityStoreDictionaryRemoveResponse>(),
7656 1
7657 );
7658
7659 impl ::fidl_next::Constrained for CapabilityStoreDictionaryRemoveResponse {
7660 type Constraint = ();
7661
7662 fn validate(
7663 _: ::fidl_next::Slot<'_, Self>,
7664 _: Self::Constraint,
7665 ) -> Result<(), ::fidl_next::ValidationError> {
7666 Ok(())
7667 }
7668 }
7669
7670 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveResponse {
7671 type Narrowed<'de> = CapabilityStoreDictionaryRemoveResponse;
7672
7673 #[inline]
7674 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7675 ::fidl_next::munge! {
7676 let Self {
7677
7678 _empty,
7679
7680
7681 } = &mut *out_;
7682 }
7683 }
7684 }
7685
7686 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveResponse
7687 where
7688 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7689 {
7690 fn decode(
7691 slot_: ::fidl_next::Slot<'_, Self>,
7692 decoder_: &mut ___D,
7693 _: (),
7694 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7695 ::fidl_next::munge! {
7696 let Self {
7697
7698 mut _empty,
7699
7700
7701 } = slot_;
7702 }
7703
7704 if _empty.as_bytes() != &[0u8] {
7705 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
7706 }
7707
7708 Ok(())
7709 }
7710 }
7711
7712 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveResponse {
7713 type Natural = crate::natural::CapabilityStoreDictionaryRemoveResponse;
7714 }
7715
7716 #[derive(Clone, Debug)]
7718 #[repr(C)]
7719 pub struct CapabilityStoreDictionaryCopyRequest {
7720 pub id: ::fidl_next::wire::Uint64,
7721
7722 pub dest_id: ::fidl_next::wire::Uint64,
7723 }
7724
7725 static_assertions::const_assert_eq!(
7726 std::mem::size_of::<CapabilityStoreDictionaryCopyRequest>(),
7727 16
7728 );
7729 static_assertions::const_assert_eq!(
7730 std::mem::align_of::<CapabilityStoreDictionaryCopyRequest>(),
7731 8
7732 );
7733
7734 static_assertions::const_assert_eq!(
7735 std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, id),
7736 0
7737 );
7738
7739 static_assertions::const_assert_eq!(
7740 std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, dest_id),
7741 8
7742 );
7743
7744 impl ::fidl_next::Constrained for CapabilityStoreDictionaryCopyRequest {
7745 type Constraint = ();
7746
7747 fn validate(
7748 _: ::fidl_next::Slot<'_, Self>,
7749 _: Self::Constraint,
7750 ) -> Result<(), ::fidl_next::ValidationError> {
7751 Ok(())
7752 }
7753 }
7754
7755 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyRequest {
7756 type Narrowed<'de> = CapabilityStoreDictionaryCopyRequest;
7757
7758 #[inline]
7759 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7760 ::fidl_next::munge! {
7761 let Self {
7762
7763 id,
7764 dest_id,
7765
7766 } = &mut *out_;
7767 }
7768
7769 ::fidl_next::Wire::zero_padding(id);
7770
7771 ::fidl_next::Wire::zero_padding(dest_id);
7772 }
7773 }
7774
7775 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyRequest
7776 where
7777 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7778 {
7779 fn decode(
7780 slot_: ::fidl_next::Slot<'_, Self>,
7781 decoder_: &mut ___D,
7782 _: (),
7783 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7784 ::fidl_next::munge! {
7785 let Self {
7786
7787 mut id,
7788 mut dest_id,
7789
7790 } = slot_;
7791 }
7792
7793 let _field = id.as_mut();
7794
7795 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
7796
7797 let _field = dest_id.as_mut();
7798
7799 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
7800
7801 Ok(())
7802 }
7803 }
7804
7805 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyRequest {
7806 type Natural = crate::natural::CapabilityStoreDictionaryCopyRequest;
7807 }
7808
7809 #[derive(Clone, Debug)]
7811 #[repr(C)]
7812 pub struct CapabilityStoreDictionaryCopyResponse {
7813 pub(crate) _empty: fidl_next::wire::EmptyStruct,
7814 }
7815
7816 static_assertions::const_assert_eq!(
7817 std::mem::size_of::<CapabilityStoreDictionaryCopyResponse>(),
7818 1
7819 );
7820 static_assertions::const_assert_eq!(
7821 std::mem::align_of::<CapabilityStoreDictionaryCopyResponse>(),
7822 1
7823 );
7824
7825 impl ::fidl_next::Constrained for CapabilityStoreDictionaryCopyResponse {
7826 type Constraint = ();
7827
7828 fn validate(
7829 _: ::fidl_next::Slot<'_, Self>,
7830 _: Self::Constraint,
7831 ) -> Result<(), ::fidl_next::ValidationError> {
7832 Ok(())
7833 }
7834 }
7835
7836 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyResponse {
7837 type Narrowed<'de> = CapabilityStoreDictionaryCopyResponse;
7838
7839 #[inline]
7840 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7841 ::fidl_next::munge! {
7842 let Self {
7843
7844 _empty,
7845
7846
7847 } = &mut *out_;
7848 }
7849 }
7850 }
7851
7852 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyResponse
7853 where
7854 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7855 {
7856 fn decode(
7857 slot_: ::fidl_next::Slot<'_, Self>,
7858 decoder_: &mut ___D,
7859 _: (),
7860 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7861 ::fidl_next::munge! {
7862 let Self {
7863
7864 mut _empty,
7865
7866
7867 } = slot_;
7868 }
7869
7870 if _empty.as_bytes() != &[0u8] {
7871 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
7872 }
7873
7874 Ok(())
7875 }
7876 }
7877
7878 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyResponse {
7879 type Natural = crate::natural::CapabilityStoreDictionaryCopyResponse;
7880 }
7881
7882 #[derive(Clone, Debug)]
7884 #[repr(C)]
7885 pub struct CapabilityStoreDictionaryKeysResponse {
7886 pub(crate) _empty: fidl_next::wire::EmptyStruct,
7887 }
7888
7889 static_assertions::const_assert_eq!(
7890 std::mem::size_of::<CapabilityStoreDictionaryKeysResponse>(),
7891 1
7892 );
7893 static_assertions::const_assert_eq!(
7894 std::mem::align_of::<CapabilityStoreDictionaryKeysResponse>(),
7895 1
7896 );
7897
7898 impl ::fidl_next::Constrained for CapabilityStoreDictionaryKeysResponse {
7899 type Constraint = ();
7900
7901 fn validate(
7902 _: ::fidl_next::Slot<'_, Self>,
7903 _: Self::Constraint,
7904 ) -> Result<(), ::fidl_next::ValidationError> {
7905 Ok(())
7906 }
7907 }
7908
7909 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysResponse {
7910 type Narrowed<'de> = CapabilityStoreDictionaryKeysResponse;
7911
7912 #[inline]
7913 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7914 ::fidl_next::munge! {
7915 let Self {
7916
7917 _empty,
7918
7919
7920 } = &mut *out_;
7921 }
7922 }
7923 }
7924
7925 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysResponse
7926 where
7927 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7928 {
7929 fn decode(
7930 slot_: ::fidl_next::Slot<'_, Self>,
7931 decoder_: &mut ___D,
7932 _: (),
7933 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7934 ::fidl_next::munge! {
7935 let Self {
7936
7937 mut _empty,
7938
7939
7940 } = slot_;
7941 }
7942
7943 if _empty.as_bytes() != &[0u8] {
7944 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
7945 }
7946
7947 Ok(())
7948 }
7949 }
7950
7951 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysResponse {
7952 type Natural = crate::natural::CapabilityStoreDictionaryKeysResponse;
7953 }
7954
7955 #[derive(Clone, Debug)]
7957 #[repr(C)]
7958 pub struct CapabilityStoreDictionaryEnumerateResponse {
7959 pub(crate) _empty: fidl_next::wire::EmptyStruct,
7960 }
7961
7962 static_assertions::const_assert_eq!(
7963 std::mem::size_of::<CapabilityStoreDictionaryEnumerateResponse>(),
7964 1
7965 );
7966 static_assertions::const_assert_eq!(
7967 std::mem::align_of::<CapabilityStoreDictionaryEnumerateResponse>(),
7968 1
7969 );
7970
7971 impl ::fidl_next::Constrained for CapabilityStoreDictionaryEnumerateResponse {
7972 type Constraint = ();
7973
7974 fn validate(
7975 _: ::fidl_next::Slot<'_, Self>,
7976 _: Self::Constraint,
7977 ) -> Result<(), ::fidl_next::ValidationError> {
7978 Ok(())
7979 }
7980 }
7981
7982 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateResponse {
7983 type Narrowed<'de> = CapabilityStoreDictionaryEnumerateResponse;
7984
7985 #[inline]
7986 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7987 ::fidl_next::munge! {
7988 let Self {
7989
7990 _empty,
7991
7992
7993 } = &mut *out_;
7994 }
7995 }
7996 }
7997
7998 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateResponse
7999 where
8000 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8001 {
8002 fn decode(
8003 slot_: ::fidl_next::Slot<'_, Self>,
8004 decoder_: &mut ___D,
8005 _: (),
8006 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8007 ::fidl_next::munge! {
8008 let Self {
8009
8010 mut _empty,
8011
8012
8013 } = slot_;
8014 }
8015
8016 if _empty.as_bytes() != &[0u8] {
8017 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
8018 }
8019
8020 Ok(())
8021 }
8022 }
8023
8024 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateResponse {
8025 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateResponse;
8026 }
8027
8028 #[derive(Clone, Debug)]
8030 #[repr(C)]
8031 pub struct CapabilityStoreDictionaryDrainResponse {
8032 pub(crate) _empty: fidl_next::wire::EmptyStruct,
8033 }
8034
8035 static_assertions::const_assert_eq!(
8036 std::mem::size_of::<CapabilityStoreDictionaryDrainResponse>(),
8037 1
8038 );
8039 static_assertions::const_assert_eq!(
8040 std::mem::align_of::<CapabilityStoreDictionaryDrainResponse>(),
8041 1
8042 );
8043
8044 impl ::fidl_next::Constrained for CapabilityStoreDictionaryDrainResponse {
8045 type Constraint = ();
8046
8047 fn validate(
8048 _: ::fidl_next::Slot<'_, Self>,
8049 _: Self::Constraint,
8050 ) -> Result<(), ::fidl_next::ValidationError> {
8051 Ok(())
8052 }
8053 }
8054
8055 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainResponse {
8056 type Narrowed<'de> = CapabilityStoreDictionaryDrainResponse;
8057
8058 #[inline]
8059 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8060 ::fidl_next::munge! {
8061 let Self {
8062
8063 _empty,
8064
8065
8066 } = &mut *out_;
8067 }
8068 }
8069 }
8070
8071 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainResponse
8072 where
8073 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8074 {
8075 fn decode(
8076 slot_: ::fidl_next::Slot<'_, Self>,
8077 decoder_: &mut ___D,
8078 _: (),
8079 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8080 ::fidl_next::munge! {
8081 let Self {
8082
8083 mut _empty,
8084
8085
8086 } = slot_;
8087 }
8088
8089 if _empty.as_bytes() != &[0u8] {
8090 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
8091 }
8092
8093 Ok(())
8094 }
8095 }
8096
8097 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainResponse {
8098 type Natural = crate::natural::CapabilityStoreDictionaryDrainResponse;
8099 }
8100
8101 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8103 #[repr(transparent)]
8104 pub struct RouterError {
8105 pub(crate) value: ::fidl_next::wire::Uint32,
8106 }
8107
8108 impl ::fidl_next::Constrained for RouterError {
8109 type Constraint = ();
8110
8111 fn validate(
8112 _: ::fidl_next::Slot<'_, Self>,
8113 _: Self::Constraint,
8114 ) -> Result<(), ::fidl_next::ValidationError> {
8115 Ok(())
8116 }
8117 }
8118
8119 unsafe impl ::fidl_next::Wire for RouterError {
8120 type Narrowed<'de> = Self;
8121
8122 #[inline]
8123 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8124 }
8126 }
8127
8128 impl RouterError {
8129 pub const NOT_FOUND: RouterError = RouterError { value: ::fidl_next::wire::Uint32(1) };
8130
8131 pub const INVALID_ARGS: RouterError = RouterError { value: ::fidl_next::wire::Uint32(2) };
8132
8133 pub const NOT_SUPPORTED: RouterError = RouterError { value: ::fidl_next::wire::Uint32(3) };
8134
8135 pub const INTERNAL: RouterError = RouterError { value: ::fidl_next::wire::Uint32(4) };
8136 }
8137
8138 unsafe impl<___D> ::fidl_next::Decode<___D> for RouterError
8139 where
8140 ___D: ?Sized,
8141 {
8142 fn decode(
8143 slot: ::fidl_next::Slot<'_, Self>,
8144 _: &mut ___D,
8145 _: (),
8146 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8147 Ok(())
8148 }
8149 }
8150
8151 impl ::core::convert::From<crate::natural::RouterError> for RouterError {
8152 fn from(natural: crate::natural::RouterError) -> Self {
8153 match natural {
8154 crate::natural::RouterError::NotFound => RouterError::NOT_FOUND,
8155
8156 crate::natural::RouterError::InvalidArgs => RouterError::INVALID_ARGS,
8157
8158 crate::natural::RouterError::NotSupported => RouterError::NOT_SUPPORTED,
8159
8160 crate::natural::RouterError::Internal => RouterError::INTERNAL,
8161
8162 crate::natural::RouterError::UnknownOrdinal_(value) => {
8163 RouterError { value: ::fidl_next::wire::Uint32::from(value) }
8164 }
8165 }
8166 }
8167 }
8168
8169 impl ::fidl_next::IntoNatural for RouterError {
8170 type Natural = crate::natural::RouterError;
8171 }
8172
8173 #[derive(Clone, Debug)]
8175 #[repr(C)]
8176 pub struct DictionaryDrainIteratorGetNextRequest {
8177 pub start_id: ::fidl_next::wire::Uint64,
8178
8179 pub limit: ::fidl_next::wire::Uint32,
8180 }
8181
8182 static_assertions::const_assert_eq!(
8183 std::mem::size_of::<DictionaryDrainIteratorGetNextRequest>(),
8184 16
8185 );
8186 static_assertions::const_assert_eq!(
8187 std::mem::align_of::<DictionaryDrainIteratorGetNextRequest>(),
8188 8
8189 );
8190
8191 static_assertions::const_assert_eq!(
8192 std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, start_id),
8193 0
8194 );
8195
8196 static_assertions::const_assert_eq!(
8197 std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, limit),
8198 8
8199 );
8200
8201 impl ::fidl_next::Constrained for DictionaryDrainIteratorGetNextRequest {
8202 type Constraint = ();
8203
8204 fn validate(
8205 _: ::fidl_next::Slot<'_, Self>,
8206 _: Self::Constraint,
8207 ) -> Result<(), ::fidl_next::ValidationError> {
8208 Ok(())
8209 }
8210 }
8211
8212 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextRequest {
8213 type Narrowed<'de> = DictionaryDrainIteratorGetNextRequest;
8214
8215 #[inline]
8216 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8217 ::fidl_next::munge! {
8218 let Self {
8219
8220 start_id,
8221 limit,
8222
8223 } = &mut *out_;
8224 }
8225
8226 ::fidl_next::Wire::zero_padding(start_id);
8227
8228 ::fidl_next::Wire::zero_padding(limit);
8229
8230 unsafe {
8231 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
8232 }
8233 }
8234 }
8235
8236 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextRequest
8237 where
8238 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8239 {
8240 fn decode(
8241 slot_: ::fidl_next::Slot<'_, Self>,
8242 decoder_: &mut ___D,
8243 _: (),
8244 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8245 if slot_.as_bytes()[12..16] != [0u8; 4] {
8246 return Err(::fidl_next::DecodeError::InvalidPadding);
8247 }
8248
8249 ::fidl_next::munge! {
8250 let Self {
8251
8252 mut start_id,
8253 mut limit,
8254
8255 } = slot_;
8256 }
8257
8258 let _field = start_id.as_mut();
8259
8260 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
8261
8262 let _field = limit.as_mut();
8263
8264 ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
8265
8266 Ok(())
8267 }
8268 }
8269
8270 impl ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextRequest {
8271 type Natural = crate::natural::DictionaryDrainIteratorGetNextRequest;
8272 }
8273
8274 #[derive(Clone, Debug)]
8276 #[repr(C)]
8277 pub struct DictionaryEnumerateIteratorGetNextRequest {
8278 pub start_id: ::fidl_next::wire::Uint64,
8279
8280 pub limit: ::fidl_next::wire::Uint32,
8281 }
8282
8283 static_assertions::const_assert_eq!(
8284 std::mem::size_of::<DictionaryEnumerateIteratorGetNextRequest>(),
8285 16
8286 );
8287 static_assertions::const_assert_eq!(
8288 std::mem::align_of::<DictionaryEnumerateIteratorGetNextRequest>(),
8289 8
8290 );
8291
8292 static_assertions::const_assert_eq!(
8293 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, start_id),
8294 0
8295 );
8296
8297 static_assertions::const_assert_eq!(
8298 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, limit),
8299 8
8300 );
8301
8302 impl ::fidl_next::Constrained for DictionaryEnumerateIteratorGetNextRequest {
8303 type Constraint = ();
8304
8305 fn validate(
8306 _: ::fidl_next::Slot<'_, Self>,
8307 _: Self::Constraint,
8308 ) -> Result<(), ::fidl_next::ValidationError> {
8309 Ok(())
8310 }
8311 }
8312
8313 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextRequest {
8314 type Narrowed<'de> = DictionaryEnumerateIteratorGetNextRequest;
8315
8316 #[inline]
8317 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8318 ::fidl_next::munge! {
8319 let Self {
8320
8321 start_id,
8322 limit,
8323
8324 } = &mut *out_;
8325 }
8326
8327 ::fidl_next::Wire::zero_padding(start_id);
8328
8329 ::fidl_next::Wire::zero_padding(limit);
8330
8331 unsafe {
8332 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
8333 }
8334 }
8335 }
8336
8337 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextRequest
8338 where
8339 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8340 {
8341 fn decode(
8342 slot_: ::fidl_next::Slot<'_, Self>,
8343 decoder_: &mut ___D,
8344 _: (),
8345 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8346 if slot_.as_bytes()[12..16] != [0u8; 4] {
8347 return Err(::fidl_next::DecodeError::InvalidPadding);
8348 }
8349
8350 ::fidl_next::munge! {
8351 let Self {
8352
8353 mut start_id,
8354 mut limit,
8355
8356 } = slot_;
8357 }
8358
8359 let _field = start_id.as_mut();
8360
8361 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
8362
8363 let _field = limit.as_mut();
8364
8365 ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
8366
8367 Ok(())
8368 }
8369 }
8370
8371 impl ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextRequest {
8372 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextRequest;
8373 }
8374
8375 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8377 #[repr(transparent)]
8378 pub struct DictionaryError {
8379 pub(crate) value: ::fidl_next::wire::Uint32,
8380 }
8381
8382 impl ::fidl_next::Constrained for DictionaryError {
8383 type Constraint = ();
8384
8385 fn validate(
8386 _: ::fidl_next::Slot<'_, Self>,
8387 _: Self::Constraint,
8388 ) -> Result<(), ::fidl_next::ValidationError> {
8389 Ok(())
8390 }
8391 }
8392
8393 unsafe impl ::fidl_next::Wire for DictionaryError {
8394 type Narrowed<'de> = Self;
8395
8396 #[inline]
8397 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8398 }
8400 }
8401
8402 impl DictionaryError {
8403 pub const NOT_FOUND: DictionaryError =
8404 DictionaryError { value: ::fidl_next::wire::Uint32(1) };
8405
8406 pub const ALREADY_EXISTS: DictionaryError =
8407 DictionaryError { value: ::fidl_next::wire::Uint32(2) };
8408
8409 pub const BAD_CAPABILITY: DictionaryError =
8410 DictionaryError { value: ::fidl_next::wire::Uint32(3) };
8411
8412 pub const INVALID_KEY: DictionaryError =
8413 DictionaryError { value: ::fidl_next::wire::Uint32(4) };
8414
8415 pub const NOT_CLONEABLE: DictionaryError =
8416 DictionaryError { value: ::fidl_next::wire::Uint32(5) };
8417 }
8418
8419 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryError
8420 where
8421 ___D: ?Sized,
8422 {
8423 fn decode(
8424 slot: ::fidl_next::Slot<'_, Self>,
8425 _: &mut ___D,
8426 _: (),
8427 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8428 Ok(())
8429 }
8430 }
8431
8432 impl ::core::convert::From<crate::natural::DictionaryError> for DictionaryError {
8433 fn from(natural: crate::natural::DictionaryError) -> Self {
8434 match natural {
8435 crate::natural::DictionaryError::NotFound => DictionaryError::NOT_FOUND,
8436
8437 crate::natural::DictionaryError::AlreadyExists => DictionaryError::ALREADY_EXISTS,
8438
8439 crate::natural::DictionaryError::BadCapability => DictionaryError::BAD_CAPABILITY,
8440
8441 crate::natural::DictionaryError::InvalidKey => DictionaryError::INVALID_KEY,
8442
8443 crate::natural::DictionaryError::NotCloneable => DictionaryError::NOT_CLONEABLE,
8444
8445 crate::natural::DictionaryError::UnknownOrdinal_(value) => {
8446 DictionaryError { value: ::fidl_next::wire::Uint32::from(value) }
8447 }
8448 }
8449 }
8450 }
8451
8452 impl ::fidl_next::IntoNatural for DictionaryError {
8453 type Natural = crate::natural::DictionaryError;
8454 }
8455
8456 #[derive(Clone, Debug)]
8458 #[repr(C)]
8459 pub struct Unavailable {
8460 pub(crate) _empty: fidl_next::wire::EmptyStruct,
8461 }
8462
8463 static_assertions::const_assert_eq!(std::mem::size_of::<Unavailable>(), 1);
8464 static_assertions::const_assert_eq!(std::mem::align_of::<Unavailable>(), 1);
8465
8466 impl ::fidl_next::Constrained for Unavailable {
8467 type Constraint = ();
8468
8469 fn validate(
8470 _: ::fidl_next::Slot<'_, Self>,
8471 _: Self::Constraint,
8472 ) -> Result<(), ::fidl_next::ValidationError> {
8473 Ok(())
8474 }
8475 }
8476
8477 unsafe impl ::fidl_next::Wire for Unavailable {
8478 type Narrowed<'de> = Unavailable;
8479
8480 #[inline]
8481 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8482 ::fidl_next::munge! {
8483 let Self {
8484
8485 _empty,
8486
8487
8488 } = &mut *out_;
8489 }
8490 }
8491 }
8492
8493 unsafe impl<___D> ::fidl_next::Decode<___D> for Unavailable
8494 where
8495 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8496 {
8497 fn decode(
8498 slot_: ::fidl_next::Slot<'_, Self>,
8499 decoder_: &mut ___D,
8500 _: (),
8501 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8502 ::fidl_next::munge! {
8503 let Self {
8504
8505 mut _empty,
8506
8507
8508 } = slot_;
8509 }
8510
8511 if _empty.as_bytes() != &[0u8] {
8512 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
8513 }
8514
8515 Ok(())
8516 }
8517 }
8518
8519 impl ::fidl_next::IntoNatural for Unavailable {
8520 type Natural = crate::natural::Unavailable;
8521 }
8522}
8523
8524pub mod wire_optional {
8525
8526 #[repr(transparent)]
8527 pub struct Data<'de> {
8528 pub(crate) raw: ::fidl_next::wire::Union,
8529 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8530 }
8531
8532 impl ::fidl_next::Constrained for Data<'_> {
8533 type Constraint = ();
8534
8535 fn validate(
8536 _: ::fidl_next::Slot<'_, Self>,
8537 _: Self::Constraint,
8538 ) -> Result<(), ::fidl_next::ValidationError> {
8539 Ok(())
8540 }
8541 }
8542
8543 unsafe impl ::fidl_next::Wire for Data<'static> {
8544 type Narrowed<'de> = Data<'de>;
8545
8546 #[inline]
8547 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8548 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8549 ::fidl_next::wire::Union::zero_padding(raw);
8550 }
8551 }
8552
8553 impl<'de> Data<'de> {
8554 pub fn is_some(&self) -> bool {
8555 self.raw.is_some()
8556 }
8557
8558 pub fn is_none(&self) -> bool {
8559 self.raw.is_none()
8560 }
8561
8562 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Data<'de>> {
8563 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
8564 }
8565
8566 pub fn into_option(self) -> ::core::option::Option<crate::wire::Data<'de>> {
8567 if self.is_some() {
8568 Some(crate::wire::Data { raw: self.raw, _phantom: ::core::marker::PhantomData })
8569 } else {
8570 None
8571 }
8572 }
8573 }
8574
8575 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Data<'de>
8576 where
8577 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8578 ___D: ::fidl_next::Decoder<'de>,
8579 {
8580 fn decode(
8581 mut slot: ::fidl_next::Slot<'_, Self>,
8582 decoder: &mut ___D,
8583 _: (),
8584 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8585 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8586 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8587 1 => {
8588 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
8589 raw,
8590 decoder,
8591 (8192, ()),
8592 )?
8593 }
8594
8595 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
8596 raw, decoder, 8192,
8597 )?,
8598
8599 3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int64>(
8600 raw,
8601 decoder,
8602 (),
8603 )?,
8604
8605 4 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
8606 raw,
8607 decoder,
8608 (),
8609 )?,
8610
8611 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
8612 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
8613 }
8614
8615 Ok(())
8616 }
8617 }
8618
8619 impl<'de> ::core::fmt::Debug for Data<'de> {
8620 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8621 self.as_ref().fmt(f)
8622 }
8623 }
8624
8625 impl<'de> ::fidl_next::IntoNatural for Data<'de> {
8626 type Natural = ::core::option::Option<crate::natural::Data>;
8627 }
8628}
8629
8630pub mod generic {
8631
8632 pub struct Unit {}
8633
8634 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Unit, ___E> for Unit
8635 where
8636 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8637 {
8638 #[inline]
8639 fn encode(
8640 self,
8641 encoder_: &mut ___E,
8642 out_: &mut ::core::mem::MaybeUninit<crate::wire::Unit>,
8643 _: (),
8644 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8645 ::fidl_next::munge! {
8646 let crate::wire::Unit {
8647
8648 _empty,
8649
8650
8651 } = out_;
8652 }
8653
8654 Ok(())
8655 }
8656 }
8657
8658 pub struct CapabilityStoreDuplicateRequest<T0, T1> {
8659 pub id: T0,
8660
8661 pub dest_id: T1,
8662 }
8663
8664 unsafe impl<___E, T0, T1>
8665 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>
8666 for CapabilityStoreDuplicateRequest<T0, T1>
8667 where
8668 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8669 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8670 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8671 {
8672 #[inline]
8673 fn encode(
8674 self,
8675 encoder_: &mut ___E,
8676 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateRequest>,
8677 _: (),
8678 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8679 ::fidl_next::munge! {
8680 let crate::wire::CapabilityStoreDuplicateRequest {
8681
8682 id,
8683 dest_id,
8684
8685 } = out_;
8686 }
8687
8688 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8689
8690 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
8691
8692 Ok(())
8693 }
8694 }
8695
8696 pub struct CapabilityStoreDropRequest<T0> {
8697 pub id: T0,
8698 }
8699
8700 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>
8701 for CapabilityStoreDropRequest<T0>
8702 where
8703 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8704 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8705 {
8706 #[inline]
8707 fn encode(
8708 self,
8709 encoder_: &mut ___E,
8710 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropRequest>,
8711 _: (),
8712 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8713 ::fidl_next::munge! {
8714 let crate::wire::CapabilityStoreDropRequest {
8715
8716 id,
8717
8718 } = out_;
8719 }
8720
8721 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8722
8723 Ok(())
8724 }
8725 }
8726
8727 pub struct CapabilityStoreExportRequest<T0> {
8728 pub id: T0,
8729 }
8730
8731 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>
8732 for CapabilityStoreExportRequest<T0>
8733 where
8734 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8735 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8736 {
8737 #[inline]
8738 fn encode(
8739 self,
8740 encoder_: &mut ___E,
8741 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreExportRequest>,
8742 _: (),
8743 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8744 ::fidl_next::munge! {
8745 let crate::wire::CapabilityStoreExportRequest {
8746
8747 id,
8748
8749 } = out_;
8750 }
8751
8752 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8753
8754 Ok(())
8755 }
8756 }
8757
8758 pub struct CapabilityStoreDictionaryCreateRequest<T0> {
8759 pub id: T0,
8760 }
8761
8762 unsafe impl<___E, T0>
8763 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>
8764 for CapabilityStoreDictionaryCreateRequest<T0>
8765 where
8766 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8767 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8768 {
8769 #[inline]
8770 fn encode(
8771 self,
8772 encoder_: &mut ___E,
8773 out_: &mut ::core::mem::MaybeUninit<
8774 crate::wire::CapabilityStoreDictionaryCreateRequest,
8775 >,
8776 _: (),
8777 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8778 ::fidl_next::munge! {
8779 let crate::wire::CapabilityStoreDictionaryCreateRequest {
8780
8781 id,
8782
8783 } = out_;
8784 }
8785
8786 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8787
8788 Ok(())
8789 }
8790 }
8791
8792 pub struct DictionaryItem<T0, T1> {
8793 pub key: T0,
8794
8795 pub value: T1,
8796 }
8797
8798 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>
8799 for DictionaryItem<T0, T1>
8800 where
8801 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8802 ___E: ::fidl_next::Encoder,
8803 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8804 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8805 {
8806 #[inline]
8807 fn encode(
8808 self,
8809 encoder_: &mut ___E,
8810 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryItem<'static>>,
8811 _: (),
8812 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8813 ::fidl_next::munge! {
8814 let crate::wire::DictionaryItem {
8815
8816 key,
8817 value,
8818
8819 } = out_;
8820 }
8821
8822 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
8823
8824 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
8825
8826 Ok(())
8827 }
8828 }
8829
8830 pub struct CapabilityStoreDictionaryInsertRequest<T0, T1> {
8831 pub id: T0,
8832
8833 pub item: T1,
8834 }
8835
8836 unsafe impl<___E, T0, T1>
8837 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>
8838 for CapabilityStoreDictionaryInsertRequest<T0, T1>
8839 where
8840 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8841 ___E: ::fidl_next::Encoder,
8842 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8843 T1: ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>,
8844 {
8845 #[inline]
8846 fn encode(
8847 self,
8848 encoder_: &mut ___E,
8849 out_: &mut ::core::mem::MaybeUninit<
8850 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
8851 >,
8852 _: (),
8853 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8854 ::fidl_next::munge! {
8855 let crate::wire::CapabilityStoreDictionaryInsertRequest {
8856
8857 id,
8858 item,
8859
8860 } = out_;
8861 }
8862
8863 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8864
8865 ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
8866
8867 Ok(())
8868 }
8869 }
8870
8871 pub struct CapabilityStoreDictionaryGetRequest<T0, T1, T2> {
8872 pub id: T0,
8873
8874 pub key: T1,
8875
8876 pub dest_id: T2,
8877 }
8878
8879 unsafe impl<___E, T0, T1, T2>
8880 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>
8881 for CapabilityStoreDictionaryGetRequest<T0, T1, T2>
8882 where
8883 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8884 ___E: ::fidl_next::Encoder,
8885 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8886 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8887 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8888 {
8889 #[inline]
8890 fn encode(
8891 self,
8892 encoder_: &mut ___E,
8893 out_: &mut ::core::mem::MaybeUninit<
8894 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
8895 >,
8896 _: (),
8897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8898 ::fidl_next::munge! {
8899 let crate::wire::CapabilityStoreDictionaryGetRequest {
8900
8901 id,
8902 key,
8903 dest_id,
8904
8905 } = out_;
8906 }
8907
8908 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8909
8910 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
8911
8912 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
8913
8914 Ok(())
8915 }
8916 }
8917
8918 pub struct WrappedCapabilityId<T0> {
8919 pub id: T0,
8920 }
8921
8922 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>
8923 for WrappedCapabilityId<T0>
8924 where
8925 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8926 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8927 {
8928 #[inline]
8929 fn encode(
8930 self,
8931 encoder_: &mut ___E,
8932 out_: &mut ::core::mem::MaybeUninit<crate::wire::WrappedCapabilityId>,
8933 _: (),
8934 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8935 ::fidl_next::munge! {
8936 let crate::wire::WrappedCapabilityId {
8937
8938 id,
8939
8940 } = out_;
8941 }
8942
8943 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8944
8945 Ok(())
8946 }
8947 }
8948
8949 pub struct CapabilityStoreDictionaryRemoveRequest<T0, T1, T2> {
8950 pub id: T0,
8951
8952 pub key: T1,
8953
8954 pub dest_id: T2,
8955 }
8956
8957 unsafe impl<___E, T0, T1, T2>
8958 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>
8959 for CapabilityStoreDictionaryRemoveRequest<T0, T1, T2>
8960 where
8961 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8962 ___E: ::fidl_next::Encoder,
8963 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8964 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8965 T2: ::fidl_next::Encode<
8966 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
8967 ___E,
8968 >,
8969 {
8970 #[inline]
8971 fn encode(
8972 self,
8973 encoder_: &mut ___E,
8974 out_: &mut ::core::mem::MaybeUninit<
8975 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
8976 >,
8977 _: (),
8978 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8979 ::fidl_next::munge! {
8980 let crate::wire::CapabilityStoreDictionaryRemoveRequest {
8981
8982 id,
8983 key,
8984 dest_id,
8985
8986 } = out_;
8987 }
8988
8989 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8990
8991 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
8992
8993 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
8994
8995 Ok(())
8996 }
8997 }
8998
8999 pub struct CapabilityStoreDictionaryCopyRequest<T0, T1> {
9000 pub id: T0,
9001
9002 pub dest_id: T1,
9003 }
9004
9005 unsafe impl<___E, T0, T1>
9006 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>
9007 for CapabilityStoreDictionaryCopyRequest<T0, T1>
9008 where
9009 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9010 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9011 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9012 {
9013 #[inline]
9014 fn encode(
9015 self,
9016 encoder_: &mut ___E,
9017 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyRequest>,
9018 _: (),
9019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9020 ::fidl_next::munge! {
9021 let crate::wire::CapabilityStoreDictionaryCopyRequest {
9022
9023 id,
9024 dest_id,
9025
9026 } = out_;
9027 }
9028
9029 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
9030
9031 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
9032
9033 Ok(())
9034 }
9035 }
9036
9037 pub struct DictionaryDrainIteratorGetNextRequest<T0, T1> {
9038 pub start_id: T0,
9039
9040 pub limit: T1,
9041 }
9042
9043 unsafe impl<___E, T0, T1>
9044 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>
9045 for DictionaryDrainIteratorGetNextRequest<T0, T1>
9046 where
9047 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9048 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9049 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
9050 {
9051 #[inline]
9052 fn encode(
9053 self,
9054 encoder_: &mut ___E,
9055 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryDrainIteratorGetNextRequest>,
9056 _: (),
9057 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9058 ::fidl_next::munge! {
9059 let crate::wire::DictionaryDrainIteratorGetNextRequest {
9060
9061 start_id,
9062 limit,
9063
9064 } = out_;
9065 }
9066
9067 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
9068
9069 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
9070
9071 Ok(())
9072 }
9073 }
9074
9075 pub struct DictionaryEnumerateIteratorGetNextRequest<T0, T1> {
9076 pub start_id: T0,
9077
9078 pub limit: T1,
9079 }
9080
9081 unsafe impl<___E, T0, T1>
9082 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>
9083 for DictionaryEnumerateIteratorGetNextRequest<T0, T1>
9084 where
9085 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9086 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9087 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
9088 {
9089 #[inline]
9090 fn encode(
9091 self,
9092 encoder_: &mut ___E,
9093 out_: &mut ::core::mem::MaybeUninit<
9094 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
9095 >,
9096 _: (),
9097 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9098 ::fidl_next::munge! {
9099 let crate::wire::DictionaryEnumerateIteratorGetNextRequest {
9100
9101 start_id,
9102 limit,
9103
9104 } = out_;
9105 }
9106
9107 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
9108
9109 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
9110
9111 Ok(())
9112 }
9113 }
9114
9115 pub struct Unavailable {}
9116
9117 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Unavailable, ___E> for Unavailable
9118 where
9119 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9120 {
9121 #[inline]
9122 fn encode(
9123 self,
9124 encoder_: &mut ___E,
9125 out_: &mut ::core::mem::MaybeUninit<crate::wire::Unavailable>,
9126 _: (),
9127 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9128 ::fidl_next::munge! {
9129 let crate::wire::Unavailable {
9130
9131 _empty,
9132
9133
9134 } = out_;
9135 }
9136
9137 Ok(())
9138 }
9139 }
9140}
9141
9142pub use self::natural::*;
9143
9144#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
9145pub const MAX_NAME_LENGTH: u64 = 255 as u64;
9146
9147#[doc = " Maximum number of bytes in a [Data].\n"]
9148pub const MAX_DATA_LENGTH: u32 = 8192 as u32;
9149
9150#[derive(PartialEq, Debug)]
9152pub struct Dictionary;
9153
9154impl ::fidl_next::Discoverable for Dictionary {
9155 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
9156}
9157
9158#[cfg(target_os = "fuchsia")]
9159impl ::fidl_next::HasTransport for Dictionary {
9160 type Transport = ::fidl_next::fuchsia::zx::Channel;
9161}
9162
9163pub mod dictionary {
9164 pub mod prelude {
9165 pub use crate::{Dictionary, DictionaryClientHandler, DictionaryServerHandler, dictionary};
9166 }
9167
9168 mod ___detail {
9169 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Dictionary
9170 where
9171 ___T: ::fidl_next::Transport,
9172 {
9173 type Client = DictionaryClient<___T>;
9174 type Server = DictionaryServer<___T>;
9175 }
9176
9177 #[repr(transparent)]
9179 pub struct DictionaryClient<___T: ::fidl_next::Transport> {
9180 #[allow(dead_code)]
9181 client: ::fidl_next::protocol::Client<___T>,
9182 }
9183
9184 impl<___T> DictionaryClient<___T> where ___T: ::fidl_next::Transport {}
9185
9186 #[repr(transparent)]
9188 pub struct DictionaryServer<___T: ::fidl_next::Transport> {
9189 server: ::fidl_next::protocol::Server<___T>,
9190 }
9191
9192 impl<___T> DictionaryServer<___T> where ___T: ::fidl_next::Transport {}
9193 }
9194}
9195
9196pub trait DictionaryClientHandler<
9200 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9201 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9202>
9203{
9204 fn on_unknown_interaction(
9205 &mut self,
9206 ordinal: u64,
9207 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9208 ::core::future::ready(())
9209 }
9210}
9211
9212impl<___T> DictionaryClientHandler<___T> for ::fidl_next::IgnoreEvents
9213where
9214 ___T: ::fidl_next::Transport,
9215{
9216 async fn on_unknown_interaction(&mut self, _: u64) {}
9217}
9218
9219impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Dictionary
9220where
9221 ___H: DictionaryClientHandler<___T> + ::core::marker::Send,
9222 ___T: ::fidl_next::Transport,
9223{
9224 async fn on_event(
9225 handler: &mut ___H,
9226 ordinal: u64,
9227 flexibility: ::fidl_next::protocol::Flexibility,
9228 body: ::fidl_next::Body<___T>,
9229 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9230 match ordinal {
9231 ordinal => {
9232 handler.on_unknown_interaction(ordinal).await;
9233 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9234 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9235 } else {
9236 Ok(())
9237 }
9238 }
9239 }
9240 }
9241}
9242
9243pub trait DictionaryServerHandler<
9247 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9248 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9249>
9250{
9251 fn on_unknown_interaction(
9252 &mut self,
9253 ordinal: u64,
9254 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9255 ::core::future::ready(())
9256 }
9257}
9258
9259impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Dictionary
9260where
9261 ___H: DictionaryServerHandler<___T> + ::core::marker::Send,
9262 ___T: ::fidl_next::Transport,
9263{
9264 async fn on_one_way(
9265 handler: &mut ___H,
9266 ordinal: u64,
9267 flexibility: ::fidl_next::protocol::Flexibility,
9268 body: ::fidl_next::Body<___T>,
9269 ) -> ::core::result::Result<
9270 (),
9271 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9272 > {
9273 match ordinal {
9274 ordinal => {
9275 handler.on_unknown_interaction(ordinal).await;
9276 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9277 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9278 } else {
9279 Ok(())
9280 }
9281 }
9282 }
9283 }
9284
9285 async fn on_two_way(
9286 handler: &mut ___H,
9287 ordinal: u64,
9288 flexibility: ::fidl_next::protocol::Flexibility,
9289 body: ::fidl_next::Body<___T>,
9290 responder: ::fidl_next::protocol::Responder<___T>,
9291 ) -> ::core::result::Result<
9292 (),
9293 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9294 > {
9295 match ordinal {
9296 ordinal => {
9297 handler.on_unknown_interaction(ordinal).await;
9298 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9299 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9300 } else {
9301 responder
9302 .respond(
9303 ordinal,
9304 flexibility,
9305 ::fidl_next::Flexible::<()>::FrameworkErr(
9306 ::fidl_next::FrameworkError::UnknownMethod,
9307 ),
9308 )
9309 .expect("encoding a framework error should never fail")
9310 .await?;
9311 Ok(())
9312 }
9313 }
9314 }
9315 }
9316}
9317
9318#[doc = " Maximum number of items returned by dictionary iterator.\n"]
9319pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128 as u32;
9320
9321pub mod compat {
9323
9324 impl ::fidl_next::CompatFrom<crate::Availability>
9325 for ::fidl_fuchsia_component_sandbox::Availability
9326 {
9327 fn compat_from(value: crate::Availability) -> Self {
9328 match value {
9329 crate::Availability::Required => Self::Required,
9330
9331 crate::Availability::Optional => Self::Optional,
9332
9333 crate::Availability::SameAsTarget => Self::SameAsTarget,
9334
9335 crate::Availability::Transitional => Self::Transitional,
9336 }
9337 }
9338 }
9339
9340 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Availability>
9341 for crate::Availability
9342 {
9343 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Availability) -> Self {
9344 match value {
9345 ::fidl_fuchsia_component_sandbox::Availability::Required => Self::Required,
9346
9347 ::fidl_fuchsia_component_sandbox::Availability::Optional => Self::Optional,
9348
9349 ::fidl_fuchsia_component_sandbox::Availability::SameAsTarget => Self::SameAsTarget,
9350
9351 ::fidl_fuchsia_component_sandbox::Availability::Transitional => Self::Transitional,
9352 }
9353 }
9354 }
9355
9356 impl ::fidl_next::CompatFrom<crate::Unit> for ::fidl_fuchsia_component_sandbox::Unit {
9357 #[inline]
9358 fn compat_from(value: crate::Unit) -> Self {
9359 Self {}
9360 }
9361 }
9362
9363 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unit> for crate::Unit {
9364 #[inline]
9365 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unit) -> Self {
9366 Self {}
9367 }
9368 }
9369
9370 impl ::fidl_next::CompatFrom<crate::Data> for ::fidl_fuchsia_component_sandbox::Data {
9371 fn compat_from(value: crate::Data) -> Self {
9372 match value {
9373 crate::Data::Bytes(value) => {
9374 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
9375 }
9376
9377 crate::Data::String(value) => {
9378 Self::String(::fidl_next::CompatFrom::compat_from(value))
9379 }
9380
9381 crate::Data::Int64(value) => {
9382 Self::Int64(::fidl_next::CompatFrom::compat_from(value))
9383 }
9384
9385 crate::Data::Uint64(value) => {
9386 Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
9387 }
9388
9389 crate::Data::UnknownOrdinal_(unknown_ordinal) => {
9390 Self::__SourceBreaking { unknown_ordinal }
9391 }
9392 }
9393 }
9394 }
9395
9396 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Data> for crate::Data {
9397 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Data) -> Self {
9398 match value {
9399 ::fidl_fuchsia_component_sandbox::Data::Bytes(value) => {
9400 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
9401 }
9402
9403 ::fidl_fuchsia_component_sandbox::Data::String(value) => {
9404 Self::String(::fidl_next::CompatFrom::compat_from(value))
9405 }
9406
9407 ::fidl_fuchsia_component_sandbox::Data::Int64(value) => {
9408 Self::Int64(::fidl_next::CompatFrom::compat_from(value))
9409 }
9410
9411 ::fidl_fuchsia_component_sandbox::Data::Uint64(value) => {
9412 Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
9413 }
9414
9415 ::fidl_fuchsia_component_sandbox::Data::__SourceBreaking { unknown_ordinal } => {
9416 Self::UnknownOrdinal_(unknown_ordinal)
9417 }
9418 }
9419 }
9420 }
9421
9422 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDuplicateRequest>
9423 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest
9424 {
9425 #[inline]
9426 fn compat_from(value: crate::CapabilityStoreDuplicateRequest) -> Self {
9427 Self {
9428 id: ::fidl_next::CompatFrom::compat_from(value.id),
9429
9430 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9431 }
9432 }
9433 }
9434
9435 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest>
9436 for crate::CapabilityStoreDuplicateRequest
9437 {
9438 #[inline]
9439 fn compat_from(
9440 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest,
9441 ) -> Self {
9442 Self {
9443 id: ::fidl_next::CompatFrom::compat_from(value.id),
9444
9445 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9446 }
9447 }
9448 }
9449
9450 impl ::fidl_next::CompatFrom<crate::CapabilityStoreError>
9451 for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
9452 {
9453 fn compat_from(value: crate::CapabilityStoreError) -> Self {
9454 match value {
9455 crate::CapabilityStoreError::IdNotFound => Self::IdNotFound,
9456
9457 crate::CapabilityStoreError::IdAlreadyExists => Self::IdAlreadyExists,
9458
9459 crate::CapabilityStoreError::BadCapability => Self::BadCapability,
9460
9461 crate::CapabilityStoreError::WrongType => Self::WrongType,
9462
9463 crate::CapabilityStoreError::NotDuplicatable => Self::NotDuplicatable,
9464
9465 crate::CapabilityStoreError::ItemNotFound => Self::ItemNotFound,
9466
9467 crate::CapabilityStoreError::ItemAlreadyExists => Self::ItemAlreadyExists,
9468
9469 crate::CapabilityStoreError::InvalidKey => Self::InvalidKey,
9470
9471 crate::CapabilityStoreError::InvalidArgs => Self::InvalidArgs,
9472
9473 crate::CapabilityStoreError::UnknownOrdinal_(unknown_ordinal) => {
9474 Self::__SourceBreaking { unknown_ordinal }
9475 }
9476 }
9477 }
9478 }
9479
9480 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreError>
9481 for crate::CapabilityStoreError
9482 {
9483 fn compat_from(value: ::fidl_fuchsia_component_sandbox::CapabilityStoreError) -> Self {
9484 match value {
9485 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdNotFound => {
9486 Self::IdNotFound
9487 }
9488
9489 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdAlreadyExists => {
9490 Self::IdAlreadyExists
9491 }
9492
9493 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::BadCapability => {
9494 Self::BadCapability
9495 }
9496
9497 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::WrongType => {
9498 Self::WrongType
9499 }
9500
9501 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::NotDuplicatable => {
9502 Self::NotDuplicatable
9503 }
9504
9505 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemNotFound => {
9506 Self::ItemNotFound
9507 }
9508
9509 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemAlreadyExists => {
9510 Self::ItemAlreadyExists
9511 }
9512
9513 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidKey => {
9514 Self::InvalidKey
9515 }
9516
9517 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidArgs => {
9518 Self::InvalidArgs
9519 }
9520
9521 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::__SourceBreaking {
9522 unknown_ordinal: value,
9523 } => Self::UnknownOrdinal_(value),
9524 }
9525 }
9526 }
9527
9528 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDropRequest>
9529 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest
9530 {
9531 #[inline]
9532 fn compat_from(value: crate::CapabilityStoreDropRequest) -> Self {
9533 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9534 }
9535 }
9536
9537 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest>
9538 for crate::CapabilityStoreDropRequest
9539 {
9540 #[inline]
9541 fn compat_from(
9542 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest,
9543 ) -> Self {
9544 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9545 }
9546 }
9547
9548 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportRequest>
9549 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest
9550 {
9551 #[inline]
9552 fn compat_from(value: crate::CapabilityStoreExportRequest) -> Self {
9553 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9554 }
9555 }
9556
9557 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest>
9558 for crate::CapabilityStoreExportRequest
9559 {
9560 #[inline]
9561 fn compat_from(
9562 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest,
9563 ) -> Self {
9564 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9565 }
9566 }
9567
9568 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCreateRequest>
9569 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest
9570 {
9571 #[inline]
9572 fn compat_from(value: crate::CapabilityStoreDictionaryCreateRequest) -> Self {
9573 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9574 }
9575 }
9576
9577 impl
9578 ::fidl_next::CompatFrom<
9579 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
9580 > for crate::CapabilityStoreDictionaryCreateRequest
9581 {
9582 #[inline]
9583 fn compat_from(
9584 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
9585 ) -> Self {
9586 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9587 }
9588 }
9589
9590 impl ::fidl_next::CompatFrom<crate::DictionaryItem>
9591 for ::fidl_fuchsia_component_sandbox::DictionaryItem
9592 {
9593 #[inline]
9594 fn compat_from(value: crate::DictionaryItem) -> Self {
9595 Self {
9596 key: ::fidl_next::CompatFrom::compat_from(value.key),
9597
9598 value: ::fidl_next::CompatFrom::compat_from(value.value),
9599 }
9600 }
9601 }
9602
9603 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryItem>
9604 for crate::DictionaryItem
9605 {
9606 #[inline]
9607 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryItem) -> Self {
9608 Self {
9609 key: ::fidl_next::CompatFrom::compat_from(value.key),
9610
9611 value: ::fidl_next::CompatFrom::compat_from(value.value),
9612 }
9613 }
9614 }
9615
9616 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryInsertRequest>
9617 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest
9618 {
9619 #[inline]
9620 fn compat_from(value: crate::CapabilityStoreDictionaryInsertRequest) -> Self {
9621 Self {
9622 id: ::fidl_next::CompatFrom::compat_from(value.id),
9623
9624 item: ::fidl_next::CompatFrom::compat_from(value.item),
9625 }
9626 }
9627 }
9628
9629 impl
9630 ::fidl_next::CompatFrom<
9631 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
9632 > for crate::CapabilityStoreDictionaryInsertRequest
9633 {
9634 #[inline]
9635 fn compat_from(
9636 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
9637 ) -> Self {
9638 Self {
9639 id: ::fidl_next::CompatFrom::compat_from(value.id),
9640
9641 item: ::fidl_next::CompatFrom::compat_from(value.item),
9642 }
9643 }
9644 }
9645
9646 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryGetRequest>
9647 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest
9648 {
9649 #[inline]
9650 fn compat_from(value: crate::CapabilityStoreDictionaryGetRequest) -> Self {
9651 Self {
9652 id: ::fidl_next::CompatFrom::compat_from(value.id),
9653
9654 key: ::fidl_next::CompatFrom::compat_from(value.key),
9655
9656 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9657 }
9658 }
9659 }
9660
9661 impl
9662 ::fidl_next::CompatFrom<
9663 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
9664 > for crate::CapabilityStoreDictionaryGetRequest
9665 {
9666 #[inline]
9667 fn compat_from(
9668 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
9669 ) -> Self {
9670 Self {
9671 id: ::fidl_next::CompatFrom::compat_from(value.id),
9672
9673 key: ::fidl_next::CompatFrom::compat_from(value.key),
9674
9675 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9676 }
9677 }
9678 }
9679
9680 impl ::fidl_next::CompatFrom<crate::WrappedCapabilityId>
9681 for ::fidl_fuchsia_component_sandbox::WrappedCapabilityId
9682 {
9683 #[inline]
9684 fn compat_from(value: crate::WrappedCapabilityId) -> Self {
9685 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9686 }
9687 }
9688
9689 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::WrappedCapabilityId>
9690 for crate::WrappedCapabilityId
9691 {
9692 #[inline]
9693 fn compat_from(value: ::fidl_fuchsia_component_sandbox::WrappedCapabilityId) -> Self {
9694 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
9695 }
9696 }
9697
9698 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryRemoveRequest>
9699 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest
9700 {
9701 #[inline]
9702 fn compat_from(value: crate::CapabilityStoreDictionaryRemoveRequest) -> Self {
9703 Self {
9704 id: ::fidl_next::CompatFrom::compat_from(value.id),
9705
9706 key: ::fidl_next::CompatFrom::compat_from(value.key),
9707
9708 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9709 }
9710 }
9711 }
9712
9713 impl
9714 ::fidl_next::CompatFrom<
9715 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
9716 > for crate::CapabilityStoreDictionaryRemoveRequest
9717 {
9718 #[inline]
9719 fn compat_from(
9720 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
9721 ) -> Self {
9722 Self {
9723 id: ::fidl_next::CompatFrom::compat_from(value.id),
9724
9725 key: ::fidl_next::CompatFrom::compat_from(value.key),
9726
9727 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9728 }
9729 }
9730 }
9731
9732 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCopyRequest>
9733 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest
9734 {
9735 #[inline]
9736 fn compat_from(value: crate::CapabilityStoreDictionaryCopyRequest) -> Self {
9737 Self {
9738 id: ::fidl_next::CompatFrom::compat_from(value.id),
9739
9740 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9741 }
9742 }
9743 }
9744
9745 impl
9746 ::fidl_next::CompatFrom<
9747 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
9748 > for crate::CapabilityStoreDictionaryCopyRequest
9749 {
9750 #[inline]
9751 fn compat_from(
9752 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
9753 ) -> Self {
9754 Self {
9755 id: ::fidl_next::CompatFrom::compat_from(value.id),
9756
9757 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
9758 }
9759 }
9760 }
9761
9762 impl ::fidl_next::CompatFrom<crate::RouterError> for ::fidl_fuchsia_component_sandbox::RouterError {
9763 fn compat_from(value: crate::RouterError) -> Self {
9764 match value {
9765 crate::RouterError::NotFound => Self::NotFound,
9766
9767 crate::RouterError::InvalidArgs => Self::InvalidArgs,
9768
9769 crate::RouterError::NotSupported => Self::NotSupported,
9770
9771 crate::RouterError::Internal => Self::Internal,
9772
9773 crate::RouterError::UnknownOrdinal_(unknown_ordinal) => {
9774 Self::__SourceBreaking { unknown_ordinal }
9775 }
9776 }
9777 }
9778 }
9779
9780 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouterError> for crate::RouterError {
9781 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouterError) -> Self {
9782 match value {
9783 ::fidl_fuchsia_component_sandbox::RouterError::NotFound => Self::NotFound,
9784
9785 ::fidl_fuchsia_component_sandbox::RouterError::InvalidArgs => Self::InvalidArgs,
9786
9787 ::fidl_fuchsia_component_sandbox::RouterError::NotSupported => Self::NotSupported,
9788
9789 ::fidl_fuchsia_component_sandbox::RouterError::Internal => Self::Internal,
9790
9791 ::fidl_fuchsia_component_sandbox::RouterError::__SourceBreaking {
9792 unknown_ordinal: value,
9793 } => Self::UnknownOrdinal_(value),
9794 }
9795 }
9796 }
9797
9798 #[cfg(target_os = "fuchsia")]
9799 pub type DictionaryProxy = ::fidl_next::Client<crate::Dictionary>;
9802
9803 impl ::fidl_next::CompatFrom<crate::Dictionary>
9804 for ::fidl_fuchsia_component_sandbox::DictionaryMarker
9805 {
9806 fn compat_from(_: crate::Dictionary) -> Self {
9807 Self
9808 }
9809 }
9810
9811 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryMarker>
9812 for crate::Dictionary
9813 {
9814 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryMarker) -> Self {
9815 Self
9816 }
9817 }
9818
9819 #[cfg(target_os = "fuchsia")]
9820
9821 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryProxy>
9822 for crate::Dictionary
9823 {
9824 fn client_compat_from(
9825 proxy: ::fidl_fuchsia_component_sandbox::DictionaryProxy,
9826 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
9827 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
9828 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
9829 ::fidl_next::ClientDispatcher::new(client_end)
9830 }
9831 }
9832
9833 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextRequest>
9834 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest
9835 {
9836 #[inline]
9837 fn compat_from(value: crate::DictionaryDrainIteratorGetNextRequest) -> Self {
9838 Self {
9839 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
9840
9841 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
9842 }
9843 }
9844 }
9845
9846 impl
9847 ::fidl_next::CompatFrom<
9848 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
9849 > for crate::DictionaryDrainIteratorGetNextRequest
9850 {
9851 #[inline]
9852 fn compat_from(
9853 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
9854 ) -> Self {
9855 Self {
9856 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
9857
9858 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
9859 }
9860 }
9861 }
9862
9863 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextRequest>
9864 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest
9865 {
9866 #[inline]
9867 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextRequest) -> Self {
9868 Self {
9869 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
9870
9871 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
9872 }
9873 }
9874 }
9875
9876 impl
9877 ::fidl_next::CompatFrom<
9878 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
9879 > for crate::DictionaryEnumerateIteratorGetNextRequest
9880 {
9881 #[inline]
9882 fn compat_from(
9883 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
9884 ) -> Self {
9885 Self {
9886 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
9887
9888 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
9889 }
9890 }
9891 }
9892
9893 impl ::fidl_next::CompatFrom<crate::DictionaryError>
9894 for ::fidl_fuchsia_component_sandbox::DictionaryError
9895 {
9896 fn compat_from(value: crate::DictionaryError) -> Self {
9897 match value {
9898 crate::DictionaryError::NotFound => Self::NotFound,
9899
9900 crate::DictionaryError::AlreadyExists => Self::AlreadyExists,
9901
9902 crate::DictionaryError::BadCapability => Self::BadCapability,
9903
9904 crate::DictionaryError::InvalidKey => Self::InvalidKey,
9905
9906 crate::DictionaryError::NotCloneable => Self::NotCloneable,
9907
9908 crate::DictionaryError::UnknownOrdinal_(unknown_ordinal) => {
9909 Self::__SourceBreaking { unknown_ordinal }
9910 }
9911 }
9912 }
9913 }
9914
9915 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryError>
9916 for crate::DictionaryError
9917 {
9918 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryError) -> Self {
9919 match value {
9920 ::fidl_fuchsia_component_sandbox::DictionaryError::NotFound => Self::NotFound,
9921
9922 ::fidl_fuchsia_component_sandbox::DictionaryError::AlreadyExists => {
9923 Self::AlreadyExists
9924 }
9925
9926 ::fidl_fuchsia_component_sandbox::DictionaryError::BadCapability => {
9927 Self::BadCapability
9928 }
9929
9930 ::fidl_fuchsia_component_sandbox::DictionaryError::InvalidKey => Self::InvalidKey,
9931
9932 ::fidl_fuchsia_component_sandbox::DictionaryError::NotCloneable => {
9933 Self::NotCloneable
9934 }
9935
9936 ::fidl_fuchsia_component_sandbox::DictionaryError::__SourceBreaking {
9937 unknown_ordinal: value,
9938 } => Self::UnknownOrdinal_(value),
9939 }
9940 }
9941 }
9942
9943 impl ::fidl_next::CompatFrom<crate::Unavailable> for ::fidl_fuchsia_component_sandbox::Unavailable {
9944 #[inline]
9945 fn compat_from(value: crate::Unavailable) -> Self {
9946 Self {}
9947 }
9948 }
9949
9950 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unavailable> for crate::Unavailable {
9951 #[inline]
9952 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unavailable) -> Self {
9953 Self {}
9954 }
9955 }
9956}