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